X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic16%2Fralloc.c;h=1319ff89e97ba01cb0ae31a4c2cc8463879e9117;hb=3062f96ccb55d1d05caf9c8782f4961f87b341ce;hp=7d5e782dce4bf89e3a19a231979715bc1cd612fb;hpb=3e896c0ba619568082bc9e952265022cad9fe911;p=fw%2Fsdcc

diff --git a/src/pic16/ralloc.c b/src/pic16/ralloc.c
index 7d5e782d..1319ff89 100644
--- a/src/pic16/ralloc.c
+++ b/src/pic16/ralloc.c
@@ -31,11 +31,14 @@
 #include "gen.h"
 #include "device.h"
 
-#if defined(__BORLANDC__) || defined(_MSC_VER)
-#define STRCASECMP stricmp
-#else
-#define STRCASECMP strcasecmp
+#ifndef debugf
+#define debugf(frm, rest)       _debugf(__FILE__, __LINE__, frm, rest)
 #endif
+void _debugf(char *f, int l, char *frm, ...);
+
+#define NEWREG_DEBUG	0
+//#define USE_ONSTACK
+
 
 /*-----------------------------------------------------------------*/
 /* At this point we start getting processor specific although      */
@@ -73,18 +76,25 @@ set *pic16_dynProcessorRegs=NULL;
 set *pic16_dynDirectRegs=NULL;
 set *pic16_dynDirectBitRegs=NULL;
 set *pic16_dynInternalRegs=NULL;
+set *pic16_dynAccessRegs=NULL;
 
-static hTab  *dynDirectRegNames= NULL;
+static hTab *dynDirectRegNames=NULL;
+static hTab *dynAllocRegNames=NULL;
+static hTab *dynProcRegNames=NULL;
+static hTab *dynAccessRegNames=NULL;
 //static hTab  *regHash = NULL;    /* a hash table containing ALL registers */
 
+extern set *sectNames;
+
 set *pic16_rel_udata=NULL;	/* relocatable uninitialized registers */
 set *pic16_fix_udata=NULL;	/* absolute uninitialized registers */
 set *pic16_equ_data=NULL;	/* registers used by equates */
 set *pic16_int_regs=NULL;	/* internal registers placed in access bank 0 to 0x7f */
+set *pic16_acs_udata=NULL;	/* access bank variables */
 
 set *pic16_builtin_functions=NULL;
 
-static int dynrIdx=0x10;		//0x20;		// starting temporary register rIdx
+static int dynrIdx=0x00;		//0x20;		// starting temporary register rIdx
 static int rDirectIdx=0;
 
 int pic16_nRegs = 128;   // = sizeof (regspic16) / sizeof (regs);
@@ -93,7 +103,9 @@ int pic16_Gstack_base_addr=0; /* The starting address of registers that
 			 * are used to pass and return parameters */
 
 
-
+int _inRegAllocator=0;	/* flag that marks whther allocReg happens while
+                         * inside the register allocator function */
+                         
 
 static void spillThis (symbol *);
 int pic16_ralloc_debug = 0;
@@ -135,8 +147,9 @@ debugLog (char *fmt,...)
   vsprintf (buffer, fmt, ap);
 
   fprintf (debugF, "%s", buffer);
+  //fprintf (stderr, "%s", buffer);
 /*
-   while (isspace(*bufferP)) bufferP++;
+   while (isspace((unsigned char)*bufferP)) bufferP++;
 
    if (bufferP && *bufferP) 
    lineCurr = (lineCurr ?
@@ -152,10 +165,10 @@ debugLog (char *fmt,...)
 static void
 debugNewLine (void)
 {
-	if(!pic16_ralloc_debug)return;
-	
-	if (debugF)
-		fputc ('\n', debugF);
+  if(!pic16_ralloc_debug)return;
+
+  if (debugF)
+    fputc ('\n', debugF);
 }
 /*-----------------------------------------------------------------*/
 /* debugLogClose - closes the debug log file (if opened)           */
@@ -163,10 +176,10 @@ debugNewLine (void)
 static void
 debugLogClose (void)
 {
-	if (debugF) {
-		fclose (debugF);
-		debugF = NULL;
-	}
+  if (debugF) {
+    fclose (debugF);
+    debugF = NULL;
+  }
 }
 
 #define AOP(op) op->aop
@@ -185,8 +198,8 @@ debugAopGet (char *str, operand * op)
   return NULL;
 }
 
-static char *
-decodeOp (unsigned int op)
+char *
+pic16_decodeOp (unsigned int op)
 {
 	if (op < 128 && op > ' ') {
 		buffer[0] = (op & 0xff);
@@ -257,7 +270,6 @@ decodeOp (unsigned int op)
 		case STRUCT:		return "STRUCT";
 		case UNION:		return "UNION";
 		case ENUM:		return "ENUM";
-		case ELIPSIS:		return "ELIPSIS";
 		case RANGE:		return "RANGE";
 		case FAR:		return "FAR";
 		case CASE:		return "CASE";
@@ -284,6 +296,7 @@ decodeOp (unsigned int op)
 		case IPUSH:		return "IPUSH";
 		case IPOP:		return "IPOP";
 		case PCALL:		return "PCALL";
+                case FUNCTION:          return "FUNCTION";
 		case ENDFUNCTION:	return "ENDFUNCTION";
 		case JUMPTABLE:		return "JUMPTABLE";
 		case RRC:		return "RRC";
@@ -296,11 +309,27 @@ decodeOp (unsigned int op)
 		case LABEL:		return "LABEL";
 		case RECEIVE:		return "RECEIVE";
 		case SEND:		return "SEND";
+		case DUMMY_READ_VOLATILE:	return "DUMMY_READ_VOLATILE";
 	}
 	sprintf (buffer, "unkown op %d %c", op, op & 0xff);
 
   return buffer;
 }
+
+#if 0
+static char *decodeRegType(short type)
+{
+	switch(type) {
+		case REG_GPR: return "REG_GPR";
+		case REG_PTR: return "REG_PTR";
+		case REG_CND: return "REG_CNT";
+	
+	default:
+		return "<unknown>";
+	}
+}
+#endif
+
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 static char *
@@ -339,7 +368,7 @@ static int regname2key(char const *name)
 /*-----------------------------------------------------------------*/
 /* newReg - allocate and init memory for a new register            */
 /*-----------------------------------------------------------------*/
-regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alias, operand *refop)
+regs* newReg(int type, short pc_type, int rIdx, char *name, unsigned size, int alias, operand *refop)
 {
 
   regs *dReg;
@@ -351,10 +380,16 @@ regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alia
 	if(name) 
 		dReg->name = Safe_strdup(name);
 	else {
-		sprintf(buffer,"r0x%02X", dReg->rIdx);
-		if(type == REG_STK)
-			*buffer = 's';
-			dReg->name = Safe_strdup(buffer);
+          if(xinst && pc_type == PO_GPR_TEMP) {
+            sprintf(buffer,"0x%02x", dReg->rIdx);
+          } else {
+            sprintf(buffer,"r0x%02x", dReg->rIdx);
+          }
+          
+          if(type == REG_STK) {
+            *buffer = 's';
+          }
+          dReg->name = Safe_strdup(buffer);
 	}
 
 
@@ -372,8 +407,9 @@ regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alia
 		dReg->accessBank = 0;
 	}
 
-//	fprintf(stderr,"newReg: %s, rIdx = 0x%02x\taccess= %d\tregop= %p\n",dReg->name,rIdx, dReg->accessBank, refop);
-
+#if NEWREG_DEBUG
+	fprintf(stderr,"newReg @ %p: %s, rIdx = 0x%02x\taccess= %d\tregop= %p\n",dReg, dReg->name,rIdx, dReg->accessBank, refop);
+#endif
 	dReg->size = size;
 	dReg->alias = alias;
 	dReg->reg_alias = NULL;
@@ -382,7 +418,7 @@ regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alia
 	dReg->regop = refop;
   
 	if(!(type == REG_SFR && alias == 0x80))
-		hTabAddItem(&dynDirectRegNames, regname2key(name), dReg);
+		hTabAddItem(&dynDirectRegNames, regname2key(dReg->name), dReg);
 
   return dReg;
 }
@@ -391,16 +427,22 @@ regs* newReg(short type, short pc_type, int rIdx, char *name, int size, int alia
 /* regWithIdx - Search through a set of registers that matches idx */
 /*-----------------------------------------------------------------*/
 static regs *
-regWithIdx (set *dRegs, int idx, int fixed)
+regWithIdx (set *dRegs, int idx, unsigned fixed)
 {
   regs *dReg;
 
+//#define D(text)	text
+#define D(text)
+
   for (dReg = setFirstItem(dRegs) ; dReg ; 
        dReg = setNextItem(dRegs)) {
 
+	D(fprintf(stderr, "%s:%d testing reg w/rIdx = %d (%d f:%d)\t", __FUNCTION__, __LINE__, dReg->rIdx, idx, fixed));
     if(idx == dReg->rIdx && (fixed == dReg->isFixed)) {
+	  D(fprintf(stderr, "found!\n"));
       return dReg;
-    }
+    } else
+	  D(fprintf(stderr, "not found!\n"));
   }
 
   return NULL;
@@ -421,12 +463,34 @@ regFindFree (set *dRegs)
 //		__FILE__, __LINE__, dReg->name, dReg, dReg->rIdx, dReg->isFree);
 
     if(dReg->isFree) {
+//		fprintf(stderr, "%s:%d free register found, rIdx = %d\n", __FILE__, __LINE__, dReg->rIdx);
+		
       return dReg;
     }
   }
 
   return NULL;
 }
+
+static regs *
+regFindFreeNext(set *dRegs, regs *creg)
+{
+  regs *dReg;
+
+    if(creg) {
+      /* position at current register */
+      for(dReg = setFirstItem(dRegs); dReg != creg; dReg = setNextItem(dRegs));
+    }
+    
+    for(dReg = setNextItem(dRegs); dReg; dReg = setNextItem(dRegs)) {
+      if(dReg->isFree) {
+        return dReg;
+      }
+    }
+  
+  return NULL;
+}
+
 /*-----------------------------------------------------------------*/
 /* pic16_initStack - allocate registers for a pseudo stack               */
 /*-----------------------------------------------------------------*/
@@ -454,6 +518,8 @@ pic16_allocProcessorRegister(int rIdx, char * name, short po_type, int alias)
 	reg->wasUsed = 0;		// we do not know if they are going to be used at all
 	reg->accessBank = 1;		// implicit add access Bank
 
+	hTabAddItem(&dynProcRegNames, regname2key(reg->name), reg);
+
   return addSet(&pic16_dynProcessorRegs, reg);
 }
 
@@ -474,6 +540,8 @@ pic16_allocInternalRegister(int rIdx, char * name, short po_type, int alias)
 
   return NULL;
 }
+
+
 /*-----------------------------------------------------------------*/
 /* allocReg - allocates register of given type                     */
 /*-----------------------------------------------------------------*/
@@ -482,8 +550,12 @@ allocReg (short type)
 {
   regs * reg=NULL;
   
+#define MAX_P16_NREGS	16
+
+
 #if 0
   if(dynrIdx > pic16_nRegs)
+	werror(W_POSSBUG2, __FILE__, __LINE__);
   	return NULL;
 #endif
 
@@ -491,26 +563,37 @@ allocReg (short type)
 	reg = regFindFree( pic16_dynAllocRegs );
 
 	if(reg) {
-//		fprintf(stderr, "%s: found FREE register %s\n", __FILE__, reg->name);
+//		fprintf(stderr, "%s: [%s][cf:%p] found FREE register %s, rIdx: %d\n", __FILE__, (_inRegAllocator)?"ralloc":"", currFunc, reg->name, reg->rIdx);
 	}
 
 	if(!reg) {
 		reg = newReg(REG_GPR, PO_GPR_TEMP, dynrIdx++, NULL, 1, 0, NULL);
-//		addSet(&pic16_dynAllocRegs, reg);
-	}
-
-	addSet(&pic16_dynAllocRegs, reg);
-
-	reg->isFree=0;
+//		fprintf(stderr, "%s [%s][cf:%p] allocating NEW register %s, rIdx: %d\n", __FILE__,
+//					(_inRegAllocator)?"ralloc":"", currFunc, reg->name, reg->rIdx);
 
-//	debugLog ("%s of type %s\n", __FUNCTION__, debugLogRegType (type));
-
-//	fprintf(stderr,"%s:%d: %s\t%s addr= 0x%x\trIdx= 0x%02x isFree: %d\n",
-//		__FILE__, __LINE__, __FUNCTION__, reg->name, reg->address, reg->rIdx, reg->isFree);
+#if 1
+		if(_inRegAllocator && (dynrIdx > MAX_P16_NREGS)) {
+		  //                  debugf("allocating more registers than available\n", 0);
+		  //                  return (NULL);
+		}
+		
+		addSet(&pic16_dynAllocRegs, reg);
+		hTabAddItem(&dynAllocRegNames, regname2key(reg->name), reg);
+//		fprintf(stderr, "%s:%d added reg to pic16_dynAllocRegs = %p\n", __FUNCTION__, __LINE__, pic16_dynAllocRegs);
+#endif
+	}
+	
+	debugLog ("%s of type %s for register rIdx: %d (0x%x)\n", __FUNCTION__, debugLogRegType (type), dynrIdx-1, dynrIdx-1);
 
+#if 0
+	fprintf(stderr,"%s:%d: %s\t%s addr= 0x%x\trIdx= 0x%02x isFree: %d\n",
+		__FILE__, __LINE__, __FUNCTION__, reg->name, reg->address, reg->rIdx, reg->isFree);
+#endif
 	if(reg) {
+		reg->isFree=0;
 		reg->accessBank = 1;	/* this is a temporary register alloc in accessBank */
 		reg->isLocal = 1;	/* this is a local frame register */
+//		reg->wasUsed = 1;
 	}
 	
 	if (currFunc) {
@@ -546,6 +629,7 @@ pic16_dirregWithName (char *name)
   while(reg) {
 
     if(STRCASECMP(reg->name, name) == 0) {
+//		fprintf(stderr, "%s:%d: FOUND name = %s\thash = %d\n", __FUNCTION__, __LINE__, reg->name, hkey);
       return(reg);
     }
 
@@ -556,6 +640,128 @@ pic16_dirregWithName (char *name)
   return NULL; // name wasn't found in the hash table
 }
 
+/*-----------------------------------------------------------------*/
+/* pic16_allocregWithName - search for register by name                    */
+/*-----------------------------------------------------------------*/
+regs *
+pic16_allocregWithName (char *name)
+{
+  int hkey;
+  regs *reg;
+
+  if(!name)
+    return NULL;
+
+  /* hash the name to get a key */
+
+  hkey = regname2key(name);
+
+  //fprintf(stderr, "%s:%d: name = %s\thash = %d\n", __FUNCTION__, __LINE__, name, hkey);
+
+  reg = hTabFirstItemWK(dynAllocRegNames, hkey);
+
+  while(reg) {
+
+    if(STRCASECMP(reg->name, name) == 0) {
+      return(reg);
+    }
+
+    reg = hTabNextItemWK (dynAllocRegNames);
+  
+  }
+
+  return NULL; // name wasn't found in the hash table
+
+}
+
+
+/*-----------------------------------------------------------------*/
+/* pic16_procregWithName - search for register by name                    */
+/*-----------------------------------------------------------------*/
+regs *
+pic16_procregWithName (char *name)
+{
+  int hkey;
+  regs *reg;
+
+  if(!name)
+    return NULL;
+
+  /* hash the name to get a key */
+
+  hkey = regname2key(name);
+
+//	fprintf(stderr, "%s:%d: name = %s\thash = %d\n", __FUNCTION__, __LINE__, name, hkey);
+
+  reg = hTabFirstItemWK(dynProcRegNames, hkey);
+
+  while(reg) {
+
+    if(STRCASECMP(reg->name, name) == 0) {
+      return(reg);
+    }
+
+    reg = hTabNextItemWK (dynProcRegNames);
+  
+  }
+
+  return NULL; // name wasn't found in the hash table
+
+}
+
+/*-----------------------------------------------------------------*/
+/* pic16_accessregWithName - search for register by name           */
+/*-----------------------------------------------------------------*/
+regs *
+pic16_accessregWithName (char *name)
+{
+  int hkey;
+  regs *reg;
+
+  if(!name)
+    return NULL;
+
+  /* hash the name to get a key */
+
+  hkey = regname2key(name);
+
+//	fprintf(stderr, "%s:%d: name = %s\thash = %d\n", __FUNCTION__, __LINE__, name, hkey);
+
+  reg = hTabFirstItemWK(dynAccessRegNames, hkey);
+
+  while(reg) {
+
+    if(STRCASECMP(reg->name, name) == 0) {
+      return(reg);
+    }
+
+    reg = hTabNextItemWK (dynAccessRegNames);
+  
+  }
+
+  return NULL; // name wasn't found in the hash table
+
+}
+
+regs *pic16_regWithName(char *name)
+{
+  regs *reg;
+
+  	reg = pic16_dirregWithName( name );
+  	if(reg)return reg;
+  	
+  	reg = pic16_procregWithName( name );
+  	if(reg)return reg;
+  	
+  	reg = pic16_allocregWithName( name );
+  	if(reg)return reg;
+
+  	reg = pic16_accessregWithName( name );
+  	if(reg)return reg;
+  	
+  return NULL;
+}
+
 
 /*-----------------------------------------------------------------*/
 /* pic16_allocDirReg - allocates register of given type                  */
@@ -574,17 +780,55 @@ pic16_allocDirReg (operand *op )
 
 	name = OP_SYMBOL (op)->rname[0] ? OP_SYMBOL (op)->rname : OP_SYMBOL (op)->name;
 
-	if(!SPEC_OCLS( OP_SYM_ETYPE(op))) {									// patch 13
-		if(pic16_debug_verbose)										//
-		{												//
-			fprintf(stderr, "%s:%d symbol %s(r:%s) is not assigned to a memmap\n", __FILE__, __LINE__,	//
-		    		OP_SYMBOL(op)->name, OP_SYMBOL(op)->rname);								//
-		}												//
-		return NULL;											//
-	}													// patch 13
 
+	if(!SPEC_OCLS( OP_SYM_ETYPE(op))) {
+#if 0
+		if(pic16_debug_verbose)
+		{
+			fprintf(stderr, "%s:%d symbol %s(r:%s) is not assigned to a memmap\n", __FILE__, __LINE__,
+		    		OP_SYMBOL(op)->name, OP_SYMBOL(op)->rname);
+		}
+#endif
+		return NULL;
+	}
+
+	if(!IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op)))
+		|| !IN_FARSPACE(SPEC_OCLS( OP_SYM_ETYPE(op))) ) {
+
+#if 0
+		if(pic16_debug_verbose) {
+			fprintf(stderr, "dispace:%d farspace:%d codespace:%d regspace:%d stack:%d eeprom: %d regparm: %d isparm: %d\n",
+				IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+				IN_FARSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+				IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+				IN_REGSP( SPEC_OCLS( OP_SYM_ETYPE(op))),
+				IN_STACK( OP_SYM_ETYPE(op)),
+				SPEC_OCLS(OP_SYM_ETYPE(op)) == eeprom,
+				IS_REGPARM(OP_SYM_ETYPE(op)),
+				IS_PARM(op));
+
+			fprintf(stderr, "%s:%d symbol %s NOT in dirspace\n", __FILE__, __LINE__,
+	    		OP_SYMBOL(op)->name);
+		}
+#endif
+
+	}
+
+
+
+	if (IS_CODE ( OP_SYM_ETYPE(op)) ) {
+//		fprintf(stderr, "%s:%d sym: %s in codespace\n", __FUNCTION__, __LINE__, OP_SYMBOL(op)->name);
+		return NULL;
+	}
+
+	if(IS_ITEMP(op))return NULL;
+	
+//	if(IS_STATIC(OP_SYM_ETYPE(op)))return NULL;
+	
+	if(IN_STACK(OP_SYM_ETYPE(op)))return NULL;
+	
 	debugLog ("%s:%d symbol name %s\n", __FUNCTION__, __LINE__, name);
-//	fprintf(stderr, "%s symbol name %s\n", __FUNCTION__,name);
+//	fprintf(stderr, "%s symbol name %s\tSTATIC:%d\n", __FUNCTION__,name, IS_STATIC(OP_SYM_ETYPE(op)));
 
 	{
 		if(SPEC_CONST ( OP_SYM_ETYPE(op)) && (IS_CHAR ( OP_SYM_ETYPE(op)) )) {
@@ -611,27 +855,8 @@ pic16_allocDirReg (operand *op )
 		debugAopGet(NULL, op);
 	}
 
-	if (IS_CODE ( OP_SYM_ETYPE(op)) )
-		return NULL;
-
-	/* First, search the hash table to see if there is a register with this name */
-	if (SPEC_ABSA ( OP_SYM_ETYPE(op)) && !(IS_BITVAR (OP_SYM_ETYPE(op))) ) {
-		reg=NULL;
-//		reg = regWithIdx (pic16_dynProcessorRegs, SPEC_ADDR ( OP_SYM_ETYPE(op)), 1);
 
-#if 0
-		if(!reg) 
-			fprintf(stderr,"%s:%d: ralloc %s is at fixed address but not a processor reg, addr=0x%x\n",
-					__FUNCTION__, __LINE__, name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
-		else
-			fprintf(stderr,"%s:%d: ralloc %s at fixed address has already been declared, addr=0x%x\n",
-					__FUNCTION__, __LINE__, name, SPEC_ADDR ( OP_SYM_ETYPE(op)));
-#endif
-	} else {
-//		fprintf(stderr,"ralloc:%d %s \n", __LINE__,name);
-    
-		reg = pic16_dirregWithName(name);
-	}
+	reg = pic16_dirregWithName(name);
 
 	if(!reg) {
 	  int address = 0;
@@ -646,71 +871,79 @@ pic16_allocDirReg (operand *op )
 		/* Register wasn't found in hash, so let's create
 		 * a new one and put it in the hash table AND in the 
 		 * dynDirectRegNames set */
-		if(IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(op)))) {
-
-//			if(pic16_debug_verbose)
-//			    	fprintf(stderr, "%s:%d symbol %s in codespace\n", __FILE__, __LINE__,
-//			    		OP_SYMBOL(op)->name);
-
+		if(IS_CODE(OP_SYM_ETYPE(op)) || IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(op)))) {
 			debugLog("%s:%d sym: %s in codespace\n", __FUNCTION__, __LINE__, OP_SYMBOL(op)->name);
 	    	  return NULL;
 		}
 
-		if(1) {	//!PIC16_IS_CONFIG_ADDRESS(address)) {
-//			fprintf(stderr,"%s:allocating new reg %s\n",__FUNCTION__, name);
 
-			/* this is an error, why added? -- VR */
-//			if(SPEC_SCLS(OP_SYM_ETYPE(op)))regtype = REG_SFR;
+#if 0
+		if(OP_SYMBOL(op)->onStack) {
+			fprintf(stderr, "%s:%d onStack %s offset: %d\n", __FILE__, __LINE__,
+				OP_SYMBOL(op)->name, OP_SYMBOL(op)->stack);
+		}
+#endif
 
-			if(OP_SYMBOL(op)->onStack) {
-//				fprintf(stderr, "%s:%d onStack %s\n", __FILE__, __LINE__, OP_SYMBOL(op)->name);
-				OP_SYMBOL(op)->onStack = 0;
-				SPEC_OCLS(OP_SYM_ETYPE(op)) = data;
-				regtype = REG_GPR;
-			}
+		if(!IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op)))
+			|| !IN_FARSPACE(SPEC_OCLS( OP_SYM_ETYPE(op))) ) {
 
-			if(!IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op)))) {						// patch 13
-				if(pic16_debug_verbose)									//
-				{											//
-					fprintf(stderr, "dispace:%d farspace:%d codespace:%d regspace:%d stack:%d\n",
-						IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
-						IN_FARSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
-						IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
-						IN_REGSP( SPEC_OCLS( OP_SYM_ETYPE(op))),
-						IN_STACK( OP_SYM_ETYPE(op)));
-
-					fprintf(stderr, "%s:%d symbol %s NOT in dirspace\n", __FILE__, __LINE__,	//
-				    		OP_SYMBOL(op)->name);							//
-				}											//
-//				return NULL;										//
-			}												// patch 13
-
-			reg = newReg(regtype, PO_DIR, rDirectIdx++, name,getSize (OP_SYMBOL (op)->type),0, op);
-			debugLog ("%d  -- added %s to hash, size = %d\n", __LINE__, name,reg->size);
-
-//			hTabAddItem(&dynDirectRegNames, regname2key(name), reg);	/* commented out */
-
-//			if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
-//				fprintf(stderr, " ralloc.c at fixed address: %s - changing to REG_SFR\n",name);
-//				reg->type = REG_SFR;
-//			}
-
-			if (IS_BITVAR (OP_SYM_ETYPE(op))) {
-//				fprintf(stderr, "%s:%d adding %s in bit registers\n", __FILE__, __LINE__, reg->name);
-				addSet(&pic16_dynDirectBitRegs, reg);
-				reg->isBitField = 1;
-			} else {
-//				fprintf(stderr, "%s:%d adding %s in direct registers\n", __FILE__, __LINE__, reg->name);
-//				addSet(&pic16_dynDirectRegs, reg);
-				checkAddReg(&pic16_dynDirectRegs, reg);
+#if 0
+			if(pic16_debug_verbose)
+			{
+				fprintf(stderr, "dispace:%d farspace:%d codespace:%d regspace:%d stack:%d eeprom: %d\n",
+					IN_DIRSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+					IN_FARSPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+					IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(op))),
+					IN_REGSP( SPEC_OCLS( OP_SYM_ETYPE(op))),
+					IN_STACK( OP_SYM_ETYPE(op)),
+					SPEC_OCLS(OP_SYM_ETYPE(op)) == eeprom);
+
+					fprintf(stderr, "%s:%d symbol %s NOT in dirspace\n", __FILE__, __LINE__,
+			    		OP_SYMBOL(op)->name);
 			}
-	
+#endif
+		}
+
+		reg = newReg(regtype, PO_DIR, rDirectIdx++, name,getSize (OP_SYMBOL (op)->type),0, op);
+		debugLog ("%d  -- added %s to hash, size = %d\n", __LINE__, name,reg->size);
+
+		if( SPEC_SCLS( OP_SYM_ETYPE( op ) ) == S_REGISTER ) {
+			fprintf(stderr, "%s:%d symbol %s is declared as register\n", __FILE__, __LINE__,
+				name);
+				
+			reg->accessBank = 1;
+			checkAddReg(&pic16_dynAccessRegs, reg);
+			hTabAddItem(&dynAccessRegNames, regname2key(name), reg);
+			
+		  return (reg);
+		}
+
+
+//		if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
+//			fprintf(stderr, " ralloc.c at fixed address: %s - changing to REG_SFR\n",name);
+//			reg->type = REG_SFR;
+//		}
+
+		if (IS_BITVAR (OP_SYM_ETYPE(op))) {
+//			fprintf(stderr, "%s:%d adding %s in bit registers\n", __FILE__, __LINE__, reg->name);
+			addSet(&pic16_dynDirectBitRegs, reg);
+			reg->isBitField = 1;
 		} else {
-			debugLog ("  -- %s is declared at address 0x30000x\n",name);
-//			fprintf(stderr, "  -- %s is declared at address 0x30000x\n",name);
-	
-		  return NULL;
+//			fprintf(stderr, "%s:%d adding %s in direct registers\n", __FILE__, __LINE__, reg->name);
+//			addSet(&pic16_dynDirectRegs, reg);
+
+#if 1
+                  if(!(IS_STATIC(OP_SYM_ETYPE(op))
+                      && OP_SYMBOL(op)->ival
+                  ))
+#endif
+                    checkAddReg(&pic16_dynDirectRegs, reg);
 		}
+	
+	} else {
+//		debugLog ("  -- %s is declared at address 0x30000x\n",name);
+	  return (reg);			/* This was NULL before, but since we found it
+					 * why not just return it?! */
 	}
 
 	if (SPEC_ABSA ( OP_SYM_ETYPE(op)) ) {
@@ -718,8 +951,8 @@ pic16_allocDirReg (operand *op )
 		reg->address = SPEC_ADDR ( OP_SYM_ETYPE(op));
 
 		/* work around for user defined registers in access bank */
-		if((reg->address>= 0x00 && reg->address < 0x80)
-			|| (reg->address >= 0xf80 && reg->address <= 0xfff))
+		if((reg->address>= 0x00 && reg->address < pic16->acsSplitOfs)
+			|| (reg->address >= (0xf00 + pic16->acsSplitOfs) && reg->address <= 0xfff))
 			reg->accessBank = 1;
 		
 		debugLog ("  -- and it is at a fixed address 0x%02x\n",reg->address);
@@ -751,7 +984,7 @@ pic16_allocRegByName (char *name, int size, operand *op)
      * a new one and put it in the hash table AND in the 
      * dynDirectRegNames set */
 
-//	fprintf (stderr,"%s:%d symbol name %s\tregop= %p\n", __FUNCTION__, __LINE__, name, op);
+	//fprintf (stderr,"%s:%d symbol name %s\tregop= %p\n", __FUNCTION__, __LINE__, name, op);
 
     reg = newReg(REG_GPR, PO_DIR, rDirectIdx++, name,size,0, op);
 
@@ -774,7 +1007,7 @@ regs *pic16_typeRegWithIdx (int idx, int type, int fixed)
   regs *dReg;
 
   debugLog ("%s - requesting index = 0x%x\n", __FUNCTION__,idx);
-//  fprintf(stderr, "%s - requesting index = 0x%x\n", __FUNCTION__, idx);
+//  fprintf(stderr, "%s - requesting index = 0x%x (type = %d [%s])\n", __FUNCTION__, idx, type, decodeRegType(type));
 
   switch (type) {
 
@@ -789,6 +1022,11 @@ regs *pic16_typeRegWithIdx (int idx, int type, int fixed)
       return dReg;
     }
 
+	if( (dReg = regWithIdx ( pic16_dynInternalRegs, idx, fixed)) != NULL ) {
+      debugLog ("Found an Internal Register!\n");
+      return dReg;
+    }
+		
     break;
   case REG_STK:
     if( (dReg = regWithIdx ( pic16_dynStackRegs, idx, fixed)) != NULL ) {
@@ -797,7 +1035,7 @@ regs *pic16_typeRegWithIdx (int idx, int type, int fixed)
     }
     break;
   case REG_SFR:
-    if( (dReg = regWithIdx ( pic16_dynProcessorRegs, idx, fixed)) != NULL ) {
+    if( (dReg = regWithIdx ( pic16_dynProcessorRegs, idx, 1)) != NULL ) {
       debugLog ("Found a Processor Register!\n");
       return dReg;
     }
@@ -826,8 +1064,10 @@ pic16_regWithIdx (int idx)
   if( (dReg = pic16_typeRegWithIdx(idx,REG_SFR,0)) != NULL)
     return dReg;
 
+#if 0
   if( (dReg = pic16_typeRegWithIdx(idx,REG_STK,0)) != NULL)
     return dReg;
+#endif
 
   return NULL;
 }
@@ -839,7 +1079,7 @@ regs *
 pic16_allocWithIdx (int idx)
 {
 
-  regs *dReg;
+  regs *dReg=NULL;
 
   debugLog ("%s - allocating with index = 0x%x\n", __FUNCTION__,idx);
 //  fprintf(stderr, "%s - allocating with index = 0x%x\n", __FUNCTION__,idx);
@@ -849,7 +1089,7 @@ pic16_allocWithIdx (int idx)
     debugLog ("Found a Dynamic Register!\n");
   } else if( (dReg = regWithIdx ( pic16_dynStackRegs, idx,0)) != NULL ) {
     debugLog ("Found a Stack Register!\n");
-  } else if( (dReg = regWithIdx ( pic16_dynProcessorRegs, idx,0)) != NULL ) {
+  } else if( (dReg = regWithIdx ( pic16_dynProcessorRegs, idx,1)) != NULL ) {
     debugLog ("Found a Processor Register!\n");
     fprintf(stderr, "Found a processor register! %s\n", dReg->name);
   } else if( (dReg = regWithIdx ( pic16_dynInternalRegs, idx,0)) != NULL ) {
@@ -858,12 +1098,19 @@ pic16_allocWithIdx (int idx)
     
     debugLog ("Dynamic Register not found\n");
 
+#if 1
+	dReg = newReg(REG_GPR, PO_GPR_TEMP, idx, NULL, 1, 0, NULL);
+	addSet(&pic16_dynAllocRegs, dReg);
+	hTabAddItem(&dynAllocRegNames, regname2key(dReg->name), dReg);
+#endif
 
+	if(!dReg) {
+//  	return (NULL);
     //fprintf(stderr,"%s %d - requested register: 0x%x\n",__FUNCTION__,__LINE__,idx);
-    werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	    "regWithIdx not found");
-    exit (1);
-
+	    werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+		    "allocWithIdx not found");
+	    exit (1);
+	}
   }
 
   dReg->wasUsed = 1;
@@ -883,7 +1130,8 @@ pic16_findFreeReg(short type)
   case REG_GPR:
     if((dReg = regFindFree(pic16_dynAllocRegs)) != NULL)
       return dReg;
-    return allocReg( REG_GPR );		//addSet(&pic16_dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0, NULL));
+//	return (addSet(&pic16_dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0, NULL)));
+    return allocReg( REG_GPR );
 
   case REG_STK:
 
@@ -899,6 +1147,34 @@ pic16_findFreeReg(short type)
     return NULL;
   }
 }
+
+regs *
+pic16_findFreeRegNext(short type, regs *creg)
+{
+  //  int i;
+  regs* dReg;
+
+  switch (type) {
+  case REG_GPR:
+    if((dReg = regFindFreeNext(pic16_dynAllocRegs, creg)) != NULL)
+      return dReg;
+//	  return (addSet(&pic16_dynAllocRegs,newReg(REG_GPR, PO_GPR_TEMP,dynrIdx++,NULL,1,0, NULL)));
+    return (allocReg( REG_GPR ) );
+
+  case REG_STK:
+
+    if((dReg = regFindFreeNext(pic16_dynStackRegs, creg)) != NULL)
+      return dReg;
+
+    return NULL;
+
+  case REG_PTR:
+  case REG_CND:
+  case REG_SFR:
+  default:
+    return NULL;
+  }
+}
 /*-----------------------------------------------------------------*/
 /* freeReg - frees a register                                      */
 /*-----------------------------------------------------------------*/
@@ -975,12 +1251,15 @@ static void writeSetUsedRegs(FILE *of, set *dRegs)
 extern void pic16_groupRegistersInSection(set *regset);
 
 extern void pic16_dump_equates(FILE *of, set *equs);
+extern void pic16_dump_access(FILE *of, set *section);
 //extern void pic16_dump_map(void);
 extern void pic16_dump_usection(FILE *of, set *section, int fix);
 extern void pic16_dump_isection(FILE *of, set *section, int fix);
 extern void pic16_dump_int_registers(FILE *of, set *section);
 extern void pic16_dump_idata(FILE *of, set *idataSymSet);
 
+extern void pic16_dump_gsection(FILE *of, set *sections);
+
 static void packBits(set *bregs)
 {
   set *regset;
@@ -1043,140 +1322,44 @@ static void packBits(set *bregs)
       
 }
 
-
-
-#if 0
-static void bitEQUs(FILE *of, set *bregs)
-{
-  regs *breg,*bytereg;
-  int bit_no=0;
-
-  //fprintf(stderr," %s\n",__FUNCTION__);
-  for (breg = setFirstItem(bregs) ; breg ;
-       breg = setNextItem(bregs)) {
-
-    //fprintf(stderr,"bit reg: %s\n",breg->name);
-
-    bytereg = breg->reg_alias;
-    if(bytereg)
-      fprintf (of, "%s\tEQU\t( (%s<<3)+%d)\n",
-	       breg->name,
-	       bytereg->name,
-	       breg->rIdx & 0x0007);
-
-    else {
-      fprintf(stderr, "bit field is not assigned to a register\n");
-      fprintf (of, "%s\tEQU\t( (bitfield%d<<3)+%d)\n",
-	       breg->name,
-	       bit_no>>3,
-	       bit_no & 0x0007);
-
-      bit_no++;
-    }
-  }
-      
-}
-
-static void aliasEQUs(FILE *of, set *fregs, int use_rIdx)
-{
-  regs *reg;
-
-
-  for (reg = setFirstItem(fregs) ; reg ;
-       reg = setNextItem(fregs)) {
-
-    if(!reg->isEmitted && reg->wasUsed) {
-      if(use_rIdx) {
-        if (reg->type != REG_SFR) {
-	  fprintf (of, "%s\tEQU\t0x%03x\n",
-		   reg->name,
-		   reg->rIdx);
-        }
-      }
-      else
-	fprintf (of, "%s\tEQU\t0x%03x\n",
-		 reg->name,
-		 reg->address);
-    }
-  }
-      
-}
-#endif
-
 void pic16_writeUsedRegs(FILE *of) 
 {
-	packBits(pic16_dynDirectBitRegs);
-
-	pic16_groupRegistersInSection(pic16_dynAllocRegs);
-	pic16_groupRegistersInSection(pic16_dynInternalRegs);
-	pic16_groupRegistersInSection(pic16_dynStackRegs);
-	pic16_groupRegistersInSection(pic16_dynDirectRegs);
-	pic16_groupRegistersInSection(pic16_dynDirectBitRegs);
-	pic16_groupRegistersInSection(pic16_dynProcessorRegs);
-	
+  packBits(pic16_dynDirectBitRegs);
+
+  pic16_groupRegistersInSection(pic16_dynAllocRegs);
+  pic16_groupRegistersInSection(pic16_dynInternalRegs);
+  pic16_groupRegistersInSection(pic16_dynStackRegs);
+  pic16_groupRegistersInSection(pic16_dynDirectRegs);
+  pic16_groupRegistersInSection(pic16_dynDirectBitRegs);
+  pic16_groupRegistersInSection(pic16_dynProcessorRegs);
+  pic16_groupRegistersInSection(pic16_dynAccessRegs);
 	
-#if 0
-	pic16_assignFixedRegisters(pic16_dynAllocRegs);
-	pic16_assignFixedRegisters(pic16_dynStackRegs);
-	pic16_assignFixedRegisters(pic16_dynDirectRegs);
-	pic16_assignFixedRegisters(pic16_dynProcessorRegs);
-
-	pic16_assignRelocatableRegisters(pic16_dynDirectBitRegs, 0);
-	pic16_assignRelocatableRegisters(pic16_dynInternalRegs,0);
-	pic16_assignRelocatableRegisters(pic16_dynAllocRegs,0);
-	pic16_assignRelocatableRegisters(pic16_dynStackRegs,0);
-	pic16_assignRelocatableRegisters(pic16_dynDirectRegs,0);
-#endif
+  /* dump equates */
+  pic16_dump_equates(of, pic16_equ_data);
 
-//	pic16_dump_map();
-//	pic16_dump_cblock(of);
+//	pic16_dump_esection(of, pic16_rel_eedata, 0);
+//	pic16_dump_esection(of, pic16_fix_eedata, 0);
 
-	/* dump equates */
-	pic16_dump_equates(of, pic16_equ_data);
+  /* dump access bank symbols */
+  pic16_dump_access(of, pic16_acs_udata);
 
-	/* dump initialised data */
-	pic16_dump_isection(of, rel_idataSymSet, 0);
-	pic16_dump_isection(of, fix_idataSymSet, 1);
+  /* dump initialised data */
+  pic16_dump_isection(of, rel_idataSymSet, 0);
+  pic16_dump_isection(of, fix_idataSymSet, 1);
 
-//	pic16_dump_idata(of, idataSymSet);
-
-	/* dump internal registers */
-	pic16_dump_int_registers(of, pic16_int_regs);
-	
-	/* dump other variables */
-	pic16_dump_usection(of, pic16_rel_udata, 0);
-	pic16_dump_usection(of, pic16_fix_udata, 1);
+  if(!xinst) {
+    /* dump internal registers */
+    pic16_dump_int_registers(of, pic16_int_regs);
+  }
 	
-}
+  /* dump generic section variables */
+  pic16_dump_gsection(of, sectNames);
 
-#if 0
-/*-----------------------------------------------------------------*/
-/* allDefsOutOfRange - all definitions are out of a range          */
-/*-----------------------------------------------------------------*/
-static bool
-allDefsOutOfRange (bitVect * defs, int fseq, int toseq)
-{
-  int i;
-
-  debugLog ("%s\n", __FUNCTION__);
-  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;
+  /* dump other variables */
+  pic16_dump_usection(of, pic16_rel_udata, 0);
+  pic16_dump_usection(of, pic16_fix_udata, 1);
 }
-#endif
+
 
 /*-----------------------------------------------------------------*/
 /* computeSpillable - given a point find the spillable live ranges */
@@ -1661,7 +1844,9 @@ selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
 
       /* check if there are any live ranges that not
          used in the remainder of the block */
-      if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
+      if (!_G.blockSpil &&
+          !isiCodeInFunctionCall (ic) &&       
+          (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
 	{
 	  sym = leastUsedLR (selectS);
 	  if (!sym->remat)
@@ -1897,6 +2082,13 @@ deassignLRs (iCode * ic, eBBlock * ebp)
       if (!bitVectBitValue (_G.regAssigned, sym->key))
 	continue;
 
+      /* special case for shifting: there is a case where shift count
+       * can be allocated in the same register as the result, so do not
+       * free right registers if same as result registers, cause genShiftLeft
+       * will fail -- VR */
+       if(ic->op == LEFT_OP)
+         continue;
+
       /* special case check if this is an IFX &
          the privious one was a pop and the 
          previous one was not spilt then keep track
@@ -1927,6 +2119,7 @@ deassignLRs (iCode * ic, eBBlock * ebp)
 	      (result = OP_SYMBOL (IC_RESULT (ic))) &&	/* has a result */
 	      result->liveTo > ic->seq &&	/* and will live beyond this */
 	      result->liveTo <= ebp->lSeq &&	/* does not go beyond this block */
+	      result->liveFrom == ic->seq &&    /* does not start before here */
 	      result->regType == sym->regType &&	/* same register types */
 	      result->nRegs &&	/* which needs registers */
 	      !result->isspilt &&	/* and does not already have them */
@@ -1938,15 +2131,20 @@ deassignLRs (iCode * ic, eBBlock * ebp)
 		sym->nRegs) >= result->nRegs)
 	    )
 	    {
+	      
+
+//	      for (i = 0; i < max (sym->nRegs, result->nRegs); i++)
+              /* the above does not free the unsued registers in sym,
+               * leaving them marked as used, and increasing register usage
+               * until the end of the function - VR 23/11/05 */
 
-	      for (i = 0; i < max (sym->nRegs, result->nRegs); i++)
+	      for (i = 0; i < result->nRegs; i++)
 		if (i < sym->nRegs)
 		  result->regs[i] = sym->regs[i];
 		else
 		  result->regs[i] = getRegGpr (ic, ebp, result);
 
 	      _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
-
 	    }
 
 	  /* free the remaining */
@@ -2097,14 +2295,12 @@ static void
 serialRegAssign (eBBlock ** ebbs, int count)
 {
   int i;
-
+  iCode *ic;
+  
   debugLog ("%s\n", __FUNCTION__);
   /* for all blocks */
   for (i = 0; i < count; i++)
     {
-
-      iCode *ic;
-
       if (ebbs[i]->noPath &&
 	  (ebbs[i]->entryLabel != entryLabel &&
 	   ebbs[i]->entryLabel != returnLabel))
@@ -2114,7 +2310,7 @@ serialRegAssign (eBBlock ** ebbs, int count)
       for (ic = ebbs[i]->sch; ic; ic = ic->next)
 	{
 
-	  debugLog ("  op: %s\n", decodeOp (ic->op));
+	  debugLog ("  op: %s\n", pic16_decodeOp (ic->op));
 
 		if(IC_RESULT(ic) && !IS_ITEMP( IC_RESULT(ic)))
 			pic16_allocDirReg(IC_RESULT(ic));
@@ -2158,6 +2354,13 @@ serialRegAssign (eBBlock ** ebbs, int count)
 	      int j;
 	      int ptrRegSet = 0;
 
+	      /* Make sure any spill location is definately allocated */
+	      if (sym->isspilt && !sym->remat && sym->usl.spillLoc &&
+		  !sym->usl.spillLoc->allocreq)
+		{
+		  sym->usl.spillLoc->allocreq++;
+		}
+
 	      /* if it does not need or is spilt 
 	         or is already assigned to registers
 	         or will not live beyond this instructions */
@@ -2180,6 +2383,10 @@ serialRegAssign (eBBlock ** ebbs, int count)
 	         or this one is rematerializable then
 	         spill this one */
 	      willCS = willCauseSpill (sym->nRegs, sym->regType);
+
+	      /* explicit turn off register spilling */
+	      willCS = 0;
+	      
 	      spillable = computeSpillable (ic);
 	      if (sym->remat ||
 		  (willCS && bitVectIsZero (spillable)))
@@ -2195,12 +2402,13 @@ serialRegAssign (eBBlock ** ebbs, int count)
 		 have been allocated after sym->liveFrom but freed
 		 before ic->seq. This is complicated, so spill this
 		 symbol instead and let fillGaps handle the allocation. */
+#if 0
 	      if (sym->liveFrom < ic->seq)
 		{
 		    spillThis (sym);
 		    continue;		      
 		}
-
+#endif
 	      /* if it has a spillocation & is used less than
 	         all other live ranges then spill this */
 		if (willCS) {
@@ -2227,9 +2435,22 @@ serialRegAssign (eBBlock ** ebbs, int count)
 	      if (ic->op == RECEIVE)
 		debugLog ("When I get clever, I'll optimize the receive logic\n");
 
+              if(POINTER_GET(ic) && IS_BITFIELD(getSpec(operandType(IC_RESULT(ic))))
+                && (SPEC_BLEN(getSpec(operandType(IC_RESULT(ic))))==1)
+                && (ic->next->op == IFX)
+                && (OP_LIVETO(IC_RESULT(ic)) == ic->next->seq)) {
+
+                /* skip register allocation since none will be used */
+                for(j=0;j<sym->nRegs;j++)
+                  sym->regs[j] = newReg(REG_TMP, PO_GPR_TEMP, 0, "bad", 1, 0, NULL);
+//                OP_SYMBOL(IC_RESULT(ic))->nRegs = 0;
+                
+                continue;
+              }
+
 	      /* if we need ptr regs for the right side
 	         then mark it */
-	      if (POINTER_GET (ic) && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
+	      if (POINTER_GET (ic) && IS_SYMOP( IC_LEFT(ic) ) && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
 		  <= (unsigned) PTRSIZE)
 		{
 		  pic16_ptrRegReq++;
@@ -2238,7 +2459,6 @@ serialRegAssign (eBBlock ** ebbs, int count)
 	      /* else we assign registers to it */
 	      _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
 
-	      debugLog ("  %d - \n", __LINE__);
 	      if(debugF) 
 		bitVectDebugOn(_G.regAssigned, debugF);
 
@@ -2591,7 +2811,6 @@ regTypeNum ()
 	if (IS_AGGREGATE (sym->type) || sym->isptr)
 	  sym->type = aggrToPtr (sym->type, FALSE);
 	debugLog ("  %d - no reg needed - used as a return\n", __LINE__);
-
 	continue;
       }
 
@@ -2607,6 +2826,7 @@ regTypeNum ()
 	  !IS_BITVAR (sym->etype) &&
 	  (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER)) {
 
+//        continue;       /* FIXME -- VR */
 	if (ptrPseudoSymSafe (sym, ic)) {
           
 	  symbol *psym;
@@ -2669,12 +2889,14 @@ regTypeNum ()
       /* registers for true symbols we will */
       /* see how things go                  */
       sym->nRegs = 0;
+      
   }
 
 }
 static DEFSETFUNC (markRegFree)
 {
   ((regs *)item)->isFree = 1;
+//  ((regs *)item)->wasUsed = 0;
 
   return 0;
 }
@@ -2791,53 +3013,42 @@ farSpacePackable (iCode * ic)
   return NULL;
 }
 
+#if 0
+static int packRegsForPointerGet(iCode *ic, eBBlock *ebp)
+{
+  iCode *dic, *sic;
+
+    debugLog ("%d\t%s\n", __LINE__, __FUNCTION__);
+    debugLog ("ic->op = %s\n", pic16_decodeOp( ic->op ) );
+    debugAopGet ("  result:", IC_RESULT (ic));
+    debugAopGet ("  left:", IC_LEFT (ic));
+    debugAopGet ("  right:", IC_RIGHT (ic));
+
+    dic = ic->prev;
+    if((dic->op == '=')
+      && (
+}
+#endif
+
+
+void replaceOperandWithOperand(eBBlock *ebp, iCode *ic, operand *src, iCode *dic, operand *dst);
+
 /*-----------------------------------------------------------------*/
 /* packRegsForAssign - register reduction for assignment           */
 /*-----------------------------------------------------------------*/
 static int
 packRegsForAssign (iCode * ic, eBBlock * ebp)
 {
-
   iCode *dic, *sic;
 
   debugLog ("%d\t%s\n", __LINE__, __FUNCTION__);
-  debugLog ("ic->op = %s\n", decodeOp( ic->op ) );
+  debugLog ("ic->op = %s\n", pic16_decodeOp( ic->op ) );
   debugAopGet ("  result:", IC_RESULT (ic));
   debugAopGet ("  left:", IC_LEFT (ic));
   debugAopGet ("  right:", IC_RIGHT (ic));
 
 //	fprintf(stderr, "%s:%d symbol = %s\n", __FILE__, __LINE__, OP_SYMBOL( IC_RESULT(ic))->name);
 
-#if 0
-  /* if this is at an absolute address, then get the address. */
-  if (SPEC_ABSA ( OP_SYM_ETYPE(IC_RESULT(ic))) ) {
-    if(PIC16_IS_CONFIG_ADDRESS( SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))))) {
-      debugLog ("  %d - found config word declaration\n", __LINE__);
-      if(IS_VALOP(IC_RIGHT(ic))) {
-	debugLog ("  setting config word to %x\n", 
-		  (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
-
-	fprintf(stderr, "%s:%d  setting config word to %x\n", __FILE__, __LINE__, 
-		  (int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
-
-	pic16_assignConfigWordValue(  SPEC_ADDR ( OP_SYM_ETYPE(IC_RESULT(ic))),
-				(int) floatFromVal (IC_RIGHT(ic)->operand.valOperand));
-      }
-
-
- 	debugLog(" %d\n", __LINE__);
-
-      /* remove the assignment from the iCode chain. */
-
-      remiCodeFromeBBlock (ebp, ic);
-      bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
-      hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-
-      return 1;
-
-    }
-  }
-#endif
 	debugLog(" %d - actuall processing\n", __LINE__ );
 
   if (!IS_ITEMP (IC_RESULT (ic))) {
@@ -2845,10 +3056,11 @@ packRegsForAssign (iCode * ic, eBBlock * ebp)
     debugLog ("  %d - result is not temp\n", __LINE__);
   }
 
+//  if(IS_VALOP(IC_RIGHT(ic)))return 0;
 
 /* See BUGLOG0001 - VR */
 #if 1
-  if (!IS_ITEMP (IC_RIGHT (ic))) {
+  if (!IS_ITEMP (IC_RIGHT (ic)) /*&& (!IS_PARM(IC_RESULT(ic)))*/) {
     debugLog ("  %d - not packing - right is not temp\n", __LINE__);
     pic16_allocDirReg(IC_RIGHT (ic));
     return 0;
@@ -2962,12 +3174,12 @@ packRegsForAssign (iCode * ic, eBBlock * ebp)
 	 * if it fits for pic16, but I leave it here just in case */
 
 	/* if assignment then check that right is not a bit */
-	if (ASSIGNMENT (dic) && !POINTER_SET (dic)) {
-	  sym_link *etype = operandType (IC_RIGHT (dic));
+	if (ASSIGNMENT (ic) && !POINTER_SET (ic)) {
+	  sym_link *etype = operandType (IC_RESULT (dic));
 
 		if (IS_BITFIELD (etype)) {
 			/* if result is a bit too then it's ok */
-			etype = operandType (IC_RESULT (dic));
+			etype = operandType (IC_RESULT (ic));
 			if (!IS_BITFIELD (etype)) {
 				debugLog(" %d bitfields\n");
 			  return 0;
@@ -2981,14 +3193,6 @@ packRegsForAssign (iCode * ic, eBBlock * ebp)
   if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
       OP_SYMBOL (IC_RESULT (ic))->iaccess)
     {
-
-#if 0
-	/* clear the onStack flag, the port doesn't support it yet! FIXME */
-	if(OP_SYMBOL(IC_RESULT(ic))->onStack)
-		OP_SYMBOL(IC_RESULT(ic))->onStack = 0;
-#endif
-	
-
       /* the operation has only one symbol
          operator then we can pack */
       if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
@@ -3007,34 +3211,35 @@ pack:
   /* found the definition */
   /* replace the result with the result of */
   /* this assignment and remove this assignment */
-  bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
-  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;
-    }
-  /* delete from liverange table also 
-     delete from all the points inbetween and the new
-     one */
-  for (sic = dic; sic != ic; sic = sic->next)
-    {
-      bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
-      if (IS_ITEMP (IC_RESULT (dic)))
-	bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
-    }
 
-  remiCodeFromeBBlock (ebp, ic);
-  bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
+  
+    bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
+    IC_RESULT (dic) = IC_RESULT (ic);
 
-	debugLog("  %d\n", __LINE__ );
-  hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
-  OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
-  return 1;
+    if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
+      {
+        OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
+      }
+    /* delete from liverange table also 
+       delete from all the points inbetween and the new
+       one */
+    for (sic = dic; sic != ic; sic = sic->next)
+      {
+        bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
+        if (IS_ITEMP (IC_RESULT (dic)))
+          bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
+      }
 
+    remiCodeFromeBBlock (ebp, ic);
+    bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
 
+    debugLog("  %d\n", __LINE__ );
+    hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
+    OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
+    return 1;
 }
 
+
 #if 1
 
 #define NO_packRegsForAccUse
@@ -3085,12 +3290,6 @@ findAssignToSym (operand * op, iCode * ic)
 	  if ((ic->op == '+' || ic->op == '-') &&
 	      OP_SYMBOL (IC_RIGHT (dic))->onStack)
 	    {
-
-#if 0
-		if(OP_SYMBOL(IC_RESULT(ic))->onStack)
-			OP_SYMBOL(IC_RESULT(ic))->onStack = 0;
-#endif
-
 	      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)
@@ -3224,16 +3423,24 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
   bitVect *uses;
   iCode *dic, *sic;
 
+  return NULL;
+
   debugLog ("%s\n", __FUNCTION__);
   /* if returning a literal then do nothing */
   if (!IS_SYMOP (op))
     return NULL;
 
+  if(OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly)
+    return NULL;
+
   /* only upto 2 bytes since we cannot predict
      the usage of b, & acc */
-  if (getSize (operandType (op)) > (pic16_fReturnSizePic - 3) &&	/* was 2, changed to 3 -- VR */
-      ic->op != RETURN &&
-      ic->op != SEND)
+  if (getSize (operandType (op)) > (pic16_fReturnSizePic - 1)
+      && ic->op != RETURN
+      && ic->op != SEND
+      && !POINTER_SET(ic)
+      && !POINTER_GET(ic)
+      )
     return NULL;
 
   /* this routine will mark the a symbol as used in one 
@@ -3242,10 +3449,18 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
      that definition is either a return value from a 
      function or does not contain any variables in
      far space */
+
+#if 0
   uses = bitVectCopy (OP_USES (op));
   bitVectUnSetBit (uses, ic->key);	/* take away this iCode */
   if (!bitVectIsZero (uses))	/* has other uses */
     return NULL;
+#endif
+
+#if 1
+  if (bitVectnBitsOn (OP_USES (op)) > 1)
+    return NULL;
+#endif
 
   /* if it has only one defintion */
   if (bitVectnBitsOn (OP_DEFS (op)) > 1)
@@ -3274,6 +3489,8 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
 	}
       dic = dic->next;
     }
+  else
+    {
 
 
   /* otherwise check that the definition does
@@ -3295,6 +3512,7 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
   if (POINTER_GET (dic) &&
       !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
     return NULL;
+    }
 
   sic = dic;
 
@@ -3325,7 +3543,7 @@ packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
          operation is a '*','/' or '%' then 'b' may
          cause a problem */
       if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
-	  getSize (operandType (op)) >= 3)
+	  getSize (operandType (op)) >= 2)
 	return NULL;
 
       /* if left or right or result is in far space */
@@ -3557,20 +3775,16 @@ packForReceive (iCode * ic, eBBlock * ebp)
 
   for (dic = ic->next; dic; dic = dic->next)
     {
-
-
-
       if (IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key))
-	debugLog ("    used on left\n");
+        debugLog ("    used on left\n");
       if (IC_RIGHT (dic) && IC_RESULT (ic)->key == IC_RIGHT (dic)->key)
-	debugLog ("    used on right\n");
+        debugLog ("    used on right\n");
       if (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key)
-	debugLog ("    used on result\n");
+        debugLog ("    used on result\n");
 
       if ((IC_LEFT (dic) && (IC_RESULT (ic)->key == IC_LEFT (dic)->key)) ||
-	  (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key))
+        (IC_RESULT (dic) && IC_RESULT (ic)->key == IC_RESULT (dic)->key))
 	return;
-
     }
 
   debugLog ("  hey we can remove this unnecessary assign\n");
@@ -3582,11 +3796,26 @@ static void
 packForPush (iCode * ic, eBBlock * ebp)
 {
   iCode *dic;
-
+  char *iLine;
+  
   debugLog ("%s\n", __FUNCTION__);
   if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
     return;
 
+#if 0
+  {
+    int n1, n2;
+    char *iLine;
+
+      n1 = bitVectnBitsOn( OP_DEFS(IC_LEFT(ic)));
+      n2 = bitVectnBitsOn( OP_USES(IC_LEFT(ic)));
+      iLine = printILine(ic);
+      debugf3("defs: %d\tuses: %d\t%s\n", n1, n2, printILine(ic));
+      dbuf_free(iLine);
+      debugf2("IC_LEFT(ic): from %d to %d\n", OP_LIVEFROM(IC_LEFT(ic)), OP_LIVETO(IC_LEFT(ic)));
+  }
+#endif
+
   /* must have only definition & one usage */
   if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
       bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
@@ -3597,12 +3826,28 @@ packForPush (iCode * ic, eBBlock * ebp)
 			       bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
     return;
 
+  /* if definition is not assignment,
+   * or is not pointer (because pointer might have changed) */
   if (dic->op != '=' || POINTER_SET (dic))
     return;
 
+  /* we must ensure that we can use the delete the assignment,
+   * because the source might have been modified in between.
+   * Until I know how to fix this, I'll use the adhoc fix
+   * to check the liveranges */
+  if((OP_LIVEFROM(IC_RIGHT(dic))==0) || (OP_LIVETO(IC_RIGHT(dic))==0))
+    return;
+//  debugf2("IC_RIGHT(dic): from %d to %d\n", OP_LIVEFROM(IC_RIGHT(dic)), OP_LIVETO(IC_RIGHT(dic)));
+  
+
+
   /* 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);
+  
+  iLine = printILine(dic);
+  debugf("remiCodeFromeBBlock: %s\n", iLine);
+  dbuf_free(iLine);
 
   remiCodeFromeBBlock (ebp, dic);
   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
@@ -3614,7 +3859,7 @@ static void printSymType(char * str, sym_link *sl)
 	if(!pic16_ralloc_debug)return;
 	
 	debugLog ("    %s Symbol type: ",str);
-	printTypeChain( sl, debugF);
+	printTypeChain (sl, debugF);
 	debugLog ("\n");
 }
 
@@ -3627,33 +3872,32 @@ static void isData(sym_link *sl)
 {
   FILE *of = stderr;
 
-	if(!pic16_ralloc_debug)return;
-	
-	if(!sl)return;
-
-	if(debugF)
-		of = debugF;
-
-	for ( ; sl; sl=sl->next) {
-		if(!IS_DECL(sl) ) {
-			switch (SPEC_SCLS(sl)) {
-				case S_DATA: fprintf (of, "data "); break;
-				case S_XDATA: fprintf (of, "xdata "); break;
-				case S_SFR: fprintf (of, "sfr "); break;
-				case S_SBIT: fprintf (of, "sbit "); break;
-				case S_CODE: fprintf (of, "code "); break;
-				case S_IDATA: fprintf (of, "idata "); break;
-				case S_PDATA: fprintf (of, "pdata "); break;
-				case S_LITERAL: fprintf (of, "literal "); break;
-				case S_STACK: fprintf (of, "stack "); break;
-				case S_XSTACK: fprintf (of, "xstack "); break;
-				case S_BIT: fprintf (of, "bit "); break;
-				case S_EEPROM: fprintf (of, "eeprom "); break;
-				default: break;
-			}
-
-		}
-	}
+    if(!pic16_ralloc_debug)return;
+    
+    if(!sl)return;
+    
+    if(debugF)
+      of = debugF;
+
+    for ( ; sl; sl=sl->next) {
+      if(!IS_DECL(sl) ) {
+        switch (SPEC_SCLS(sl)) {
+          case S_DATA: fprintf (of, "data "); break;
+          case S_XDATA: fprintf (of, "xdata "); break;
+          case S_SFR: fprintf (of, "sfr "); break;
+          case S_SBIT: fprintf (of, "sbit "); break;
+          case S_CODE: fprintf (of, "code "); break;
+          case S_IDATA: fprintf (of, "idata "); break;
+          case S_PDATA: fprintf (of, "pdata "); break;
+          case S_LITERAL: fprintf (of, "literal "); break;
+          case S_STACK: fprintf (of, "stack "); break;
+          case S_XSTACK: fprintf (of, "xstack "); break;
+          case S_BIT: fprintf (of, "bit "); break;
+          case S_EEPROM: fprintf (of, "eeprom "); break;
+          default: break;
+        }
+      }
+    }
 }
 
 
@@ -3682,8 +3926,6 @@ pic16_packRegisters (eBBlock * ebp)
       {
 //		debugLog("%d\n", __LINE__);
 	/* find assignment of the form TrueSym := iTempNN:1 */
-	/* see BUGLOG0001 for workaround with the CAST - VR */
-//	if ( (ic->op == '=' || ic->op == CAST) && !POINTER_SET (ic) ) // patch 11
  	if ( (ic->op == '=') && !POINTER_SET (ic) ) // patch 11
 	  change += packRegsForAssign (ic, ebp);
 	/* debug stuff */
@@ -3755,9 +3997,45 @@ pic16_packRegisters (eBBlock * ebp)
 
 
     if (POINTER_SET (ic))
-	debugLog ("  %d - Pointer set\n", __LINE__);
-
+      debugLog ("  %d - Pointer set\n", __LINE__);
+      
+      /* Look for two subsequent iCodes with */
+      /*   iTemp := _c;         */
+      /*   _c = iTemp & op;     */
+      /* and replace them by    */
+      /*   iTemp := _c;         */
+      /*   _c = _c & op;        */
+      if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^')
+        && ic->prev
+        && ic->prev->op == '='
+        && IS_ITEMP (IC_LEFT (ic))
+        && IC_LEFT (ic) == IC_RESULT (ic->prev)
+        && isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev)))
+        {
+          iCode* ic_prev = ic->prev;
+          symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev));
+			
+          ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic));
+          if (IC_RESULT (ic_prev) != IC_RIGHT (ic)) {
+            bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key);
+            if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */
+              prev_result_sym->liveTo == ic->seq)
+            {
+              prev_result_sym->liveTo = ic_prev->seq;
+            }
+          }
+          bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
+          
+          bitVectSetBit (ic->rlive, IC_RESULT (ic)->key);
 
+          if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev)))) {
+            bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key);
+            bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key);
+            remiCodeFromeBBlock (ebp, ic_prev);
+            hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL);
+          }
+        }
+		
     /* if this is an itemp & result of a address of a true sym 
        then mark this as rematerialisable   */
     if (ic->op == ADDRESS_OF &&
@@ -3808,18 +4086,64 @@ pic16_packRegisters (eBBlock * ebp)
 	OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
       }
 
+
+#if 0
+    /* try to optimize FSR0 usage when reading data memory pointers */
+     
+    if(getenv("OPTIMIZE_NEAR_POINTER_GET")) {
+	  static int fsr0usage=0;
+	  static iCode *usic;
+
+		if(POINTER_GET(ic)				/* this is a memory read */
+			&& ic->loop					/* this is in a loop */
+		) {
+			fprintf(stderr, "might optimize FSR0 usage\n");
+		}
+    }
+#endif
+          
     /* mark the pointer usages */
     if (POINTER_SET (ic))
       {
 	OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
 	debugLog ("  marking as a pointer (set) =>");
 	debugAopGet ("  result:", IC_RESULT (ic));
+
       }
+
     if (POINTER_GET (ic))
       {
-	OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
-	debugLog ("  marking as a pointer (get) =>");
-	debugAopGet ("  left:", IC_LEFT (ic));
+        if(IS_SYMOP(IC_LEFT(ic))) {
+          OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
+          debugLog ("  marking as a pointer (get) =>");
+          debugAopGet ("  left:", IC_LEFT (ic));
+        }
+        
+        if(getenv("OPTIMIZE_BITFIELD_POINTER_GET")) {
+          if(IS_ITEMP(IC_LEFT(ic)) && IS_BITFIELD(OP_SYM_ETYPE(IC_LEFT(ic)))) {
+            iCode *dic = ic->prev;
+
+            fprintf(stderr, "%s:%d might give opt POINTER_GET && IS_BITFIELD(IC_LEFT)\n", __FILE__, __LINE__);
+          
+            if(dic && dic->op == '='
+              && isOperandEqual(IC_RESULT(dic), IC_LEFT(ic))) {
+              
+                fprintf(stderr, "%s:%d && prev is '=' && prev->result == ic->left\n", __FILE__, __LINE__);
+
+
+                /* replace prev->left with ic->left */
+                IC_LEFT(ic) = IC_RIGHT(dic);
+                IC_RIGHT(ic->prev) = NULL;
+                
+                /* remove ic->prev iCode (assignment) */
+                remiCodeFromeBBlock (ebp, dic);
+                bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,ic->key);
+
+
+                hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
+            }
+          }
+        }
       }
 
 	//debugLog("  %d   %s\n", __LINE__, __FUNCTION__);
@@ -3976,6 +4300,12 @@ pic16_packRegisters (eBBlock * ebp)
       }
     }
 #endif
+
+#if 1
+    /* there are some problems with packing variables
+     * it seems that the live range estimator doesn't
+     * estimate correctly the liveranges of some symbols */
+     
     /* pack for PUSH 
        iTempNN := (some variable in farspace) V1
        push iTempNN ;
@@ -3986,7 +4316,7 @@ pic16_packRegisters (eBBlock * ebp)
       {
 	packForPush (ic, ebp);
       }
-
+#endif
 
 #ifndef NO_packRegsForAccUse
     /* pack registers for accumulator use, when the
@@ -4056,12 +4386,17 @@ dumpEbbsToDebug (eBBlock ** ebbs, int count)
       printiCChain (ebbs[i]->sch, debugF);
     }
 }
+
+void dbg_dumpregusage(void);
+
 /*-----------------------------------------------------------------*/
 /* pic16_assignRegisters - assigns registers to each live range as need  */
 /*-----------------------------------------------------------------*/
 void
-pic16_assignRegisters (eBBlock ** ebbs, int count)
+pic16_assignRegisters (ebbIndex * ebbi)
 {
+  eBBlock ** ebbs = ebbi->bbOrder;
+  int count = ebbi->count;
   iCode *ic;
   int i;
 
@@ -4069,6 +4404,26 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   debugLog ("\nebbs before optimizing:\n");
   dumpEbbsToDebug (ebbs, count);
 
+  _inRegAllocator = 1;
+
+  pic16_freeAllRegs();
+#if 0
+	dbg_dumpregusage();
+	/* clear whats left over from peephole parser */
+	pic16_dynAllocRegs= newSet();	//NULL;
+//	pic16_dynStackRegs= newSet();	//NULL;
+//	pic16_dynProcessorRegs=newSet();	//NULL;
+//	pic16_dynDirectRegs=newSet();		//NULL;
+//	pic16_dynDirectBitRegs=newSet();	//NULL;
+//	pic16_dynInternalRegs=newSet();		//NULL;
+//	pic16_dynAccessRegs=newSet();		//NULL;
+
+//	dynDirectRegNames=NULL;
+	dynAllocRegNames=NULL;
+//	dynProcRegNames=NULL;
+//	dynAccessRegNames=NULL;
+#endif
+
   setToNull ((void *) &_G.funcrUsed);
   pic16_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
 
@@ -4078,19 +4433,21 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   for (i = 0; i < count; i++)
     pic16_packRegisters (ebbs[i]);
 
+
   {
     regs *reg;
     int hkey;
-    int i=0;
 
     debugLog("dir registers allocated so far:\n");
     reg = hTabFirstItem(dynDirectRegNames, &hkey);
 
+#if 0
     while(reg) {
       debugLog("  -- #%d reg = %s  key %d, rIdx = %d, size %d\n",i++,reg->name,hkey, reg->rIdx,reg->size);
 //      fprintf(stderr, "  -- #%d reg = %s  key %d, rIdx = %d, size %d\n",i++,reg->name,hkey, reg->rIdx,reg->size);
       reg = hTabNextItem(dynDirectRegNames, &hkey);
     }
+#endif
 
   }
 
@@ -4099,18 +4456,24 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   recomputeLiveRanges (ebbs, count);
 
   if (options.dump_pack)
-    dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
+    dumpEbbsToFileExt (DUMP_PACK, ebbi);
 
   /* first determine for each live range the number of 
      registers & the type of registers required for each */
   regTypeNum ();
 
+  /* start counting function temporary registers from zero */
+  /* XXX: Resetting dynrIdx breaks register allocation,
+   *      see #1489055, #1483693 (?), and #1445850! */
+  //dynrIdx = 0;
+
   /* and serially allocate registers */
   serialRegAssign (ebbs, count);
 
-//  debugLog ("ebbs after serialRegAssign:\n");
-//  dumpEbbsToDebug (ebbs, count);
-
+#if 0
+  debugLog ("ebbs after serialRegAssign:\n");
+  dumpEbbsToDebug (ebbs, count);
+#endif
 
   //pic16_freeAllRegs();
 
@@ -4137,7 +4500,9 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   redoStackOffsets ();
 
   if (options.dump_rassgn)
-    dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
+    dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
+
+//  dumpLR(ebbs, count);
 
   /* now get back the chain */
   ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
@@ -4146,6 +4511,8 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   dumpEbbsToDebug (ebbs, count);
 
 
+  _inRegAllocator = 0;
+
   genpic16Code (ic);
 
   /* free up any _G.stackSpil locations allocated */
@@ -4156,6 +4523,7 @@ pic16_assignRegisters (eBBlock ** ebbs, int count)
   /* mark all registers as free */
   pic16_freeAllRegs ();
 
+
   debugLog ("leaving\n<><><><><><><><><><><><><><><><><>\n");
   debugLogClose ();
   return;