X-Git-Url: https://git.gag.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Fpic%2Fpcode.c;h=d28f0b3d3ced0df4d032eaae46883a23ac7f529f;hb=25837611386183e136d41617166c3a81b52ce430;hp=6d90e89a634bce0617110c206d8b274ef43291c6;hpb=4310a3fc67a7a7b92b7c7c0640ae8df680da16f7;p=fw%2Fsdcc

diff --git a/src/pic/pcode.c b/src/pic/pcode.c
index 6d90e89a..d28f0b3d 100644
--- a/src/pic/pcode.c
+++ b/src/pic/pcode.c
@@ -1255,7 +1255,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,10 +1343,12 @@ 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);
@@ -1362,9 +1364,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;
@@ -2021,6 +2023,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(*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(*lbp))lbp++;
+
+  if(lbp && *lbp)
+    pcad->arg = Safe_strdup( lbp );
+
+  return ((pCode *)pcad);
+}
+
 /*-----------------------------------------------------------------*/
 /* pCodeLabelDestruct - free memory used by a label.               */
 /*-----------------------------------------------------------------*/
@@ -2394,6 +2439,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 +2451,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));
@@ -2811,7 +2866,8 @@ pCodeOp *popCopyReg(pCodeOpReg *pc)
 	} else {
 		pcor->r = pc->r;
 		pcor->rIdx = pc->rIdx;
-		pcor->r->wasUsed=1;
+		if (pcor->r)
+			pcor->r->wasUsed=1;
 	}	
 	//DEBUGpic14_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
 	
@@ -2910,7 +2966,6 @@ 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) {
@@ -2930,21 +2985,21 @@ char *get_op(pCodeOp *pcop,char *buffer, size_t size)
 				} else
 					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);
+						SAFE_snprintf(&s,&size,"((%s + %d) >> %d)&0xff",pcop->name, PCOI(pcop)->index, 8*PCOI(pcop)->offset);
+						break;
 					}
 				}
 			}
@@ -3023,85 +3078,89 @@ 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);
+    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;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3109,106 +3168,122 @@ 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);
+    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);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3262,47 +3337,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;
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3462,24 +3535,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;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3534,7 +3607,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;
 }
 
@@ -3584,27 +3657,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;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3613,7 +3682,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;
 }
 
 /*-----------------------------------------------------------------*/
@@ -3622,7 +3709,6 @@ pCode * findPrevInstruction(pCode *pci)
 /*-----------------------------------------------------------------*/
 pCode * findFunctionEnd(pCode *pc)
 {
-	
 	while(pc) {
 		if(pc->type == PC_FUNCTION &&  !(PCF(pc)->fname))
 			return pc;
@@ -3676,7 +3762,7 @@ static void AnalyzeRETURN(pCode *pc)
 /*-----------------------------------------------------------------*/
 regs * getRegFromInstruction(pCode *pc)
 {
-	
+	regs *r;
 	if(!pc                   || 
 		!isPCI(pc)            ||
 		!PCI(pc)->pcop        ||
@@ -3687,36 +3773,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;
 	}
 	
@@ -4315,8 +4398,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);
@@ -4348,7 +4432,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));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4363,7 +4447,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));
 }
 
 /*-----------------------------------------------------------------*/
@@ -4489,7 +4573,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;
 	}
@@ -4540,10 +4625,8 @@ 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
@@ -4896,19 +4979,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;
 }
 
 /*-----------------------------------------------------------------*/