X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic%2Fpcode.c;h=5128c5ad85a8636f87c767f2fe5bb34699f9ac62;hb=195ee3f3ee25ce2c5f2a59fbd2779c4cb80527c3;hp=8cdbf6b9d888d1bda89696bd5ecd8b8f650ddabe;hpb=617ae3de6c95d9293627b9da71a724343f8d5f0d;p=fw%2Fsdcc

diff --git a/src/pic/pcode.c b/src/pic/pcode.c
index 8cdbf6b9..5128c5ad 100644
--- a/src/pic/pcode.c
+++ b/src/pic/pcode.c
@@ -57,7 +57,7 @@ peepCommand peepCommands[] = {
 pCodeOpReg pc_status    = {{PO_STATUS,  "STATUS"}, -1, NULL,0,NULL};
 pCodeOpReg pc_indf      = {{PO_INDF,    "INDF"}, -1, NULL,0,NULL};
 pCodeOpReg pc_fsr       = {{PO_FSR,     "FSR"}, -1, NULL,0,NULL};
-pCodeOpReg pc_intcon    = {{PO_INTCON,  ""}, -1, NULL,0,NULL};
+pCodeOpReg pc_intcon    = {{PO_INTCON,  "INTCON"}, -1, NULL,0,NULL};
 pCodeOpReg pc_pcl       = {{PO_PCL,     "PCL"}, -1, NULL,0,NULL};
 pCodeOpReg pc_pclath    = {{PO_PCLATH,  "PCLATH"}, -1, NULL,0,NULL};
 
@@ -75,13 +75,18 @@ static pFile *the_pFile = NULL;
 static pBlock *pb_dead_pcodes = NULL;
 
 /* Hardcoded flags to change the behavior of the PIC port */
-static int peepOptimizing = 0;        /* run the peephole optimizer if nonzero */
+static int peepOptimizing = 1;        /* run the peephole optimizer if nonzero */
 static int functionInlining = 1;      /* inline functions if nonzero */
 int debug_verbose = 0;                /* Set true to inundate .asm file */
 
 // static int GpCodeSequenceNumber = 1;
 int GpcFlowSeq = 1;
 
+/* statistics (code size estimation) */
+static unsigned int pcode_insns = 0;
+static unsigned int pcode_doubles = 0;
+
+
 unsigned maxIdx; /* This keeps track of the maximum register index for call tree register reuse */
 unsigned peakIdx; /* This keeps track of the peak register index for call tree register reuse */
 
@@ -119,6 +124,8 @@ pBlock *newpBlock(void);
 pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval);
 void pCodeRegMapLiveRanges(pBlock *pb);
 
+pBranch * pBranchAppend(pBranch *h, pBranch *n);
+
 
 /****************************************************************/
 /*                    PIC Instructions                          */
@@ -1255,7 +1262,7 @@ unsigned PCodeID(void) {
 	static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */
 	/*
 	static unsigned int stop;
-	if (pcodeId == 524)
+	if (pcodeId == 1448)
 		stop++; // Place break point here
 	*/
 	return pcodeId++;
@@ -1343,16 +1350,18 @@ void  pCodeInitRegisters(void)
 		return;
 	initialized = 1;
 	
-	shareBankAddress = 0x7f; /* FIXME - some PIC ICs like 16C7X which do not have a shared bank need a different approach. */
-	stkSize = 8; // Set pseudo stack size to 8
-	initStack(shareBankAddress, stkSize); // Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters
 	init_pic(port->processor);
+	shareBankAddress = 0x7f; /* FIXME - some PIC ICs like 16C7X which do not have a shared bank need a different approach. */
+	if ((unsigned)shareBankAddress > getMaxRam()) /* If total RAM is less than 0x7f as with 16f84 then reduce shareBankAddress to fit */
+		shareBankAddress = (int)getMaxRam();
+	stkSize = 15; /* Set pseudo stack size to 15, on multi memory bank ICs this leaves room for WSAVE (used for interrupts) to fit into the shared portion of the memory bank */
+	initStack(shareBankAddress, stkSize); /* Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters */
 	
 	pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180);
 	pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
 	pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x180);
 	pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x180);
-	pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x80);
+	pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x180);
 	pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x180);
 	
 	pc_status.rIdx = IDX_STATUS;
@@ -1362,9 +1371,9 @@ void  pCodeInitRegisters(void)
 	pc_pcl.rIdx = IDX_PCL;
 	pc_pclath.rIdx = IDX_PCLATH;
 	
-	pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
-	pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for status register. */
-	pc_psave.r = allocInternalRegister(IDX_PSAVE,"PSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for pclath register. */
+	pc_wsave.r = allocInternalRegister(IDX_WSAVE,pc_wsave.pcop.name,pc_wsave.pcop.type, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
+	pc_ssave.r = allocInternalRegister(IDX_SSAVE,pc_ssave.pcop.name,pc_ssave.pcop.type, 0); /* Interrupt storage for status register. */
+	pc_psave.r = allocInternalRegister(IDX_PSAVE,pc_psave.pcop.name,pc_psave.pcop.type, 0); /* Interrupt storage for pclath register. */
 	
 	pc_wsave.rIdx = pc_wsave.r->rIdx;
 	pc_ssave.rIdx = pc_ssave.r->rIdx;
@@ -1388,7 +1397,7 @@ void  pCodeInitRegisters(void)
 /*                                                                 */
 /*-----------------------------------------------------------------*/
 
-int mnem2key(char const *mnem)
+int mnem2key(unsigned char const *mnem)
 {
 	int key = 0;
 	
@@ -1637,7 +1646,7 @@ void copypCode(FILE *of, char dbName)
 	
 	if(!of || !the_pFile)
 		return;
-	
+
 	for(pb = the_pFile->pbHead; pb; pb = pb->next) {
 		if(getpBlock_dbName(pb) == dbName) {
 			pBlockStats(of,pb);
@@ -1647,6 +1656,21 @@ void copypCode(FILE *of, char dbName)
 	}
 	
 }
+
+void resetpCodeStatistics (void)
+{
+  pcode_insns = pcode_doubles = 0;
+}
+
+void dumppCodeStatistics (FILE *of)
+{
+	/* dump statistics */
+	fprintf (of, "\n");
+	fprintf (of, ";\tcode size estimation:\n");
+	fprintf (of, ";\t%5u+%5u = %5u instructions (%5u byte)\n", pcode_insns, pcode_doubles, pcode_insns + pcode_doubles, 2*(pcode_insns + 2*pcode_doubles));
+	fprintf (of, "\n");
+}
+
 void pcode_test(void)
 {
 	
@@ -1992,7 +2016,7 @@ pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
 /* newpCodeCSource - create a new pCode Source Symbol              */
 /*-----------------------------------------------------------------*/
 
-pCode *newpCodeCSource(int ln, char *f, char *l)
+pCode *newpCodeCSource(int ln, char *f, const char *l)
 {
 	
 	pCodeCSource *pccs;
@@ -2021,6 +2045,49 @@ pCode *newpCodeCSource(int ln, char *f, char *l)
 	return ( (pCode *)pccs);
 	
 }
+
+/*******************************************************************/
+/* pic16_newpCodeAsmDir - create a new pCode Assembler Directive   */
+/*                        added by VR 6-Jun-2003                   */
+/*******************************************************************/
+
+pCode *newpCodeAsmDir(char *asdir, char *argfmt, ...)
+{
+  pCodeAsmDir *pcad;
+  va_list ap;
+  char buffer[512];
+  char *lbp=buffer;
+
+  pcad = Safe_calloc(1, sizeof(pCodeAsmDir));
+  pcad->pci.pc.type = PC_ASMDIR;
+  pcad->pci.pc.prev = pcad->pci.pc.next = NULL;
+  pcad->pci.pc.pb = NULL;
+  pcad->pci.pc.destruct = genericDestruct;
+  pcad->pci.pc.print = genericPrint;
+
+  if(asdir && *asdir) {
+
+    while(isspace((unsigned char)*asdir))asdir++;	// strip any white space from the beginning
+
+    pcad->directive = Safe_strdup( asdir );
+  }
+
+  va_start(ap, argfmt);
+
+  memset(buffer, 0, sizeof(buffer));
+  if(argfmt && *argfmt)
+    vsprintf(buffer, argfmt, ap);
+
+  va_end(ap);
+
+  while(isspace((unsigned char)*lbp))lbp++;
+
+  if(lbp && *lbp)
+    pcad->arg = Safe_strdup( lbp );
+
+  return ((pCode *)pcad);
+}
+
 /*-----------------------------------------------------------------*/
 /* pCodeLabelDestruct - free memory used by a label.               */
 /*-----------------------------------------------------------------*/
@@ -2394,6 +2461,7 @@ pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type)
 void pCodeConstString(char *name, char *value)
 {
 	pBlock *pb;
+	unsigned i;
 	
 	//  fprintf(stderr, " %s  %s  %s\n",__FUNCTION__,name,value);
 	
@@ -2405,6 +2473,15 @@ void pCodeConstString(char *name, char *value)
 	addpBlock(pb);
 	
 	sprintf(buffer,"; %s = %s",name,value);
+	for (i=strlen(buffer); i--; ) {
+		unsigned char c = buffer[i];
+		if (c=='\r' || c=='\n') {
+			memmove(buffer+i+1,buffer+i,strlen(buffer)-i+1);
+			buffer[i] = '\\';
+			if (c=='\r') buffer[i+1] = 'r';
+			else if (c=='\n') buffer[i+1] = 'n';
+		}
+	}
 	
 	addpCode2pBlock(pb,newpCodeCharP(buffer));
 	addpCode2pBlock(pb,newpCodeLabel(name,-1));
@@ -2555,9 +2632,19 @@ void printpBlock(FILE *of, pBlock *pb)
 	if(!of)
 		of = stderr;
 	
-	for(pc = pb->pcHead; pc; pc = pc->next)
+	for(pc = pb->pcHead; pc; pc = pc->next) {
 		printpCode(of,pc);
-	
+
+		if (isPCI(pc))
+		{
+			if (isPCI(pc) && (PCI(pc)->op == POC_PAGESEL || PCI(pc)->op == POC_BANKSEL)) {
+				pcode_doubles++;
+			} else {
+				pcode_insns++;
+			}
+		}
+	} // for
+
 }
 
 /*-----------------------------------------------------------------*/
@@ -2581,7 +2668,20 @@ void unlinkpCode(pCode *pc)
 			pc->prev->next = pc->next;
 		if(pc->next)
 			pc->next->prev = pc->prev;
-		
+
+#if 0
+		/* RN: I believe this should be right here, but this did not
+		 *     cure the bug I was hunting... */
+		/* must keep labels -- attach to following instruction */
+		if (isPCI(pc) && PCI(pc)->label && pc->next)
+		{
+		  pCodeInstruction *pcnext = PCI(findNextInstruction (pc->next));
+		  if (pcnext)
+		  {
+		    pBranchAppend (pcnext->label, PCI(pc)->label);
+		  }
+		}
+#endif
 		pc->prev = pc->next = NULL;
 	}
 }
@@ -2806,10 +2906,14 @@ pCodeOp *popCopyReg(pCodeOpReg *pc)
 	} else
 		pcor->pcop.name = NULL;
 	
-	pcor->r = pc->r;
-	pcor->rIdx = pc->rIdx;
-	pcor->r->wasUsed=1;
-	
+	if (pcor->pcop.type == PO_IMMEDIATE){
+		PCOL(pcor)->lit = PCOL(pc)->lit;
+	} else {
+		pcor->r = pc->r;
+		pcor->rIdx = pc->rIdx;
+		if (pcor->r)
+			pcor->r->wasUsed=1;
+	}	
 	//DEBUGpic14_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
 	
 	return PCOP(pcor);
@@ -2907,41 +3011,44 @@ char *get_op(pCodeOp *pcop,char *buffer, size_t size)
 			
 		case PO_IMMEDIATE:
 			s = buffer;
-			
 			if(PCOI(pcop)->_const) {
 				
-				if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) {
+				if( PCOI(pcop)->offset >= 0 && PCOI(pcop)->offset<4) {
 					switch(PCOI(pcop)->offset) {
 					case 0:
-						SAFE_snprintf(&s,&size,"low %s",pcop->name);
+						SAFE_snprintf(&s,&size,"low (%s+%d)",pcop->name, PCOI(pcop)->index);
 						break;
 					case 1:
-						SAFE_snprintf(&s,&size,"high %s",pcop->name);
+						SAFE_snprintf(&s,&size,"high (%s+%d)",pcop->name, PCOI(pcop)->index);
 						break;
 					default:
+						fprintf (stderr, "PO_IMMEDIATE/_const/offset=%d\n", PCOI(pcop)->offset);
+						assert ( !"offset too large" );
 						SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
 							pcop->name,
 							PCOI(pcop)->index,
 							8 * PCOI(pcop)->offset );
 					}
 				} else
-					SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index);
+					SAFE_snprintf(&s,&size,"LOW (%s+%d)",pcop->name,PCOI(pcop)->index);
 			} else {
-				
-				if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) {
+				if( !PCOI(pcop)->offset) { // && PCOI(pcc->pcop)->offset<4) {
 					SAFE_snprintf(&s,&size,"(%s + %d)",
 						pcop->name,
-						PCOI(pcop)->index );
+						PCOI(pcop)->index);
 				} else {
 					switch(PCOI(pcop)->offset) {
 					case 0:
-						SAFE_snprintf(&s,&size,"%s",pcop->name);
+						SAFE_snprintf(&s,&size,"(%s + %d)",pcop->name, PCOI(pcop)->index);
 						break;
 					case 1:
-						SAFE_snprintf(&s,&size,"high %s",pcop->name);
+						SAFE_snprintf(&s,&size,"high (%s + %d)",pcop->name, PCOI(pcop)->index);
 						break;
 					default:
-						SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset);
+						fprintf (stderr, "PO_IMMEDIATE/mutable/offset=%d\n", PCOI(pcop)->offset);
+						assert ( !"offset too large" );
+						SAFE_snprintf(&s,&size,"((%s + %d) >> %d)&0xff",pcop->name, PCOI(pcop)->index, 8*PCOI(pcop)->offset);
+						break;
 					}
 				}
 			}
@@ -3020,85 +3127,90 @@ static void pCodeOpPrint(FILE *of, pCodeOp *pcop)
 }
 
 /*-----------------------------------------------------------------*/
+/* pCode2str - convert a pCode instruction to string               */
 /*-----------------------------------------------------------------*/
 char *pCode2str(char *str, size_t size, pCode *pc)
 {
-	char *s = str;
-	
-	switch(pc->type) {
-		
-	case PC_OPCODE:
-		
-		SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
-		
-		if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
-			
-			if(PCI(pc)->isBitInst) {
-				if(PCI(pc)->pcop->type == PO_GPR_BIT) {
-					char *name = PCI(pc)->pcop->name;
-					if (!name) 
-						name = PCOR(PCI(pc)->pcop)->r->name;
-					if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
-						SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
-					else
-						SAFE_snprintf(&s,&size,"%s,%d", name, 
-						(((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
-				} else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
-					SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
-				}else
-					SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
-				//PCI(pc)->pcop->t.bit );
-			} else {
-				
-				if(PCI(pc)->pcop->type == PO_GPR_BIT) {
-					if( PCI(pc)->num_ops == 2)
-						SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
-					else
-						SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
-					
-				}else {
-					SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
-					
-					if( PCI(pc)->num_ops == 2)
-						SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
-				}
-			}
-			
-		}
-		break;
-		
-	case PC_COMMENT:
-		/* assuming that comment ends with a \n */
-		SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
-		break;
-		
-	case PC_INLINE:
-		/* assuming that inline code ends with a \n */
-		SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
-		break;
-		
-	case PC_LABEL:
-		SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
-		break;
-	case PC_FUNCTION:
-		SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
-		break;
-	case PC_WILD:
-		SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
-		break;
-	case PC_FLOW:
-		SAFE_snprintf(&s,&size,";\t--FLOW change\n");
-		break;
-	case PC_CSOURCE:
-		SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
-		break;
-		
-	case PC_BAD:
-		SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
-	}
-	
-	return str;
-	
+  char *s = str;
+
+  switch(pc->type) {
+
+  case PC_OPCODE:
+
+    SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic);
+
+    if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) {
+
+      if(PCI(pc)->isBitInst) {
+        if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+          char *name = PCI(pc)->pcop->name;
+          if (!name)
+            name = PCOR(PCI(pc)->pcop)->r->name;
+          if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
+            SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name);
+          else
+            SAFE_snprintf(&s,&size,"%s,%d", name, 
+            (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
+        } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+          SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
+      } else
+          SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
+        //PCI(pc)->pcop->t.bit );
+      } else {
+        if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+          if( PCI(pc)->num_ops == 2)
+            SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
+          else
+            SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
+        } else {
+          SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc)));
+          if( PCI(pc)->num_ops == 2)
+            SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W'));
+        }
+      }
+    }
+    break;
+
+  case PC_COMMENT:
+    /* assuming that comment ends with a \n */
+    SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment);
+    break;
+
+  case PC_INLINE:
+    /* assuming that inline code ends with a \n */
+    SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment);
+    break;
+
+  case PC_LABEL:
+    SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
+    break;
+  case PC_FUNCTION:
+    SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
+    break;
+  case PC_WILD:
+    SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id);
+    break;
+  case PC_FLOW:
+    SAFE_snprintf(&s,&size,";\t--FLOW change\n");
+    break;
+  case PC_CSOURCE:
+//    SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
+    SAFE_snprintf(&s,&size,"%s\t.line\t%d; \"%s\"\t%s\n",(options.debug?"":";"),PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line);
+    break;
+  case PC_ASMDIR:
+    if(PCAD(pc)->directive) {
+      SAFE_snprintf(&s,&size,"\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:"");
+    } else if(PCAD(pc)->arg) {
+      /* special case to handle inline labels without a tab */
+      SAFE_snprintf(&s,&size,"%s\n", PCAD(pc)->arg);
+    }
+    break;
+
+  case PC_BAD:
+    SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
+  }
+
+  return str;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3106,106 +3218,123 @@ char *pCode2str(char *str, size_t size, pCode *pc)
 /*-----------------------------------------------------------------*/
 static void genericPrint(FILE *of, pCode *pc)
 {
-	
-	if(!pc || !of)
-		return;
-	
-	switch(pc->type) {
-	case PC_COMMENT:
-		fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
-		break;
-		
-	case PC_INLINE:
-		fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
-		break;
-		
-	case PC_OPCODE:
-		// If the opcode has a label, print that first
-		{
-			char str[256];
-			pCodeInstruction *pci = PCI(pc);
-			pBranch *pbl = pci->label;
-			while(pbl && pbl->pc) {
-				if(pbl->pc->type == PC_LABEL)
-					pCodePrintLabel(of, pbl->pc);
-				pbl = pbl->next;
-			}
-		
-			if(pci->cline) 
-				genericPrint(of,PCODE(pci->cline));
-		
-			
-			pCode2str(str, 256, pc);
-			
-			fprintf(of,"%s",str);
-			
-			/* Debug */
-			if(debug_verbose) {
-				pCodeOpReg *pcor = PCOR(pci->pcop);
-				fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
-				if(pci->pcflow)
-					fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq);
-				if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed)
-					fprintf(of,",rIdx=r0x%X",pcor->rIdx);
-			}
-		}
+  if(!pc || !of)
+    return;
+
+  switch(pc->type) {
+  case PC_COMMENT:
+    fprintf(of,";%s\n", ((pCodeComment *)pc)->comment);
+    break;
+
+  case PC_INLINE:
+    fprintf(of,"%s\n", ((pCodeComment *)pc)->comment);
+    break;
+
+  case PC_OPCODE:
+    // If the opcode has a label, print that first
+    {
+      char str[256];
+      pCodeInstruction *pci = PCI(pc);
+      pBranch *pbl = pci->label;
+      while(pbl && pbl->pc) {
+        if(pbl->pc->type == PC_LABEL)
+          pCodePrintLabel(of, pbl->pc);
+        pbl = pbl->next;
+      }
+
+      if(pci->cline)
+        genericPrint(of,PCODE(pci->cline));
+
+
+      pCode2str(str, 256, pc);
+
+      fprintf(of,"%s",str);
+
+      /* Debug */
+      if(debug_verbose) {
+        pCodeOpReg *pcor = PCOR(pci->pcop);
+        fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
+        if(pci->pcflow)
+          fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq);
+        if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed)
+          fprintf(of,",rIdx=r0x%X",pcor->rIdx);
+      }
+    }
 #if 0
-		{
-			pBranch *dpb = pc->to;   // debug
-			while(dpb) {
-				switch ( dpb->pc->type) {
-				case PC_OPCODE:
-					fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
-					break;
-				case PC_LABEL:
-					fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
-					break;
-				case PC_FUNCTION:
-					fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
-					break;
-				case PC_FLOW:
-					fprintf(of, "\t;flow");
-					break;
-				case PC_COMMENT:
-				case PC_WILD:
-					break;
-				}
-				dpb = dpb->next;
-			}
-		}
+    {
+      pBranch *dpb = pc->to;   // debug
+      while(dpb) {
+        switch ( dpb->pc->type) {
+        case PC_OPCODE:
+          fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic);
+          break;
+        case PC_LABEL:
+          fprintf(of, "\t;label %d", PCL(dpb->pc)->key);
+          break;
+        case PC_FUNCTION:
+          fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]"));
+          break;
+        case PC_FLOW:
+          fprintf(of, "\t;flow");
+          break;
+        case PC_COMMENT:
+        case PC_WILD:
+          break;
+        }
+        dpb = dpb->next;
+      }
+    }
 #endif
-		fprintf(of,"\n");
-		break;
-		
-	case PC_WILD:
-		fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
-		if(PCW(pc)->pci.label)
-			pCodePrintLabel(of, PCW(pc)->pci.label->pc);
-		
-		if(PCW(pc)->operand) {
-			fprintf(of,";\toperand  ");
-			pCodeOpPrint(of,PCW(pc)->operand );
-		}
-		break;
-		
-	case PC_FLOW:
-		if(debug_verbose) {
-			fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
-			if(PCFL(pc)->ancestor)
-				fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
-			fprintf(of,"\n");
-			
-		}
-		break;
-		
-	case PC_CSOURCE:
-		fprintf(of,";#CSRC\t%s %d\n;  %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
-		break;
-	case PC_LABEL:
-	default:
-		fprintf(of,"unknown pCode type %d\n",pc->type);
-	}
-	
+    fprintf(of,"\n");
+    break;
+
+  case PC_WILD:
+    fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id);
+    if(PCW(pc)->pci.label)
+      pCodePrintLabel(of, PCW(pc)->pci.label->pc);
+    
+    if(PCW(pc)->operand) {
+      fprintf(of,";\toperand  ");
+      pCodeOpPrint(of,PCW(pc)->operand );
+    }
+    break;
+
+  case PC_FLOW:
+    if(debug_verbose) {
+      fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq);
+      if(PCFL(pc)->ancestor)
+        fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
+      fprintf(of,"\n");
+    }
+    break;
+
+  case PC_CSOURCE:
+//    fprintf(of,";#CSRC\t%s %d\n;  %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line);
+    fprintf(of,"%s\t.line\t%d; \"%s\"\t%s\n", (options.debug?"":";"), PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line);
+    break;
+
+  case PC_ASMDIR:
+    {
+      pBranch *pbl = PCAD(pc)->pci.label;
+      while(pbl && pbl->pc) {
+        if(pbl->pc->type == PC_LABEL)
+          pCodePrintLabel(of, pbl->pc);
+        pbl = pbl->next;
+      }
+    }
+    if(PCAD(pc)->directive) {
+      fprintf(of, "\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:"");
+    } else
+    if(PCAD(pc)->arg) {
+      /* special case to handle inline labels without tab */
+      fprintf(of, "%s\n", PCAD(pc)->arg);
+    }
+    break;
+
+  case PC_LABEL:
+  default:
+    fprintf(of,"unknown pCode type %d\n",pc->type);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3259,47 +3388,45 @@ static void pCodePrintLabel(FILE *of, pCode *pc)
 		fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key);
 	
 }
+
 /*-----------------------------------------------------------------*/
 /* unlinkpCodeFromBranch - Search for a label in a pBranch and     */
 /*                         remove it if it is found.               */
 /*-----------------------------------------------------------------*/
 static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc)
 {
-	pBranch *b, *bprev;
-	
-	
-	bprev = NULL;
-	
-	if(pcl->type == PC_OPCODE)
-		b = PCI(pcl)->label;
-	else {
-		fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
-		exit(1);
-		
-	}
-	
-	//fprintf (stderr, "%s \n",__FUNCTION__);
-	//pcl->print(stderr,pcl);
-	//pc->print(stderr,pc);
-	while(b) {
-		if(b->pc == pc) {
-			//fprintf (stderr, "found label\n");
-			
-			/* Found a label */
-			if(bprev) {
-				bprev->next = b->next;  /* Not first pCode in chain */
-				free(b);
-			} else {
-				pc->destruct(pc);
-				PCI(pcl)->label = b->next;   /* First pCode in chain */
-				free(b);
-			}
-			return;  /* A label can't occur more than once */
-		}
-		bprev = b;
-		b = b->next;
-	}
-	
+  pBranch *b, *bprev;
+
+  bprev = NULL;
+
+  if(pcl->type == PC_OPCODE || pcl->type == PC_INLINE || pcl->type == PC_ASMDIR)
+    b = PCI(pcl)->label;
+  else {
+    fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__);
+    exit(1);
+  }
+  
+  //fprintf (stderr, "%s \n",__FUNCTION__);
+  //pcl->print(stderr,pcl);
+  //pc->print(stderr,pc);
+  while(b) {
+    if(b->pc == pc) {
+      //fprintf (stderr, "found label\n");
+      
+      /* Found a label */
+      if(bprev) {
+        bprev->next = b->next;  /* Not first pCode in chain */
+        free(b);
+      } else {
+        pc->destruct(pc);
+        PCI(pcl)->label = b->next;   /* First pCode in chain */
+        free(b);
+      }
+      return;  /* A label can't occur more than once */
+    }
+    bprev = b;
+    b = b->next;
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3459,24 +3586,24 @@ static void genericAnalyze(pCode *pc)
 /*-----------------------------------------------------------------*/
 int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
 {
-	pBranch *pbr;
-	
-	if(pc->type == PC_LABEL) {
-		if( ((pCodeLabel *)pc)->key ==  pcop_label->key)
-			return TRUE;
-	}
-	if(pc->type == PC_OPCODE) {
-		pbr = PCI(pc)->label;
-		while(pbr) {
-			if(pbr->pc->type == PC_LABEL) {
-				if( ((pCodeLabel *)(pbr->pc))->key ==  pcop_label->key)
-					return TRUE;
-			}
-			pbr = pbr->next;
-		}
-	}
-	
-	return FALSE;
+  pBranch *pbr;
+  
+  if(pc->type == PC_LABEL) {
+    if( ((pCodeLabel *)pc)->key ==  pcop_label->key)
+      return TRUE;
+  }
+  if(pc->type == PC_OPCODE || pc->type == PC_ASMDIR) {
+    pbr = PCI(pc)->label;
+    while(pbr) {
+      if(pbr->pc->type == PC_LABEL) {
+        if( ((pCodeLabel *)(pbr->pc))->key ==  pcop_label->key)
+          return TRUE;
+      }
+      pbr = pbr->next;
+    }
+  }
+  
+  return FALSE;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3531,7 +3658,7 @@ pCode * findLabel(pCodeOpLabel *pcop_label)
 			return pc;
 	}
 	
-	fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name);
+	fprintf(stderr,"Couldn't find label %s\n", pcop_label->pcop.name);
 	return NULL;
 }
 
@@ -3581,27 +3708,23 @@ pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
 /*-----------------------------------------------------------------*/
 pCode * findNextInstruction(pCode *pci)
 {
-	pCode *pc = pci;
-	
-	while(pc) {
-		if((pc->type == PC_OPCODE) || (pc->type == PC_WILD)) {
-			/*
-			static unsigned int stop;
-			if (pc->id == 524)
-				stop++; // Place break point here
-			*/
-			return pc;
-		}
-		
+  pCode *pc = pci;
+
+  while(pc) {
+  if((pc->type == PC_OPCODE)
+    || (pc->type == PC_WILD)
+    || (pc->type == PC_ASMDIR))
+      return pc;
+
 #ifdef PCODE_DEBUG
-		fprintf(stderr,"findNextInstruction:  ");
-		printpCode(stderr, pc);
+    fprintf(stderr,"findNextInstruction:  ");
+    printpCode(stderr, pc);
 #endif
-		pc = pc->next;
-	}
-	
-	//fprintf(stderr,"Couldn't find instruction\n");
-	return NULL;
+    pc = pc->next;
+  }
+
+  //fprintf(stderr,"Couldn't find instruction\n");
+  return NULL;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3610,7 +3733,25 @@ pCode * findNextInstruction(pCode *pci)
 /*-----------------------------------------------------------------*/
 pCode * findPrevInstruction(pCode *pci)
 {
-	return findPrevpCode(pci, PC_OPCODE);
+  pCode *pc = pci;
+
+  while(pc) {
+
+    if((pc->type == PC_OPCODE)
+      || (pc->type == PC_WILD)
+      || (pc->type == PC_ASMDIR))
+      return pc;
+      
+
+#ifdef PCODE_DEBUG
+    fprintf(stderr,"pic16_findPrevInstruction:  ");
+    printpCode(stderr, pc);
+#endif
+    pc = pc->prev;
+  }
+
+  //fprintf(stderr,"Couldn't find instruction\n");
+  return NULL;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3619,7 +3760,6 @@ pCode * findPrevInstruction(pCode *pci)
 /*-----------------------------------------------------------------*/
 pCode * findFunctionEnd(pCode *pc)
 {
-	
 	while(pc) {
 		if(pc->type == PC_FUNCTION &&  !(PCF(pc)->fname))
 			return pc;
@@ -3673,7 +3813,7 @@ static void AnalyzeRETURN(pCode *pc)
 /*-----------------------------------------------------------------*/
 regs * getRegFromInstruction(pCode *pc)
 {
-	
+	regs *r;
 	if(!pc                   || 
 		!isPCI(pc)            ||
 		!PCI(pc)->pcop        ||
@@ -3684,36 +3824,33 @@ regs * getRegFromInstruction(pCode *pc)
 	case PO_INDF:
 	case PO_FSR:
 		return PCOR(PCI(pc)->pcop)->r;
-		
-		//    return typeRegWithIdx (PCOR(PCI(pc)->pcop)->rIdx, REG_SFR, 0);
-		
+
 	case PO_BIT:
 	case PO_GPR_TEMP:
-		//fprintf(stderr, "getRegFromInstruction - bit or temp\n");
 		return PCOR(PCI(pc)->pcop)->r;
 		
 	case PO_IMMEDIATE:
-		if(PCOI(PCI(pc)->pcop)->r)
-			return (PCOI(PCI(pc)->pcop)->r);
-		
-		//fprintf(stderr, "getRegFromInstruction - immediate\n");
+		r = PCOI(PCI(pc)->pcop)->r;
+		if (r)
+			return r;
 		return dirregWithName(PCI(pc)->pcop->name);
-		//return NULL; // PCOR(PCI(pc)->pcop)->r;
 		
 	case PO_GPR_BIT:
-		return PCOR(PCI(pc)->pcop)->r;
+		r = PCOR(PCI(pc)->pcop)->r;
+		if (r)
+			return r;
+		return dirregWithName(PCI(pc)->pcop->name);
 		
 	case PO_GPR_REGISTER:
 	case PO_DIR:
-		//fprintf(stderr, "getRegFromInstruction - dir\n");
-		return PCOR(PCI(pc)->pcop)->r;
+		r = PCOR(PCI(pc)->pcop)->r;
+		if (r)
+			return r;
+		return dirregWithName(PCI(pc)->pcop->name);
 	case PO_LITERAL:
-		//fprintf(stderr, "getRegFromInstruction - literal\n");
 		break;
 		
 	default:
-		//fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
-		//genericPrint(stderr, pc);
 		break;
 	}
 	
@@ -4312,8 +4449,9 @@ static void BanksUsedFlow(pBlock *pb)
 */
 
 /*-----------------------------------------------------------------*/
+/* Inserts a new pCodeInstruction before an existing one           */
 /*-----------------------------------------------------------------*/
-static void pCodeInstructionInsertAfter(pCodeInstruction *pci, pCodeInstruction *new_pci)
+static void insertPCodeInstruction(pCodeInstruction *pci, pCodeInstruction *new_pci)
 {
 	
 	pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
@@ -4345,7 +4483,7 @@ static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBi
 	
 	new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
 	
-	pCodeInstructionInsertAfter(pci, PCI(new_pc));
+	insertPCodeInstruction(pci, PCI(new_pc));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4360,7 +4498,7 @@ static void insertBankSel(pCodeInstruction  *pci, const char *name)
 		pcop->name = strdup(name);
 	new_pc = newpCode(POC_BANKSEL, pcop);
 	
-	pCodeInstructionInsertAfter(pci, PCI(new_pc));
+	insertPCodeInstruction(pci, PCI(new_pc));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4394,9 +4532,11 @@ static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
 		}
 	}
 	
+#if 1
 	if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank
 		return cur_bank;
 	LastRegIdx = reg->rIdx;
+#endif
 	
 	if (reg->isFixed) {
 		bank = REG_BANK(reg);
@@ -4486,7 +4626,8 @@ static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) {
 		
 	} else if (PCI(pc)->op == POC_BANKSEL) {
 		int old_bank = *cur_bank;
-		*cur_bank = (PCOR(PCI(pc)->pcop)->r->isExtern) ? 'E' : 'L';
+		regs *r = PCOR(PCI(pc)->pcop)->r;
+		*cur_bank = (!r || r->isExtern) ? 'E' : 'L';
 		LastRegIdx = reg->rIdx;
 		return old_bank != *cur_bank;
 	}
@@ -4506,6 +4647,7 @@ static int DoBankSelect(pCode *pc, int cur_bank) {
 	
 	if (isCALL(pc)) {
 		pCode *pcf = findFunction(get_op_from_instruction(PCI(pc)));
+		LastRegIdx = -1; /* do not know which register is touched in the called function... */
 		if (pcf && isPCF(pcf)) {
 			pCode *pcfr;
 			int rbank = 'U'; // Undetermined
@@ -4515,9 +4657,9 @@ static int DoBankSelect(pCode *pc, int cur_bank) {
 				if (isPCI(pcfr)) {
 					if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
 						if (rbank == 'U')
-							rbank = PCFL(pcfr)->lastBank;
+							rbank = PCI(pcfr)->pcflow->lastBank;
 						else
-							if (rbank != PCFL(pcfr)->lastBank)
+							if (rbank != PCI(pcfr)->pcflow->lastBank)
 								return -1; // Unknown bank - multiple returns with different banks
 					}
 				}
@@ -4529,6 +4671,8 @@ static int DoBankSelect(pCode *pc, int cur_bank) {
 			/* Extern functions may use registers in different bank - must call banksel */
 			return -1; /* Unknown bank */
 		}
+		/* play safe... */
+		return -1;
 	}
 	
 	if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) {
@@ -4537,13 +4681,11 @@ static int DoBankSelect(pCode *pc, int cur_bank) {
 	
 	reg = getRegFromInstruction(pc);
 	if (reg) {
-		
 		if (IsBankChange(pc,reg,&cur_bank))
 			return cur_bank;
-		
 		if (!isPCI_LIT(pc)) {
 			
-		/* Examine the instruction before this one to make sure it is
+			/* Examine the instruction before this one to make sure it is
 			* not a skip type instruction */
 			pcprev = findPrevpCode(pc->prev, PC_OPCODE);
 			
@@ -4893,19 +5035,18 @@ int OptimizepBlock(pBlock *pb)
 /*-----------------------------------------------------------------*/
 pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
 {
-	pCode *pc;
-	
-	for(pc = pcs; pc; pc = pc->next) {
-		
-		if((pc->type == PC_OPCODE) && 
-			(PCI(pc)->pcop) && 
-			(PCI(pc)->pcop->type == PO_LABEL) &&
-			(PCOLAB(PCI(pc)->pcop)->key == pcl->key))
-			return pc;
-	}
-	
-	
-	return NULL;
+  pCode *pc;
+
+  for(pc = pcs; pc; pc = pc->next) {
+
+    if(((pc->type == PC_OPCODE) || (pc->type == PC_INLINE) || (pc->type == PC_ASMDIR)) &&
+      (PCI(pc)->pcop) && 
+      (PCI(pc)->pcop->type == PO_LABEL) &&
+      (PCOLAB(PCI(pc)->pcop)->key == pcl->key))
+      return pc;
+  }
+
+  return NULL;
 }
 
 /*-----------------------------------------------------------------*/
@@ -5408,12 +5549,6 @@ void AnalyzeBanking(void)
 	pBlock  *pb;
 	
 	if(!picIsInitialized()) {
-//		fprintf(stderr,"Temporary ERROR: at the moment you have to use\n");
-//		fprintf(stderr,"an include file create by inc2h.pl. See SDCC source:\n");
-//		fprintf(stderr,"support/scripts/inc2h.pl\n");
-//		fprintf(stderr,"this is a nuisance bug that will be fixed shortly\n");
-		
-//		exit(1);
 		setDefMaxRam(); // Max RAM has not been included, so use default setting
 	}
 	
@@ -5664,7 +5799,7 @@ void AnalyzepCode(char dbName)
 				pBlockMergeLabels(pb);
 				AnalyzepBlock(pb);
 			} else {
-				DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName));
+				DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName(pb)));
 			}
 		}