X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fmcs51%2Fralloc.c;h=fedf008f7e476bdddefc78f33d1a14c78ce040be;hb=8cdaa82bb9312e9ff4f965b4d9662d11ae0add10;hp=25dedea76aa169612f750142604e2fb36f60f1d1;hpb=9ab7652d61a70e7caae9e93ad80d87b98cd93bca;p=fw%2Fsdcc

diff --git a/src/mcs51/ralloc.c b/src/mcs51/ralloc.c
index 25dedea7..fedf008f 100644
--- a/src/mcs51/ralloc.c
+++ b/src/mcs51/ralloc.c
@@ -1,3 +1,9 @@
+//#define LIVERANGEHUNT
+#ifdef LIVERANGEHUNT
+  #define LRH(x) x
+#else
+  #define LRH(x)
+#endif
 /*------------------------------------------------------------------------
 
   SDCCralloc.c - source file for register allocation. (8051) specific
@@ -37,6 +43,7 @@
 /*-----------------------------------------------------------------*/
 
 extern void gen51Code (iCode *);
+#define D(x)
 
 /* Global data */
 static struct
@@ -44,6 +51,7 @@ static struct
     bitVect *spiltSet;
     set *stackSpil;
     bitVect *regAssigned;
+    bitVect *totRegAssigned;    /* final set of LRs that got into registers */
     short blockSpil;
     int slocNum;
     bitVect *funcrUsed;		/* registers used in a function */
@@ -76,6 +84,7 @@ regs regs8051[] =
 };
 int mcs51_nRegs = 13;
 static void spillThis (symbol *);
+static void freeAllRegs ();
 
 /*-----------------------------------------------------------------*/
 /* allocReg - allocates register of given type                     */
@@ -179,31 +188,13 @@ nfreeRegsType (int type)
   return nFreeRegs (type);
 }
 
-
 /*-----------------------------------------------------------------*/
-/* allDefsOutOfRange - all definitions are out of a range          */
+/* useReg - marks a register  as used                              */
 /*-----------------------------------------------------------------*/
-static bool
-allDefsOutOfRange (bitVect * defs, int fseq, int toseq)
+static void
+useReg (regs * reg)
 {
-  int i;
-
-  if (!defs)
-    return TRUE;
-
-  for (i = 0; i < defs->size; i++)
-    {
-      iCode *ic;
-
-      if (bitVectBitValue (defs, i) &&
-	  (ic = hTabItemWithKey (iCodehTab, i)) &&
-	  (ic->seq >= fseq && ic->seq <= toseq))
-
-	return FALSE;
-
-    }
-
-  return TRUE;
+  reg->isFree = 0;
 }
 
 /*-----------------------------------------------------------------*/
@@ -282,17 +273,6 @@ rematable (symbol * sym, eBBlock * ebp, iCode * ic)
   return sym->remat;
 }
 
-/*-----------------------------------------------------------------*/
-/* notUsedInBlock - not used in this block                         */
-/*-----------------------------------------------------------------*/
-static int
-notUsedInBlock (symbol * sym, eBBlock * ebp, iCode * ic)
-{
-  return (!bitVectBitsInCommon (sym->defs, ebp->usesDefs) &&
-	  allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
-/*     return (!bitVectBitsInCommon(sym->defs,ebp->usesDefs)); */
-}
-
 /*-----------------------------------------------------------------*/
 /* notUsedInRemaining - not used or defined in remain of the block */
 /*-----------------------------------------------------------------*/
@@ -393,11 +373,7 @@ noOverLap (set * itmpStack, symbol * fsym)
   for (sym = setFirstItem (itmpStack); sym;
        sym = setNextItem (itmpStack))
     {
-	    if (sym->liveFrom < fsym->liveTo &&
-		sym->liveTo   > fsym->liveTo) return 0;
-
-	    if (sym->liveFrom < fsym->liveFrom &&
-		sym->liveTo > fsym->liveFrom) return 0;
+	if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
     }
 
   return 1;
@@ -455,8 +431,7 @@ spillLRWithPtrReg (symbol * forSym)
     {
       int j;
 
-      /* if no registers assigned to it or
-         spilt */
+      /* if no registers assigned to it or spilt */
       /* if it does not overlap with this then 
          not need to spill it */
 
@@ -518,6 +493,9 @@ createStackSpil (symbol * sym)
   sloc->etype = getSpec (sloc->type);
   SPEC_SCLS (sloc->etype) = S_DATA;
   SPEC_EXTR (sloc->etype) = 0;
+  SPEC_STAT (sloc->etype) = 0;
+  SPEC_VOLATILE(sloc->etype) = 0;
+  SPEC_ABSA(sloc->etype) = 0;
 
   /* we don't allow it to be allocated`
      onto the external stack since : so we
@@ -599,12 +577,13 @@ spillThis (symbol * sym)
   if (!(sym->remat || sym->usl.spillLoc))
     createStackSpil (sym);
 
-
+  LRH(printf("spillThis: %s\n", sym->name));
   /* mark it has spilt & put it in the spilt set */
-  sym->isspilt = 1;
+  sym->isspilt = sym->spillA = 1;
   _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
 
   bitVectUnSetBit (_G.regAssigned, sym->key);
+  bitVectUnSetBit (_G.totRegAssigned, sym->key);
 
   for (i = 0; i < sym->nRegs; i++)
 
@@ -624,7 +603,7 @@ spillThis (symbol * sym)
     }
 
   if (sym->usl.spillLoc && !sym->remat)
-    sym->usl.spillLoc->allocreq = 1;
+    sym->usl.spillLoc->allocreq++;
   return;
 }
 
@@ -658,7 +637,7 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
 			   sym->usl.spillLoc->name));
       sym->spildir = 1;
       /* mark it as allocation required */
-      sym->usl.spillLoc->allocreq = 1;
+      sym->usl.spillLoc->allocreq++;
       return sym;
     }
 
@@ -703,7 +682,7 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
 
       sym = leastUsedLR (selectS);
       /* mark this as allocation required */
-      sym->usl.spillLoc->allocreq = 1;
+      sym->usl.spillLoc->allocreq++;
       return sym;
     }
 
@@ -712,7 +691,7 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
     {
 
       sym = leastUsedLR (selectS);
-      sym->usl.spillLoc->allocreq = 1;
+      sym->usl.spillLoc->allocreq++;
       return sym;
     }
 
@@ -724,7 +703,7 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
 
       /* return a created spil location */
       sym = createStackSpil (leastUsedLR (selectS));
-      sym->usl.spillLoc->allocreq = 1;
+      sym->usl.spillLoc->allocreq++;
       return sym;
     }
 
@@ -746,14 +725,16 @@ spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
 
   /* get something we can spil */
   ssym = selectSpil (ic, ebp, forSym);
+  LRH(printf("spilSomething: spilled %s for %s\n", ssym->name, forSym->name));
 
   /* mark it as spilt */
-  ssym->isspilt = 1;
+  ssym->isspilt = ssym->spillA = 1;
   _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
 
   /* mark it as not register assigned &
      take it away from the set */
   bitVectUnSetBit (_G.regAssigned, ssym->key);
+  bitVectUnSetBit (_G.totRegAssigned, ssym->key);
 
   /* mark the registers as free */
   for (i = 0; i < ssym->nRegs; i++)
@@ -854,6 +835,47 @@ tryAgain:
   goto tryAgain;
 }
 
+/*-----------------------------------------------------------------*/
+/* getRegPtrNoSpil - get it cannot split                           */
+/*-----------------------------------------------------------------*/
+static regs *getRegPtrNoSpil()
+{
+  regs *reg;
+
+  /* try for a ptr type */
+  if ((reg = allocReg (REG_PTR)))
+    return reg;
+
+  /* try for gpr type */
+  if ((reg = allocReg (REG_GPR)))
+    return reg;
+
+  assert(0);
+
+  /* just to make the compiler happy */
+  return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* getRegGprNoSpil - get it cannot split                           */
+/*-----------------------------------------------------------------*/
+static regs *getRegGprNoSpil()
+{
+
+  regs *reg;
+  if ((reg = allocReg (REG_GPR)))
+    return reg;
+
+  if (!mcs51_ptrRegReq)
+    if ((reg = allocReg (REG_PTR)))
+      return reg;
+
+  assert(0);
+
+  /* just to make the compiler happy */
+  return 0;
+}
+
 /*-----------------------------------------------------------------*/
 /* symHasReg - symbol has a given register                         */
 /*-----------------------------------------------------------------*/
@@ -953,6 +975,7 @@ deassignLRs (iCode * ic, eBBlock * ebp)
 		  result->regs[i] = getRegGpr (ic, ebp, result);
 
 	      _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
+	      _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
 
 	    }
 
@@ -982,10 +1005,11 @@ reassignLR (operand * op)
   int i;
 
   /* not spilt any more */
-  sym->isspilt = sym->blockSpil = sym->remainSpil = 0;
+  sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
   bitVectUnSetBit (_G.spiltSet, sym->key);
 
   _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
+  _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
 
   _G.blockSpil--;
 
@@ -1035,15 +1059,16 @@ willCauseSpill (int nr, int rt)
 /* ult and operand, if this happens make sure they are in the same */
 /* position as the operand otherwise chaos results                 */
 /*-----------------------------------------------------------------*/
-static void
-positionRegs (symbol * result, symbol * opsym, int lineno)
+static int
+positionRegs (symbol * result, symbol * opsym)
 {
   int count = min (result->nRegs, opsym->nRegs);
   int i, j = 0, shared = 0;
+  int change = 0;
 
   /* if the result has been spilt then cannot share */
   if (opsym->isspilt)
-    return;
+    return 0;
 again:
   shared = 0;
   /* first make sure that they actually share */
@@ -1064,8 +1089,10 @@ xchgPositions:
       regs *tmp = result->regs[i];
       result->regs[i] = result->regs[j];
       result->regs[j] = tmp;
+      change ++;
       goto again;
     }
+  return change;
 }
 
 /*-----------------------------------------------------------------*/
@@ -1074,158 +1101,263 @@ xchgPositions:
 static void
 serialRegAssign (eBBlock ** ebbs, int count)
 {
-  int i;
+    int i;
 
-  /* for all blocks */
-  for (i = 0; i < count; i++)
-    {
+    /* for all blocks */
+    for (i = 0; i < count; i++) {
 
-      iCode *ic;
+	iCode *ic;
 
-      if (ebbs[i]->noPath &&
-	  (ebbs[i]->entryLabel != entryLabel &&
-	   ebbs[i]->entryLabel != returnLabel))
-	continue;
+	if (ebbs[i]->noPath &&
+	    (ebbs[i]->entryLabel != entryLabel &&
+	     ebbs[i]->entryLabel != returnLabel))
+	    continue;
 
-      /* of all instructions do */
-      for (ic = ebbs[i]->sch; ic; ic = ic->next)
-	{
+	/* of all instructions do */
+	for (ic = ebbs[i]->sch; ic; ic = ic->next) {
 
-	  /* if this is an ipop that means some live
-	     range will have to be assigned again */
-	  if (ic->op == IPOP)
-	    reassignLR (IC_LEFT (ic));
-
-	  /* if result is present && is a true symbol */
-	  if (IC_RESULT (ic) && ic->op != IFX &&
-	      IS_TRUE_SYMOP (IC_RESULT (ic)))
-	    OP_SYMBOL (IC_RESULT (ic))->allocreq = 1;
-
-	  /* take away registers from live
-	     ranges that end at this instruction */
-	  deassignLRs (ic, ebbs[i]);
-
-	  /* some don't need registers */
-	  if (SKIP_IC2 (ic) ||
-	      ic->op == JUMPTABLE ||
-	      ic->op == IFX ||
-	      ic->op == IPUSH ||
-	      ic->op == IPOP ||
-	      (IC_RESULT (ic) && POINTER_SET (ic)))
-	    continue;
+	    /* if this is an ipop that means some live
+	       range will have to be assigned again */
+	    if (ic->op == IPOP)
+		reassignLR (IC_LEFT (ic));
 
-	  /* now we need to allocate registers
-	     only for the result */
-	  if (IC_RESULT (ic))
-	    {
-	      symbol *sym = OP_SYMBOL (IC_RESULT (ic));
-	      bitVect *spillable;
-	      int willCS;
-	      int j;
-	      int ptrRegSet = 0;
-
-	      /* if it does not need or is spilt 
-	         or is already assigned to registers
-	         or will not live beyond this instructions */
-	      if (!sym->nRegs ||
-		  sym->isspilt ||
-		  bitVectBitValue (_G.regAssigned, sym->key) ||
-		  sym->liveTo <= ic->seq)
-		continue;
+	    /* if result is present && is a true symbol */
+	    if (IC_RESULT (ic) && ic->op != IFX &&
+		IS_TRUE_SYMOP (IC_RESULT (ic)))
+		OP_SYMBOL (IC_RESULT (ic))->allocreq++;
 
-	      /* if some liverange has been spilt at the block level
-	         and this one live beyond this block then spil this
-	         to be safe */
-	      if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
-		{
-		  spillThis (sym);
-		  continue;
-		}
-	      /* if trying to allocate this will cause
-	         a spill and there is nothing to spill 
-	         or this one is rematerializable then
-	         spill this one */
-	      willCS = willCauseSpill (sym->nRegs, sym->regType);
-	      spillable = computeSpillable (ic);
-	      if (sym->remat ||
-		  (willCS && bitVectIsZero (spillable)))
-		{
+	    /* take away registers from live
+	       ranges that end at this instruction */
+	    deassignLRs (ic, ebbs[i]);
 
-		  spillThis (sym);
-		  continue;
+	    /* some don't need registers */
+	    if (SKIP_IC2 (ic) ||
+		ic->op == JUMPTABLE ||
+		ic->op == IFX ||
+		ic->op == IPUSH ||
+		ic->op == IPOP ||
+		(IC_RESULT (ic) && POINTER_SET (ic)))
+		continue;
 
+	    /* now we need to allocate registers
+	       only for the result */
+	    if (IC_RESULT (ic)) {
+		symbol *sym = OP_SYMBOL (IC_RESULT (ic));
+		bitVect *spillable;
+		int willCS;
+		int j;
+		int ptrRegSet = 0;
+
+		/* if it does not need or is spilt 
+		   or is already assigned to registers
+		   or will not live beyond this instructions */
+		if (!sym->nRegs ||
+		    sym->isspilt ||
+		    bitVectBitValue (_G.regAssigned, sym->key) ||
+		    sym->liveTo <= ic->seq)
+		    continue;
+
+		/* if some liverange has been spilt at the block level
+		   and this one live beyond this block then spil this
+		   to be safe */
+		if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) {
+		    spillThis (sym);
+		    continue;
+		}
+		/* if trying to allocate this will cause
+		   a spill and there is nothing to spill 
+		   or this one is rematerializable then
+		   spill this one */
+		willCS = willCauseSpill (sym->nRegs, sym->regType);
+		spillable = computeSpillable (ic);
+		if (sym->remat || (willCS && bitVectIsZero (spillable))) {		      
+		    spillThis (sym);
+		    continue;		      
 		}
 
-	      /* if it has a spillocation & is used less than
-	         all other live ranges then spill this */
-	      if (willCS && sym->usl.spillLoc)
-		{
-
-		  symbol *leastUsed =
-		  leastUsedLR (liveRangesWith (spillable,
-					       allLRs,
-					       ebbs[i],
-					       ic));
-		  if (leastUsed &&
-		      leastUsed->used > sym->used)
-		    {
-		      spillThis (sym);
-		      continue;
+		/* if it has a spillocation & is used less than
+		   all other live ranges then spill this */
+		if (willCS) {
+		    if (sym->usl.spillLoc) {
+			symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
+									 allLRs, ebbs[i], ic));
+			if (leastUsed && leastUsed->used > sym->used) {
+			    spillThis (sym);
+			    continue;
+			}
+		    } else {
+			/* if none of the liveRanges have a spillLocation then better
+			   to spill this one than anything else already assigned to registers */
+			if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
+			    /* if this is local to this block then we might find a block spil */
+			    if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
+				spillThis (sym);
+				continue;
+			    }
+			}
+		    }
+		}
+		/* if we need ptr regs for the right side
+		   then mark it */
+		if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
+		    && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) {
+		    mcs51_ptrRegReq++;
+		    ptrRegSet = 1;
+		}
+		/* else we assign registers to it */
+		_G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
+		_G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
+
+		for (j = 0; j < sym->nRegs; j++) {
+		    if (sym->regType == REG_PTR)
+			sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
+		    else
+			sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
+
+		    /* if the allocation failed which means
+		       this was spilt then break */
+		    if (!sym->regs[j]) {
+		      break;
 		    }
 		}
 
-	      /* if we need ptr regs for the right side
-	         then mark it */
-	      if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
-		  && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
-		  <= PTRSIZE)
-		{
-		  mcs51_ptrRegReq++;
-		  ptrRegSet = 1;
+		/* if it shares registers with operands make sure
+		   that they are in the same position */
+		if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
+		    OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=') {
+		    positionRegs (OP_SYMBOL (IC_RESULT (ic)),
+				  OP_SYMBOL (IC_LEFT (ic)));
+		}
+		/* do the same for the right operand */
+		if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
+		    OP_SYMBOL (IC_RIGHT (ic))->nRegs) {
+		    positionRegs (OP_SYMBOL (IC_RESULT (ic)),
+				  OP_SYMBOL (IC_RIGHT (ic)));
 		}
-	      /* else we assign registers to it */
-	      _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
 
-	      for (j = 0; j < sym->nRegs; j++)
-		{
-		  if (sym->regType == REG_PTR)
-		    sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
-		  else
-		    sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
+		if (ptrRegSet) {
+		    mcs51_ptrRegReq--;
+		    ptrRegSet = 0;
+		}
+
+	    }
+	}
+    }
+}
 
-		  /* if the allocation falied which means
-		     this was spilt then break */
-		  if (!sym->regs[j])
-		    break;
+/*-----------------------------------------------------------------*/
+/* fillGaps - Try to fill in the Gaps left by Pass1                */
+/*-----------------------------------------------------------------*/
+static void fillGaps()
+{
+    symbol *sym =NULL;
+    int key =0;    
+    
+    if (getenv("DISABLE_FILL_GAPS")) return;
+    
+    /* look for livernages that was spilt by the allocator */
+    for (sym = hTabFirstItem(liveRanges,&key) ; sym ; 
+	 sym = hTabNextItem(liveRanges,&key)) {
+
+	int i;
+	int pdone = 0;
+
+	if (!sym->spillA || !sym->clashes || sym->remat) continue ;
+
+	/* find the liveRanges this one clashes with, that are
+	   still assigned to registers & mark the registers as used*/
+	for ( i = 0 ; i < sym->clashes->size ; i ++) {
+	    int k;
+	    symbol *clr;
+
+	    if (bitVectBitValue(sym->clashes,i) == 0 ||    /* those that clash with this */
+		bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
+		continue ;
+
+		clr = hTabItemWithKey(liveRanges,i);
+	    assert(clr);
+	 
+	    /* mark these registers as used */
+	    for (k = 0 ; k < clr->nRegs ; k++ ) 
+		useReg(clr->regs[k]);
+	}
+
+	if (willCauseSpill(sym->nRegs,sym->regType)) {
+	    /* NOPE :( clear all registers & and continue */
+	    freeAllRegs();
+	    continue ;
+	}
+
+	/* THERE IS HOPE !!!! */
+	for (i=0; i < sym->nRegs ; i++ ) {
+	    if (sym->regType == REG_PTR)
+		sym->regs[i] = getRegPtrNoSpil ();
+	    else
+		sym->regs[i] = getRegGprNoSpil ();		  
+	}
+
+	/* for all its definitions check if the registers
+	   allocated needs positioning NOTE: we can position
+	   only ONCE if more than One positioning required 
+	   then give up */
+	sym->isspilt = 0;
+	for (i = 0 ; i < sym->defs->size ; i++ ) {
+	    if (bitVectBitValue(sym->defs,i)) {
+		iCode *ic;
+		if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
+		if (SKIP_IC(ic)) continue;
+		assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
+		/* if left is assigned to registers */
+		if (IS_SYMOP(IC_LEFT(ic)) && 
+		    bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
+		    pdone += positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)));
 		}
-	      /* if it shares registers with operands make sure
-	         that they are in the same position */
-	      if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
-		  OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=')
-		positionRegs (OP_SYMBOL (IC_RESULT (ic)),
-			      OP_SYMBOL (IC_LEFT (ic)), ic->lineno);
-	      /* do the same for the right operand */
-	      if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
-		  OP_SYMBOL (IC_RIGHT (ic))->nRegs)
-		positionRegs (OP_SYMBOL (IC_RESULT (ic)),
-			      OP_SYMBOL (IC_RIGHT (ic)), ic->lineno);
-
-	      if (ptrRegSet)
-		{
-		  mcs51_ptrRegReq--;
-		  ptrRegSet = 0;
+		if (IS_SYMOP(IC_RIGHT(ic)) && 
+		    bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
+		    pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)));
 		}
-
+		if (pdone > 1) break;
+	    }
+	}
+	for (i = 0 ; i < sym->uses->size ; i++ ) {
+	    if (bitVectBitValue(sym->uses,i)) {
+		iCode *ic;
+		if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
+		if (SKIP_IC(ic)) continue;
+		if (!IS_ASSIGN_ICODE(ic)) continue ;
+
+		/* if result is assigned to registers */
+		if (IS_SYMOP(IC_RESULT(ic)) && 
+		    bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
+		    pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)));
+		}
+		if (pdone > 1) break;
+	    }
+	}
+	/* had to position more than once GIVE UP */
+	if (pdone > 1) {
+	    /* UNDO all the changes we made to try this */
+	    sym->isspilt = 1;
+	    for (i=0; i < sym->nRegs ; i++ ) {
+		    sym->regs[i] = NULL;
 	    }
+	    freeAllRegs();
+	    D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
+	    continue ;	    
 	}
+	D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
+	_G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
+	sym->isspilt = sym->spillA = 0 ;
+	sym->usl.spillLoc->allocreq--;
+	freeAllRegs();
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* rUmaskForOp :- returns register mask for an operand             */
 /*-----------------------------------------------------------------*/
-static bitVect *
-rUmaskForOp (operand * op)
+bitVect *
+mcs51_rUmaskForOp (operand * op)
 {
   bitVect *rumask;
   symbol *sym;
@@ -1265,7 +1397,7 @@ regsUsedIniCode (iCode * ic)
   if (ic->op == IFX)
     {
       rmask = bitVectUnion (rmask,
-			    rUmaskForOp (IC_COND (ic)));
+			    mcs51_rUmaskForOp (IC_COND (ic)));
       goto ret;
     }
 
@@ -1273,7 +1405,7 @@ regsUsedIniCode (iCode * ic)
   if (ic->op == JUMPTABLE)
     {
       rmask = bitVectUnion (rmask,
-			    rUmaskForOp (IC_JTCOND (ic)));
+			    mcs51_rUmaskForOp (IC_JTCOND (ic)));
 
       goto ret;
     }
@@ -1281,16 +1413,16 @@ regsUsedIniCode (iCode * ic)
   /* of all other cases */
   if (IC_LEFT (ic))
     rmask = bitVectUnion (rmask,
-			  rUmaskForOp (IC_LEFT (ic)));
+			  mcs51_rUmaskForOp (IC_LEFT (ic)));
 
 
   if (IC_RIGHT (ic))
     rmask = bitVectUnion (rmask,
-			  rUmaskForOp (IC_RIGHT (ic)));
+			  mcs51_rUmaskForOp (IC_RIGHT (ic)));
 
   if (IC_RESULT (ic))
     rmask = bitVectUnion (rmask,
-			  rUmaskForOp (IC_RESULT (ic)));
+			  mcs51_rUmaskForOp (IC_RESULT (ic)));
 
 ret:
   return rmask;
@@ -1348,6 +1480,7 @@ createRegMask (eBBlock ** ebbs, int count)
 		{
 		  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 			  "createRegMask cannot find live range");
+		  fprintf(stderr, "\tmissing live range: key=%d\n", j);
 		  exit (0);
 		}
 
@@ -1387,6 +1520,11 @@ rematStr (symbol * sym)
 	  continue;
 	}
 
+      /* cast then continue */
+      if (IS_CAST_ICODE(ic)) {
+	  ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
+	  continue;
+      }
       /* we reached the end */
       sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
       break;
@@ -1399,7 +1537,7 @@ rematStr (symbol * sym)
 /* regTypeNum - computes the type & number of registers required   */
 /*-----------------------------------------------------------------*/
 static void
-regTypeNum ()
+regTypeNum (eBBlock *ebbs)
 {
   symbol *sym;
   int k;
@@ -1432,24 +1570,46 @@ regTypeNum ()
 	      continue;
 	    }
 
-	  /* if the symbol has only one definition &
-	     that definition is a get_pointer and the
-	     pointer we are getting is rematerializable and
-	     in "data" space */
+#ifdef RANGEHUNT
+	  /* if this symbol has only one usage and that is an assignment
+	     to a ruonly, we don't need registers */
+	  // if this symbol has only one def
+	  if (bitVectnBitsOn (sym->defs)==1) {
+	    printf ("sym: %s has only one usage", sym->name);
+	    // find that usage
+	    if ((ic = hTabItemWithKey (iCodehTab, bitVectFirstBit (sym->defs)))) {
+	      if (ic->op==CALL) {
+		printf (" for a call ");
+		// if this is only assigned to a ruonly
+		if ((ic = hTabItemWithKey (iCodehTab, bitVectFirstBit (sym->defs)))) {
+		  if (ic->op=='=') {
+		    if (OP_SYMBOL(IC_RESULT(ic))->ruonly) {
+		      printf("regTypeNum: %s assigned to %s\n", \
+			     sym->name, OP_SYMBOL(IC_RESULT(ic))->name); 
+		    }
+		  }
+		}
+	      }
+	    }
+	  }
+#endif
 
+	  /* if the symbol has only one definition &
+	     that definition is a get_pointer */
 	  if (bitVectnBitsOn (sym->defs) == 1 &&
 	      (ic = hTabItemWithKey (iCodehTab,
 				     bitVectFirstBit (sym->defs))) &&
 	      POINTER_GET (ic) &&
+	      !sym->noSpilLoc &&
 	      !IS_BITVAR (sym->etype))
 	    {
 
 
-	      /* if remat in data space */
+	      /* and that pointer is remat in data space */
 	      if (OP_SYMBOL (IC_LEFT (ic))->remat &&
-		  DCL_TYPE (aggrToPtr (sym->type, FALSE)) == POINTER)
+		  !IS_CAST_ICODE(OP_SYMBOL (IC_LEFT (ic))->rematiCode) &&
+		  DCL_TYPE (aggrToPtr (operandType(IC_LEFT(ic)), FALSE)) == POINTER)
 		{
-
 		  /* create a psuedo symbol & force a spil */
 		  symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
 		  psym->type = sym->type;
@@ -1457,6 +1617,16 @@ regTypeNum ()
 		  strcpy (psym->rname, psym->name);
 		  sym->isspilt = 1;
 		  sym->usl.spillLoc = psym;
+#if 0 // an alternative fix for bug #480076
+		  /* now this is a useless assignment to itself */
+		  remiCodeFromeBBlock (ebbs, ic);
+#else
+		  /* now this really is an assignment to itself, make it so;
+		     it will be optimized out later */
+		  ic->op='=';
+		  ReplaceOpWithCheaperOp(&IC_RIGHT(ic), IC_RESULT(ic));
+		  IC_LEFT(ic)=NULL;
+#endif
 		  continue;
 		}
 
@@ -1491,7 +1661,7 @@ regTypeNum ()
 	/* registers for true symbols we will */
 	/* see how things go                  */
 	sym->nRegs = 0;
-    }
+	  }
 
 }
 
@@ -1531,7 +1701,6 @@ farSpacePackable (iCode * ic)
      symbol on the right */
   for (dic = ic->prev; dic; dic = dic->prev)
     {
-
       /* if the definition is a call then no */
       if ((dic->op == CALL || dic->op == PCALL) &&
 	  IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
@@ -1593,37 +1762,28 @@ static int
 packRegsForAssign (iCode * ic, eBBlock * ebp)
 {
   iCode *dic, *sic;
-  sym_link *etype = operandType (IC_RIGHT (ic));
 
   if (!IS_ITEMP (IC_RIGHT (ic)) ||
       OP_SYMBOL (IC_RIGHT (ic))->isind ||
-      OP_LIVETO (IC_RIGHT (ic)) > ic->seq ||
-      IS_BITFIELD (etype))
+      OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
     {
       return 0;
     }
 
+
   /* if the true symbol is defined in far space or on stack
      then we should not since this will increase register pressure */
-  if (isOperandInFarSpace (IC_RESULT (ic)))
-    {
-      if ((dic = farSpacePackable (ic)))
-	goto pack;
-      else
-	return 0;
+  if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
+    return 0;
+  }
 
-    }
   /* find the definition of iTempNN scanning backwards if we find a 
      a use of the true symbol in before we find the definition then 
      we cannot */
   for (dic = ic->prev; dic; dic = dic->prev)
     {
-
-      /* if there is a function call and this is
-         a parameter & not my parameter then don't pack it */
-      if ((dic->op == CALL || dic->op == PCALL) &&
-	  (OP_SYMBOL (IC_RESULT (ic))->_isparm &&
-	   !OP_SYMBOL (IC_RESULT (ic))->ismyparm))
+      /* if there is a function call then don't pack it */
+      if ((dic->op == CALL || dic->op == PCALL))
 	{
 	  dic = NULL;
 	  break;
@@ -1704,12 +1864,15 @@ pack:
   /* found the definition */
   /* replace the result with the result of */
   /* this assignment and remove this assignment */
-  IC_RESULT (dic) = IC_RESULT (ic);
+  bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+  ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
 
   if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
     {
       OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
     }
+  // jwk: and the otherway around?
+
   /* delete from liverange table also 
      delete from all the points inbetween and the new
      one */
@@ -1721,20 +1884,30 @@ pack:
     }
 
   remiCodeFromeBBlock (ebp, ic);
+  bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
   hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-  OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+  OP_DEFS_SET ((IC_RESULT (dic)), bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key));
   return 1;
-
 }
 
-/*-----------------------------------------------------------------*/
+/*------------------------------------------------------------------*/
 /* findAssignToSym : scanning backwards looks for first assig found */
-/*-----------------------------------------------------------------*/
+/*------------------------------------------------------------------*/
 static iCode *
 findAssignToSym (operand * op, iCode * ic)
 {
   iCode *dic;
 
+  /* This routine is used to find sequences like
+     iTempAA = FOO;
+     ...;  (intervening ops don't use iTempAA or modify FOO)
+     blah = blah + iTempAA;
+
+     and eliminate the use of iTempAA, freeing up its register for
+     other uses.
+  */
+     
+
   for (dic = ic->prev; dic; dic = dic->prev)
     {
 
@@ -1744,37 +1917,7 @@ findAssignToSym (operand * op, iCode * ic)
 	  IC_RESULT (dic)->key == op->key
 /*          &&  IS_TRUE_SYMOP(IC_RIGHT(dic)) */
 	)
-	{
-
-	  /* we are interested only if defined in far space */
-	  /* or in stack space in case of + & - */
-
-	  /* if assigned to a non-symbol then return
-	     true */
-	  if (!IS_SYMOP (IC_RIGHT (dic)))
-	    break;
-
-	  /* if the symbol is in far space then
-	     we should not */
-	  if (isOperandInFarSpace (IC_RIGHT (dic)))
-	    return NULL;
-
-	  /* for + & - operations make sure that
-	     if it is on the stack it is the same
-	     as one of the three operands */
-	  if ((ic->op == '+' || ic->op == '-') &&
-	      OP_SYMBOL (IC_RIGHT (dic))->onStack)
-	    {
-
-	      if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
-		  IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
-		  IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
-		return NULL;
-	    }
-
-	  break;
-
-	}
+	break;  /* found where this temp was defined */
 
       /* if we find an usage then we cannot delete it */
       if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
@@ -1787,6 +1930,41 @@ findAssignToSym (operand * op, iCode * ic)
 	return NULL;
     }
 
+  if (!dic)
+    return NULL;   /* didn't find any assignment to op */
+
+  LRH(printf ("findAssignToSym: %s\n", OP_SYMBOL(IC_RESULT(dic))->name));
+  /* we are interested only if defined in far space */
+  /* or in stack space in case of + & - */
+  
+  /* if assigned to a non-symbol then don't repack regs */
+  if (!IS_SYMOP (IC_RIGHT (dic)))
+    return NULL;
+  
+  /* if the symbol is volatile then we should not */
+  if (isOperandVolatile (IC_RIGHT (dic), TRUE))
+    return NULL;
+  /* XXX TODO --- should we be passing FALSE to isOperandVolatile()?
+     What does it mean for an iTemp to be volatile, anyway? Passing
+     TRUE is more cautious but may prevent possible optimizations */
+
+  /* if the symbol is in far space then we should not */
+  if (isOperandInFarSpace (IC_RIGHT (dic)))
+    return NULL;
+  
+  /* for + & - operations make sure that
+     if it is on the stack it is the same
+     as one of the three operands */
+  if ((ic->op == '+' || ic->op == '-') &&
+      OP_SYMBOL (IC_RIGHT (dic))->onStack)
+    {
+      
+      if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
+	  IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
+	  IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
+	return NULL;
+    }
+  
   /* now make sure that the right side of dic
      is not defined between ic & dic */
   if (dic)
@@ -1800,9 +1978,46 @@ findAssignToSym (operand * op, iCode * ic)
     }
 
   return dic;
+}
 
+/*-----------------------------------------------------------------*/
+/* reassignAliasedSym - used by packRegsForSupport to replace      */
+/*                      redundant iTemp with equivalent symbol     */
+/*-----------------------------------------------------------------*/
+static void
+reassignAliasedSym (eBBlock *ebp, iCode *assignment, iCode *use, operand *op)
+{
+  iCode *ic;
+  unsigned oldSymKey, newSymKey;
+
+  oldSymKey = op->key;
+  newSymKey = IC_RIGHT(assignment)->key;
+
+  /* only track live ranges of compiler-generated temporaries */
+  if (!IS_ITEMP(IC_RIGHT(assignment)))
+    newSymKey = 0;
+
+  /* update the live-value bitmaps */
+  for (ic = assignment; ic != use; ic = ic->next) {
+    bitVectUnSetBit (ic->rlive, oldSymKey);
+    if (newSymKey != 0)
+      ic->rlive = bitVectSetBit (ic->rlive, newSymKey);
+  }
+
+  /* update the sym of the used operand */
+  OP_SYMBOL(op) = OP_SYMBOL(IC_RIGHT(assignment));
+  op->key = OP_SYMBOL(op)->key;
 
+  /* update the sym's liverange */
+  if ( OP_LIVETO(op) < ic->seq )
+    setToRange(op, ic->seq, FALSE);
+
+  /* remove the assignment iCode now that its result is unused */
+  remiCodeFromeBBlock (ebp, assignment);
+  bitVectUnSetBit(OP_SYMBOL(IC_RESULT(assignment))->defs, assignment->key);
+  hTabDeleteItem (&iCodehTab, assignment->key, assignment, DELETE_ITEM, NULL);
 }
+  
 
 /*-----------------------------------------------------------------*/
 /* packRegsForSupport :- reduce some registers for support calls   */
@@ -1810,67 +2025,50 @@ findAssignToSym (operand * op, iCode * ic)
 static int
 packRegsForSupport (iCode * ic, eBBlock * ebp)
 {
-  int change = 0;
+  iCode *dic;
+  
   /* for the left & right operand :- look to see if the
      left was assigned a true symbol in far space in that
      case replace them */
+
   if (IS_ITEMP (IC_LEFT (ic)) &&
       OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
     {
-      iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
-      iCode *sic;
-
-      if (!dic)
-	goto right;
-
-      /* found it we need to remove it from the
-         block */
-      for (sic = dic; sic != ic; sic = sic->next)
-	bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
-
-      IC_LEFT (ic)->operand.symOperand =
-	IC_RIGHT (dic)->operand.symOperand;
-      IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
-      remiCodeFromeBBlock (ebp, dic);
-      hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
-      change++;
+      dic = findAssignToSym (IC_LEFT (ic), ic);
+
+      if (dic)
+	{
+	  /* found it we need to remove it from the block */
+	  reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic));
+	  return 1;
+	}
     }
 
   /* do the same for the right operand */
-right:
-  if (!change &&
-      IS_ITEMP (IC_RIGHT (ic)) &&
+  if (IS_ITEMP (IC_RIGHT (ic)) &&
       OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
     {
       iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
-      iCode *sic;
-
-      if (!dic)
-	return change;
 
-      /* if this is a subtraction & the result
-         is a true symbol in far space then don't pack */
-      if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
+      if (dic)
 	{
-	  sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
-	  if (IN_FARSPACE (SPEC_OCLS (etype)))
-	    return change;
+	  /* if this is a subtraction & the result
+	     is a true symbol in far space then don't pack */
+	  if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
+	    {
+	      sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
+	      if (IN_FARSPACE (SPEC_OCLS (etype)))
+		return 0;
+	    }
+	  /* found it we need to remove it from the
+	     block */
+	  reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic));
+	  
+	  return 1;
 	}
-      /* found it we need to remove it from the
-         block */
-      for (sic = dic; sic != ic; sic = sic->next)
-	bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
-
-      IC_RIGHT (ic)->operand.symOperand =
-	IC_RIGHT (dic)->operand.symOperand;
-      IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
-
-      remiCodeFromeBBlock (ebp, dic);
-      hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
-      change++;
     }
 
-  return change;
+  return 0;
 }
 
 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
@@ -1891,12 +2089,16 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
 
   /* only upto 2 bytes since we cannot predict
      the usage of b, & acc */
-  if (getSize (operandType (op)) > (fReturnSizeMCS51 - 2) &&
-      ic->op != RETURN &&
+  if (getSize (operandType (op)) > (fReturnSizeMCS51 - 2))
+    return NULL;
+
+  if (ic->op != RETURN &&
       ic->op != SEND &&
       !POINTER_SET (ic) &&
       !POINTER_GET (ic))
     return NULL;
+  
+  if (ic->op == SEND && ic->argreg != 1) return NULL;
 
   /* this routine will mark the a symbol as used in one 
      instruction use only && if the defintion is local 
@@ -1913,12 +2115,23 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
   if (bitVectnBitsOn (OP_DEFS (op)) > 1)
     return NULL;		/* has more than one definition */
 
-  /* get the that definition */
+  /* get that definition */
   if (!(dic =
 	hTabItemWithKey (iCodehTab,
 			 bitVectFirstBit (OP_DEFS (op)))))
     return NULL;
 
+  LRH(printf ("packRegsForOneUse: %s\n", OP_SYMBOL(op)->name));
+  /* if that only usage is a cast */
+  if (dic->op == CAST) {
+    /* to a bigger type */
+    if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) > 
+	getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) {
+      /* than we can not, since we cannot predict the usage of b & acc */
+      return NULL;
+    }
+  }
+
   /* found the definition now check if it is local */
   if (dic->seq < ebp->fSeq ||
       dic->seq > ebp->lSeq)
@@ -1928,7 +2141,8 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
      a function call */
   if (dic->op == CALL || dic->op == PCALL)
     {
-      if (ic->op != SEND && ic->op != RETURN)
+      if (ic->op != SEND && ic->op != RETURN &&
+	  !POINTER_SET(ic) && !POINTER_GET(ic))
 	{
 	  OP_SYMBOL (op)->ruonly = 1;
 	  return dic;
@@ -1999,11 +2213,16 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
 	{
 	  return NULL;
 	}
+      /* if left or right or result is on stack */
+      if (isOperandOnStack(IC_LEFT(dic)) ||
+	  isOperandOnStack(IC_RIGHT(dic)) ||
+	  isOperandOnStack(IC_RESULT(dic))) {
+	return NULL;
+      }
     }
 
   OP_SYMBOL (op)->ruonly = 1;
   return sic;
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -2018,23 +2237,80 @@ isBitwiseOptimizable (iCode * ic)
   /* bitwise operations are considered optimizable
      under the following conditions (Jean-Louis VERN) 
 
-     x & lit   <== jwk: should be x && lit
+     x & lit
      bit & bit
      bit & x
      bit ^ bit
      bit ^ x
-     x   ^ lit <== jwk: should be x ^^ lit
-     x   | lit <== jwk: should be x || lit
+     x   ^ lit
+     x   | lit
      bit | bit
      bit | x
-   */
-  if ( /* jwk IS_LITERAL (rtype) || */
+  */
+  if (IS_LITERAL(rtype) ||
       (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
     return TRUE;
   else
     return FALSE;
 }
 
+/*-----------------------------------------------------------------*/
+/* isCommutativeOp - tests whether this op cares what order its    */
+/*                   operands are in                               */
+/*-----------------------------------------------------------------*/
+bool isCommutativeOp(unsigned int op)
+{
+  if (op == '+' || op == '*' || op == EQ_OP ||
+      op == '^' || op == '|' || op == BITWISEAND)
+    return TRUE;
+  else
+    return FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* operandUsesAcc - determines whether the code generated for this */
+/*                  operand will have to use the accumulator       */
+/*-----------------------------------------------------------------*/
+bool operandUsesAcc(operand *op)
+{
+  if (!op)
+    return FALSE;
+
+  if (IS_SYMOP(op)) {
+    symbol *sym = OP_SYMBOL(op);
+    memmap *symspace;
+
+    if (sym->accuse)
+      return TRUE;  /* duh! */
+
+    if (IN_STACK(sym->etype) || sym->onStack ||
+	(SPIL_LOC(op) && SPIL_LOC(op)->onStack))
+      return TRUE;  /* acc is used to calc stack offset */
+
+    if (IS_ITEMP(op))
+      {
+	if (SPIL_LOC(op)) {
+	  sym = SPIL_LOC(op);  /* if spilled, look at spill location */
+	} else {
+	  return FALSE;  /* more checks? */
+	}
+      }
+
+    symspace = SPEC_OCLS(sym->etype);
+
+    if (sym->iaccess && symspace->paged)
+      return TRUE;  /* must fetch paged indirect sym via accumulator */
+    
+    if (IN_BITSPACE(symspace))
+      return TRUE;  /* fetching bit vars uses the accumulator */
+    
+    if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace)) 
+      return TRUE;  /* fetched via accumulator and dptr */
+  }
+
+  return FALSE;
+}
+
 /*-----------------------------------------------------------------*/
 /* packRegsForAccUse - pack registers for acc use                  */
 /*-----------------------------------------------------------------*/
@@ -2043,6 +2319,22 @@ packRegsForAccUse (iCode * ic)
 {
   iCode *uic;
 
+  /* if this is an aggregate, e.g. a one byte char array */
+  if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
+    return;
+  }
+
+  /* if we are calling a reentrant function that has stack parameters */
+  if (ic->op == CALL &&
+       IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
+       FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
+      return;
+
+  if (ic->op == PCALL &&
+       IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
+       FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
+      return;
+
   /* if + or - then it has to be one byte result */
   if ((ic->op == '+' || ic->op == '-')
       && getSize (operandType (IC_RESULT (ic))) > 1)
@@ -2087,12 +2379,12 @@ packRegsForAccUse (iCode * ic)
   if (uic->op == JUMPTABLE)
     return;
 
-  /* if the usage is not is an assignment
-     or an arithmetic / bitwise / shift operation then not */
   if (POINTER_SET (uic) &&
       getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
     return;
 
+  /* if the usage is not is an assignment
+     or an arithmetic / bitwise / shift operation then not */
   if (uic->op != '=' &&
       !IS_ARITHMETIC_OP (uic) &&
       !IS_BITWISE_OP (uic) &&
@@ -2101,16 +2393,16 @@ packRegsForAccUse (iCode * ic)
     return;
 
   /* if used in ^ operation then make sure right is not a 
-     literl */
+     literal (WIML: Why is this?) */
   if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
     return;
 
   /* if shift operation make sure right side is not a literal */
+  /* WIML: Why is this? */
   if (uic->op == RIGHT_OP &&
       (isOperandLiteral (IC_RIGHT (uic)) ||
        getSize (operandType (IC_RESULT (uic))) > 1))
     return;
-
   if (uic->op == LEFT_OP &&
       (isOperandLiteral (IC_RIGHT (uic)) ||
        getSize (operandType (IC_RESULT (uic))) > 1))
@@ -2118,28 +2410,38 @@ packRegsForAccUse (iCode * ic)
 
   /* make sure that the result of this icode is not on the
      stack, since acc is used to compute stack offset */
+#if 0
   if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
       OP_SYMBOL (IC_RESULT (uic))->onStack)
     return;
-
-  /* if either one of them in far space then we cannot */
-  if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
-       isOperandInFarSpace (IC_LEFT (uic))) ||
-      (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
-       isOperandInFarSpace (IC_RIGHT (uic))))
+#else
+  if (isOperandOnStack(IC_RESULT(uic)))
     return;
+#endif
 
   /* if the usage has only one operand then we can */
   if (IC_LEFT (uic) == NULL ||
       IC_RIGHT (uic) == NULL)
     goto accuse;
 
-  /* make sure this is on the left side if not
-     a '+' since '+' is commutative */
-  if (ic->op != '+' &&
-      IC_LEFT (uic)->key != IC_RESULT (ic)->key)
+  /* if the other operand uses the accumulator then we cannot */
+  if ( (IC_LEFT(uic)->key == IC_RESULT(ic)->key &&
+	operandUsesAcc(IC_RIGHT(uic))) ||
+       (IC_RIGHT(uic)->key == IC_RESULT(ic)->key &&
+	operandUsesAcc(IC_LEFT(uic))) ) 
+    return;
+
+  /* make sure this is on the left side if not commutative */
+  /* except for '-', which has been written to be able to
+     handle reversed operands */
+  if (!(isCommutativeOp(ic->op) || ic->op == '-') &&
+       IC_LEFT (uic)->key != IC_RESULT (ic)->key)
     return;
 
+#if 0
+  // this is too dangerous and need further restrictions
+  // see bug #447547
+
   /* if one of them is a literal then we can */
   if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
       (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
@@ -2147,36 +2449,22 @@ packRegsForAccUse (iCode * ic)
       OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
       return;
     }
-
-  /* if the other one is not on stack then we can */
-  if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
-      (IS_ITEMP (IC_RIGHT (uic)) ||
-       (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
-	!OP_SYMBOL (IC_RIGHT (uic))->onStack)))
-    goto accuse;
-
-  if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
-      (IS_ITEMP (IC_LEFT (uic)) ||
-       (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
-	!OP_SYMBOL (IC_LEFT (uic))->onStack)))
-    goto accuse;
-
-  return;
+#endif
 
 accuse:
   OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
 
-
 }
 
 /*-----------------------------------------------------------------*/
 /* packForPush - hueristics to reduce iCode for pushing            */
 /*-----------------------------------------------------------------*/
 static void
-packForPush (iCode * ic, eBBlock * ebp)
+packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
 {
   iCode *dic, *lic;
   bitVect *dbv;
+  struct eBBlock * ebp=ebpp[blockno];
 
   if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
     return;
@@ -2194,16 +2482,44 @@ packForPush (iCode * ic, eBBlock * ebp)
   if (dic->op != '=' || POINTER_SET (dic))
     return;
 
-  /* make sure the right side does not have any definitions
-     inbetween */
-  dbv = OP_DEFS(IC_RIGHT(dic));
-  for (lic = ic; lic != dic ; lic = lic->prev) {
-	  if (bitVectBitValue(dbv,lic->key)) return ;
+  if (dic->seq < ebp->fSeq) { // Evelyn did this
+    int i;
+    for (i=0; i<blockno; i++) {
+      if (dic->seq >= ebpp[i]->fSeq && dic->seq <= ebpp[i]->lSeq) {
+	ebp=ebpp[i];
+	break;
+      }
+    }
+    wassert (i!=blockno); // no way to recover from here
   }
+
+  if (IS_SYMOP(IC_RIGHT(dic))) {
+    /* make sure the right side does not have any definitions
+       inbetween */
+    dbv = OP_DEFS(IC_RIGHT(dic));
+    for (lic = ic; lic && lic != dic ; lic = lic->prev) {
+      if (bitVectBitValue(dbv,lic->key)) 
+	return ;
+    }
+    /* make sure they have the same type */
+    {
+      sym_link *itype=operandType(IC_LEFT(ic));
+      sym_link *ditype=operandType(IC_RIGHT(dic));
+      
+      if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
+	  SPEC_LONG(itype)!=SPEC_LONG(ditype))
+	return;
+    }
+    /* extend the live range of replaced operand if needed */
+    if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
+      OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
+    }
+    bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+  } 
+
   /* we now we know that it has one & only one def & use
      and the that the definition is an assignment */
-  IC_LEFT (ic) = IC_RIGHT (dic);
-
+  ReplaceOpWithCheaperOp(&IC_LEFT (ic), IC_RIGHT (dic));
   remiCodeFromeBBlock (ebp, dic);
   hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
 }
@@ -2213,10 +2529,11 @@ packForPush (iCode * ic, eBBlock * ebp)
 /*                   pressure                                      */
 /*-----------------------------------------------------------------*/
 static void
-packRegisters (eBBlock * ebp)
+packRegisters (eBBlock ** ebpp, int blockno)
 {
   iCode *ic;
   int change = 0;
+  eBBlock *ebp=ebpp[blockno];
 
   while (1)
     {
@@ -2240,8 +2557,7 @@ packRegisters (eBBlock * ebp)
 
   for (ic = ebp->sch; ic; ic = ic->next)
     {
-
-      /* if this is an itemp & result of a address of a true sym 
+      /* if this is an itemp & result of an address of a true sym 
          then mark this as rematerialisable   */
       if (ic->op == ADDRESS_OF &&
 	  IS_ITEMP (IC_RESULT (ic)) &&
@@ -2262,6 +2578,7 @@ packRegisters (eBBlock * ebp)
 	  !POINTER_SET (ic) &&
 	  IS_SYMOP (IC_RIGHT (ic)) &&
 	  OP_SYMBOL (IC_RIGHT (ic))->remat &&
+	  !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
 	  bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
 	{
 
@@ -2271,17 +2588,30 @@ packRegisters (eBBlock * ebp)
 	    OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
 	}
 
+      /* if cast to a generic pointer & the pointer being
+	 cast is remat, then we can remat this cast as well */
+      if (ic->op == CAST && 
+	  IS_SYMOP(IC_RIGHT(ic)) &&
+	  OP_SYMBOL(IC_RIGHT(ic))->remat ) {
+	      sym_link *to_type = operandType(IC_LEFT(ic));
+	      sym_link *from_type = operandType(IC_RIGHT(ic));
+	      if (IS_GENPTR(to_type) && IS_PTR(from_type)) {		      
+		      OP_SYMBOL (IC_RESULT (ic))->remat = 1;
+		      OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
+		      OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
+	      }
+      }
+
       /* if this is a +/- operation with a rematerizable 
          then mark this as rematerializable as well */
       if ((ic->op == '+' || ic->op == '-') &&
 	  (IS_SYMOP (IC_LEFT (ic)) &&
 	   IS_ITEMP (IC_RESULT (ic)) &&
+	   IS_OP_LITERAL (IC_RIGHT (ic))) &&
 	   OP_SYMBOL (IC_LEFT (ic))->remat &&
-	   bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
-	   IS_OP_LITERAL (IC_RIGHT (ic))))
+	  (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
+	   bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
 	{
-
-	  //int i = operandLitValue (IC_RIGHT (ic));
 	  OP_SYMBOL (IC_RESULT (ic))->remat = 1;
 	  OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
 	  OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
@@ -2319,11 +2649,13 @@ packRegisters (eBBlock * ebp)
 	}
 
       /* if the condition of an if instruction
-         is defined in the previous instruction then
+         is defined in the previous instruction and
+	 this is the only usage then
          mark the itemp as a conditional */
       if ((IS_CONDITIONAL (ic) ||
 	   (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
 	  ic->next && ic->next->op == IFX &&
+	  bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
 	  isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
 	  OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
 	{
@@ -2337,10 +2669,11 @@ packRegisters (eBBlock * ebp)
 
       /* some cases the redundant moves can
          can be eliminated for return statements */
-      if ((ic->op == RETURN || ic->op == SEND) &&
+      if ((ic->op == RETURN || (ic->op == SEND && ic->argreg == 1)) &&
 	  !isOperandInFarSpace (IC_LEFT (ic)) &&
-	  options.model == MODEL_SMALL)
+	  options.model == MODEL_SMALL) {
 	packRegsForOneuse (ic, IC_LEFT (ic), ebp);
+      }
 
       /* if pointer set & left has a size more than
          one and right is not in far space */
@@ -2349,7 +2682,6 @@ packRegisters (eBBlock * ebp)
 	  !OP_SYMBOL (IC_RESULT (ic))->remat &&
 	  !IS_OP_RUONLY (IC_RIGHT (ic)) &&
 	  getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
-
 	packRegsForOneuse (ic, IC_RESULT (ic), ebp);
 
       /* if pointer get */
@@ -2358,7 +2690,6 @@ packRegisters (eBBlock * ebp)
 	  !OP_SYMBOL (IC_LEFT (ic))->remat &&
 	  !IS_OP_RUONLY (IC_RESULT (ic)) &&
 	  getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
-
 	packRegsForOneuse (ic, IC_LEFT (ic), ebp);
 
 
@@ -2381,11 +2712,13 @@ packRegisters (eBBlock * ebp)
 	      if (dic)
 		{
 		  if (IS_ARITHMETIC_OP (dic))
-		    {
-		      IC_RESULT (dic) = IC_RESULT (ic);
+		    {		       
+		      bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+		      ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
 		      remiCodeFromeBBlock (ebp, ic);
+		      bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
 		      hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-		      OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+		      OP_DEFS_SET ((IC_RESULT (dic)), bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key));
 		      ic = ic->prev;
 		    }
 		  else
@@ -2397,16 +2730,18 @@ packRegisters (eBBlock * ebp)
 
 	      /* if the type from and type to are the same
 	         then if this is the only use then packit */
-	      if (checkType (operandType (IC_RIGHT (ic)),
+	      if (compareType (operandType (IC_RIGHT (ic)),
 			     operandType (IC_LEFT (ic))) == 1)
 		{
 		  iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
 		  if (dic)
 		    {
-		      IC_RESULT (dic) = IC_RESULT (ic);
+		      bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+		      ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
 		      remiCodeFromeBBlock (ebp, ic);
+		      bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
 		      hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-		      OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+		      OP_DEFS_SET ((IC_RESULT (dic)), bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key));
 		      ic = ic->prev;
 		    }
 		}
@@ -2421,7 +2756,7 @@ packRegisters (eBBlock * ebp)
        */
       if (ic->op == IPUSH)
 	{
-	  packForPush (ic, ebp);
+	  packForPush (ic, ebpp, blockno);
 	}
 
 
@@ -2434,15 +2769,15 @@ packRegisters (eBBlock * ebp)
          we can leave the result of this operation in acc:b
          combination */
       if ((IS_ARITHMETIC_OP (ic)
+	   || IS_CONDITIONAL(ic)
 	   || IS_BITWISE_OP (ic)
-	   || ic->op == LEFT_OP || ic->op == RIGHT_OP
+	   || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
 	   || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
 	  ) &&
 	  IS_ITEMP (IC_RESULT (ic)) &&
 	  getSize (operandType (IC_RESULT (ic))) <= 2)
 
 	packRegsForAccUse (ic);
-
     }
 }
 
@@ -2456,29 +2791,28 @@ mcs51_assignRegisters (eBBlock ** ebbs, int count)
   int i;
 
   setToNull ((void *) &_G.funcrUsed);
+  setToNull ((void *) &_G.totRegAssigned);
   mcs51_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
-  /* if not register extentions then reduce number
-     of registers */
-  if (options.regExtend)
-    mcs51_nRegs = 13;
-  else
-    mcs51_nRegs = 8;
+  mcs51_nRegs = 8;
 
   /* change assignments this will remove some
      live ranges reducing some register pressure */
   for (i = 0; i < count; i++)
-    packRegisters (ebbs[i]);
+    packRegisters (ebbs, i);
 
   if (options.dump_pack)
-    dumpEbbsToFileExt (".dumppack", ebbs, count);
+    dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
 
   /* first determine for each live range the number of 
      registers & the type of registers required for each */
-  regTypeNum ();
+  regTypeNum (*ebbs);
 
   /* and serially allocate registers */
   serialRegAssign (ebbs, count);
 
+  freeAllRegs ();
+  fillGaps();
+
   /* if stack was extended then tell the user */
   if (_G.stackExtend)
     {
@@ -2503,8 +2837,8 @@ mcs51_assignRegisters (eBBlock ** ebbs, int count)
 
   if (options.dump_rassgn)
     {
-      dumpEbbsToFileExt (".dumprassgn", ebbs, count);
-      dumpLiveRanges (".dumplrange", liveRanges);
+      dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
+      dumpLiveRanges (DUMP_LRANGE, liveRanges);
     }
 
   /* do the overlaysegment stuff SDCCmem.c */
@@ -2513,7 +2847,6 @@ mcs51_assignRegisters (eBBlock ** ebbs, int count)
   /* now get back the chain */
   ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
 
-
   gen51Code (ic);
 
   /* free up any _G.stackSpil locations allocated */