static hTab *pic14pCodePeepCommandsHash = NULL;
-static pFile *the_pFile = NULL;
+pFile *the_pFile = NULL;
static pBlock *pb_dead_pcodes = NULL;
/* Hardcoded flags to change the behavior of the PIC port */
-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 */
pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval);
void pCodeRegMapLiveRanges(pBlock *pb);
+pBranch * pBranchAppend(pBranch *h, pBranch *n);
+
/****************************************************************/
/* PIC Instructions */
0, // literal operand
POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
};
pCodeInstruction pciADDFW = {
0, // literal operand
POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
};
pCodeInstruction pciADDLW = {
0,0, // branch, skip
0, // literal operand
POC_BSF,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_REGISTER // outCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
pCodeInstruction pciBSF = {
0,0, // branch, skip
0, // literal operand
POC_BCF,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
pCodeInstruction pciBTFSC = {
1,1, // branch, skip
0, // literal operand
POC_BTFSS,
- (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_EXAMINE_PCOP // outCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_NONE // outCond
};
pCodeInstruction pciBTFSS = {
0, // literal operand
POC_BTFSC,
(PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
- PCC_EXAMINE_PCOP // outCond
+ PCC_NONE // outCond
};
pCodeInstruction pciCALL = {
1,0, // branch, skip
0, // literal operand
POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ (PCC_NONE | PCC_W), // inCond, reads argument from WREG
+ (PCC_NONE | PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond, flags are destroyed by called function
};
pCodeInstruction pciCOMF = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciCOMFW = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciCLRF = {
0, // literal operand
POC_NOP,
PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciCLRW = {
0, // literal operand
POC_NOP,
PCC_NONE, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciCLRWDT = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciDECFW = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciDECFSZ = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciINCFW = {
0, // literal operand
POC_NOP,
PCC_REGISTER, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciINCFSZ = {
0, // literal operand
POC_NOP,
PCC_NONE, // inCond
- PCC_NONE // outCond (not true... affects the GIE bit too)
+ (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond (not true... affects the GIE bit too), STATUS bit are retored
};
pCodeInstruction pciRETLW = {
1, // literal operand
POC_NOP,
PCC_LITERAL, // inCond
- PCC_W // outCond
+ (PCC_W| PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETLW
};
pCodeInstruction pciRETURN = {
1,0, // branch, skip
0, // literal operand
POC_NOP,
- PCC_NONE, // inCond
- PCC_NONE // outCond
+ PCC_NONE | PCC_W, // inCond, return value is possibly present in W
+ (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETURN
};
pCodeInstruction pciRLF = {
0, // literal operand
POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
+ (PCC_REGISTER | PCC_C ) // outCond
};
pCodeInstruction pciRLFW = {
0, // literal operand
POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ (PCC_W | PCC_C) // outCond
};
pCodeInstruction pciRRF = {
0, // literal operand
POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
+ (PCC_REGISTER | PCC_C) // outCond
};
pCodeInstruction pciRRFW = {
0, // literal operand
POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ (PCC_W | PCC_C) // outCond
};
pCodeInstruction pciSUBWF = {
0, // literal operand
POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
- (PCC_REGISTER | PCC_Z) // outCond
+ (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
};
pCodeInstruction pciSUBFW = {
0, // literal operand
POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
- (PCC_W | PCC_Z) // outCond
+ (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
};
pCodeInstruction pciSUBLW = {
0,0, // branch, skip
0, // literal operand
POC_NOP,
- PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ PCC_NONE, // inCond /* FIXME: what's TRIS doing? */
+ PCC_REGISTER // outCond /* FIXME: what's TRIS doing */
};
pCodeInstruction pciXORWF = {
1, // literal operand
POC_NOP,
(PCC_W | PCC_LITERAL), // inCond
- (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
+ (PCC_W | PCC_Z) // outCond
};
0, // literal operand
POC_NOP,
PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ PCC_NONE // outCond
};
pCodeInstruction pciPAGESEL = {
0, // literal operand
POC_NOP,
PCC_NONE, // inCond
- PCC_REGISTER // outCond
+ PCC_NONE // outCond
};
pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS];
extern void initStack(int base_address, int size);
extern regs *allocProcessorRegister(int rIdx, char * name, short po_type, int alias);
-extern regs *allocInternalRegister(int rIdx, char * name, short po_type, int alias);
+extern regs *allocInternalRegister(int rIdx, char * name, PIC_OPTYPE po_type, int alias);
extern void init_pic(char *);
void pCodeInitRegisters(void)
initialized = 1;
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 */
+ /* FIXME - some PIC ICs like 16C7X which do not have a shared bank
+ * need a different approach.
+ * The fixed address might not be needed anyway, possibly the
+ * linker will assign udata_shr sections correctly... */
+ shareBankAddress = pic14_getSharebankAddress();
+ /* Set pseudo stack size to SHAREBANKSIZE - 3.
+ * On multi memory bank ICs this leaves room for WSAVE/SSAVE/PSAVE
+ * (used for interrupts) to fit into the shared portion of the
+ * memory bank */
+ stkSize = pic14_getSharebankSize()-3;
+ /* Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters */
+ initStack(shareBankAddress, stkSize);
pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180);
pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
/* */
/*-----------------------------------------------------------------*/
-int mnem2key(char const *mnem)
+int mnem2key(unsigned char const *mnem)
{
int key = 0;
for(i=0; i<MAX_PIC14MNEMONICS; i++)
if(pic14Mnemonics[i])
- hTabAddItem(&pic14MnemonicsHash, mnem2key(pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
+ hTabAddItem(&pic14MnemonicsHash, mnem2key((unsigned char *)pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]);
pci = hTabFirstItem(pic14MnemonicsHash, &key);
while(pci) {
{
pCodeInstruction *pci;
- int key = mnem2key(mnem);
+ int key = mnem2key((unsigned char *)mnem);
if(!mnemonics_initialized)
pic14initMnemonics();
i = 0;
do {
hTabAddItem(&pic14pCodePeepCommandsHash,
- mnem2key(peepCommands[i].cmd), &peepCommands[i]);
+ mnem2key((unsigned char *)peepCommands[i].cmd), &peepCommands[i]);
i++;
} while (peepCommands[i].cmd);
{
peepCommand *pcmd;
- int key = mnem2key(cmd);
+ int key = mnem2key((unsigned char *)cmd);
pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key);
char *name = pcop->name;
if (!name)
name = PCOR(pcop)->r->name;
- // if (strcmp(name, pc_status.pcop.name) != 0) { <<< This breaks the peep 2 optimisation
- switch(PCORB(pcop)->bit) {
- case PIC_C_BIT:
- return PCC_C;
- case PIC_DC_BIT:
- return PCC_DC;
- case PIC_Z_BIT:
- return PCC_Z;
+ if (strcmp(name, pc_status.pcop.name) == 0)
+ {
+ switch(PCORB(pcop)->bit) {
+ case PIC_C_BIT:
+ return PCC_C;
+ case PIC_DC_BIT:
+ return PCC_DC;
+ case PIC_Z_BIT:
+ return PCC_Z;
+ }
}
- // }
}
return 0;
if(asdir && *asdir) {
- while(isspace(*asdir))asdir++; // strip any white space from the beginning
+ while(isspace((unsigned char)*asdir))asdir++; // strip any white space from the beginning
pcad->directive = Safe_strdup( asdir );
}
va_end(ap);
- while(isspace(*lbp))lbp++;
+ while(isspace((unsigned char)*lbp))lbp++;
if(lbp && *lbp)
pcad->arg = Safe_strdup( lbp );
pcop->name = NULL;
if(lit>=0) {
- sprintf(s,"0x%02x",lit);
+ sprintf(s,"0x%02x", (unsigned char)lit);
if(s)
pcop->name = Safe_strdup(s);
}
- ((pCodeOpLit *)pcop)->lit = lit;
+ ((pCodeOpLit *)pcop)->lit = (unsigned char)lit;
return pcop;
}
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;
}
}
return NULL;
switch(pcop->type) {
+ case PO_NONE:
+ case PO_STR:
+ pcopnew = Safe_calloc (1, sizeof (pCodeOp));
+ memcpy (pcopnew, pcop, sizeof (pCodeOp));
+ break;
+
+ case PO_W:
+ case PO_STATUS:
+ case PO_FSR:
+ case PO_INDF:
+ case PO_INTCON:
+ case PO_GPR_REGISTER:
+ case PO_GPR_TEMP:
+ case PO_GPR_POINTER:
+ case PO_SFR_REGISTER:
+ case PO_PCL:
+ case PO_PCLATH:
+ case PO_DIR:
+ //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
+ memcpy (pcopnew, pcop, sizeof (pCodeOpReg));
+ DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
+ break;
+
+ case PO_LITERAL:
+ //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
+ memcpy (pcopnew, pcop, sizeof (pCodeOpLit));
+ break;
+
+ case PO_IMMEDIATE:
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
+ memcpy (pcopnew, pcop, sizeof (pCodeOpImmd));
+ break;
+
+ case PO_GPR_BIT:
case PO_CRY:
case PO_BIT:
//DFPRINTF((stderr,"pCodeOpCopy bit\n"));
pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) );
- PCORB(pcopnew)->bit = PCORB(pcop)->bit;
- PCORB(pcopnew)->inBitSpace = PCORB(pcop)->inBitSpace;
-
+ memcpy (pcopnew, pcop, sizeof (pCodeOpRegBit));
+ break;
+
+ case PO_LABEL:
+ //DFPRINTF((stderr,"pCodeOpCopy label\n"));
+ pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
+ memcpy (pcopnew, pcop, sizeof(pCodeOpLabel));
break;
case PO_WILD:
return pcopnew;
break;
-
- case PO_LABEL:
- //DFPRINTF((stderr,"pCodeOpCopy label\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
- PCOLAB(pcopnew)->key = PCOLAB(pcop)->key;
- break;
-
- case PO_IMMEDIATE:
- pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) );
- PCOI(pcopnew)->index = PCOI(pcop)->index;
- PCOI(pcopnew)->offset = PCOI(pcop)->offset;
- PCOI(pcopnew)->_const = PCOI(pcop)->_const;
- PCOI(pcopnew)->_function = PCOI(pcop)->_function;
- break;
-
- case PO_LITERAL:
- //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
- PCOL(pcopnew)->lit = PCOL(pcop)->lit;
- break;
-
- case PO_GPR_BIT:
-
- pcopnew = newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace);
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- DFPRINTF((stderr," pCodeOpCopy Bit -register index\n"));
- return pcopnew;
- break;
-
- case PO_GPR_POINTER:
- case PO_GPR_REGISTER:
- case PO_GPR_TEMP:
- case PO_FSR:
- case PO_INDF:
- //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
- pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- PCOR(pcopnew)->instance = PCOR(pcop)->instance;
- DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
- break;
-
- case PO_DIR:
- //fprintf(stderr,"pCodeOpCopy PO_DIR\n");
- pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcopnew)->r = PCOR(pcop)->r;
- PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- PCOR(pcopnew)->instance = PCOR(pcop)->instance;
+
+ default:
+ assert ( !"unhandled pCodeOp type copied" );
break;
- case PO_STATUS:
- DFPRINTF((stderr,"pCodeOpCopy PO_STATUS\n"));
- case PO_SFR_REGISTER:
- case PO_STR:
- case PO_NONE:
- case PO_W:
- case PO_INTCON:
- case PO_PCL:
- case PO_PCLATH:
-
- //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type));
- pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
-
- }
+ } // switch
- pcopnew->type = pcop->type;
if(pcop->name)
pcopnew->name = Safe_strdup(pcop->name);
else
} else
SAFE_snprintf(&s,&size,"LOW (%s+%d)",pcop->name,PCOI(pcop)->index);
} else {
- if( !PCOI(pcop)->offset) { // && 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);
SAFE_snprintf(&s,&size,"%s",pcop->name);
}
return buffer;
-
+
case PO_GPR_BIT:
if(PCOR(pcop)->r) {
if(use_buffer) {
}
}
- printf("PIC port internal warning: (%s:%d) %s not found\n",
- __FUNCTION__,
- __LINE__,
+ printf("PIC port internal warning: (%s:%d(%s)) %s not found\n",
+ __FILE__, __LINE__, __FUNCTION__,
pCodeOpType(pcop));
return "NO operand";
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,";#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) {
/* Debug */
if(debug_verbose) {
pCodeOpReg *pcor = PCOR(pci->pcop);
- fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq);
+ fprintf(of, "\t;id=%u,key=%03x,inCond:%x,outCond:%x",pc->id,pc->seq, pci->inCond, pci->outCond);
if(pci->pcflow)
fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq);
if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed)
if(PCFL(pc)->ancestor)
fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq);
fprintf(of,"\n");
+ fprintf(of,"; from: ");
+ {
+ pCodeFlowLink *link;
+ for (link = setFirstItem(PCFL(pc)->from); link; link = setNextItem (PCFL(pc)->from))
+ {
+ fprintf(of,"%03x ",link->pcflow->pc.seq);
+ }
+ }
+ fprintf(of,"; to: ");
+ {
+ pCodeFlowLink *link;
+ for (link = setFirstItem(PCFL(pc)->to); link; link = setNextItem (PCFL(pc)->to))
+ {
+ fprintf(of,"%03x ",link->pcflow->pc.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,";#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:
return NULL;
switch(PCI(pc)->pcop->type) {
- case PO_INDF:
+ case PO_STATUS:
case PO_FSR:
- return PCOR(PCI(pc)->pcop)->r;
-
+ case PO_INDF:
+ case PO_INTCON:
case PO_BIT:
case PO_GPR_TEMP:
+ case PO_SFR_REGISTER:
+ case PO_PCL:
+ case PO_PCLATH:
return PCOR(PCI(pc)->pcop)->r;
-
- case PO_IMMEDIATE:
- r = PCOI(PCI(pc)->pcop)->r;
- if (r)
- return r;
- return dirregWithName(PCI(pc)->pcop->name);
-
+
+ case PO_GPR_REGISTER:
case PO_GPR_BIT:
+ case PO_DIR:
r = PCOR(PCI(pc)->pcop)->r;
if (r)
return r;
return dirregWithName(PCI(pc)->pcop->name);
- case PO_GPR_REGISTER:
- case PO_DIR:
- r = PCOR(PCI(pc)->pcop)->r;
+ case PO_LITERAL:
+ break;
+
+ case PO_IMMEDIATE:
+ r = PCOI(PCI(pc)->pcop)->r;
if (r)
return r;
return dirregWithName(PCI(pc)->pcop->name);
- case PO_LITERAL:
- break;
default:
break;
PCI(pc)->pcflow = PCFL(pflow);
//fprintf(stderr," build: ");
+ //pc->print(stderr, pc);
//pflow->print(stderr,pflow);
- if( PCI(pc)->isSkip) {
+ if (checkLabel(pc)) {
+
+ /* This instruction marks the beginning of a
+ * new flow segment */
+
+ pc->seq = 0;
+ seq = 1;
+
+ /* If the previous pCode is not a flow object, then
+ * insert a new flow object. (This check prevents
+ * two consecutive flow objects from being insert in
+ * the case where a skip instruction preceeds an
+ * instruction containing a label.) */
+
+ last_pci = findPrevInstruction (pc->prev);
+
+ if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
+ InsertpFlow(last_pci, &pflow);
+
+ PCI(pc)->pcflow = PCFL(pflow);
+
+ }
+
+ if(isPCI_SKIP(pc)) {
/* The two instructions immediately following this one
* mark the beginning of a new flow segment */
- while(pc && PCI(pc)->isSkip) {
+ while(pc && isPCI_SKIP(pc)) {
PCI(pc)->pcflow = PCFL(pflow);
pc->seq = seq-1;
pc->seq = 0;
InsertpFlow(pc, &pflow);
- } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next))) {
+ } else if ( isPCI_BRANCH(pc) && !checkLabel(findNextInstruction(pc->next))) {
InsertpFlow(pc, &pflow);
seq = 0;
- } else if (checkLabel(pc)) {
-
- /* This instruction marks the beginning of a
- * new flow segment */
-
- pc->seq = 0;
- seq = 1;
-
- /* If the previous pCode is not a flow object, then
- * insert a new flow object. (This check prevents
- * two consecutive flow objects from being insert in
- * the case where a skip instruction preceeds an
- * instruction containing a label.) */
-
- if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow)))
- InsertpFlow(findPrevInstruction(pc->prev), &pflow);
-
- PCI(pc)->pcflow = PCFL(pflow);
-
}
+
last_pci = pc;
pc = pc->next;
}
void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
{
pCodeFlowLink *fromLink, *toLink;
-
+#if 0
+ fprintf(stderr, "%s: linking ", __FUNCTION__ );
+ if (from) from->pc.print(stderr, &from->pc);
+ else fprintf(stderr, "(null)");
+ fprintf(stderr, " -(%u)-> with -(%u)-> ",
+ from && from->pcflow ? from->pcflow->pc.seq : 0,
+ to && to->pcflow ? to->pcflow->pc.seq : 0);
+ if (to) to->pc.print(stderr, &to->pc);
+ else fprintf(stderr, "(null)");
+#endif
+
if(!from || !to || !to->pcflow || !from->pcflow)
return;
//FillFlow(PCFL(pcflow));
- pc = PCFL(pcflow)->end;
+ /* find last instruction in flow */
+ pc = findPrevInstruction (PCFL(pcflow)->end);
+ if (!pc) {
+ fprintf(stderr, "%s: flow without end (%u)?\n",
+ __FUNCTION__, pcflow->seq );
+ continue;
+ }
//fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
+ //pc->print(stderr, pc);
if(isPCI_SKIP(pc)) {
//fprintf(stderr, "ends with skip\n");
//pc->print(stderr,pc);
//fprintf(stderr, "ends with branch\n ");
//pc->print(stderr,pc);
-
+
if(!(pcol && isPCOLAB(pcol))) {
- if((PCI(pc)->op != POC_RETLW) && (PCI(pc)->op != POC_RETURN) && (PCI(pc)->op != POC_CALL) && (PCI(pc)->op != POC_RETFIE) ) {
+ if((PCI(pc)->op != POC_RETLW)
+ && (PCI(pc)->op != POC_RETURN)
+ && (PCI(pc)->op != POC_CALL)
+ && (PCI(pc)->op != POC_RETFIE) )
+ {
pc->print(stderr,pc);
fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__);
}
- continue;
- }
-
- if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
- LinkFlow_pCode(PCI(pc),PCI(pct));
- else
- fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
- __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
- //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
+ } else {
- continue;
+ if( (pct = findLabelinpBlock(pb,pcol)) != NULL)
+ LinkFlow_pCode(PCI(pc),PCI(pct));
+ else
+ fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n",
+ __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-"));
+ //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
+ }
+ /* link CALLs to next instruction */
+ if (PCI(pc)->op != POC_CALL) continue;
}
if(isPCI(pc)) {
continue;
}
- //fprintf(stderr, "ends with nothing: ERROR\n");
+ fprintf(stderr, "ends with nothing: ERROR\n");
}
}
}
*/
+void pCodeReplace (pCode *old, pCode *new)
+{
+ pCodeInsertAfter (old, new);
+
+ /* special handling for pCodeInstructions */
+ if (isPCI(new) && isPCI(old))
+ {
+ assert (!PCI(new)->from && !PCI(new)->to && !PCI(new)->label && /*!PCI(new)->pcflow && */!PCI(new)->cline);
+ PCI(new)->from = PCI(old)->from;
+ PCI(new)->to = PCI(old)->to;
+ PCI(new)->label = PCI(old)->label;
+ PCI(new)->pcflow = PCI(old)->pcflow;
+ PCI(new)->cline = PCI(old)->cline;
+ } // if
+
+ old->destruct (old);
+}
+
/*-----------------------------------------------------------------*/
/* Inserts a new pCodeInstruction before an existing one */
/*-----------------------------------------------------------------*/
static void insertPCodeInstruction(pCodeInstruction *pci, pCodeInstruction *new_pci)
{
+ pCode *pcprev;
+
+ pcprev = findPrevInstruction(pci->pc.prev);
pCodeInsertAfter(pci->pc.prev, &new_pci->pc);
/* The new instruction has the same pcflow block */
new_pci->pcflow = pci->pcflow;
-
+
+ /* Arrrrg: is pci's previous instruction is a skip, we need to
+ * change that into a jump (over pci and the new instruction) ... */
+ if (pcprev && isPCI_SKIP(pcprev))
+ {
+ symbol *lbl = newiTempLabel (NULL);
+ pCode *label = newpCodeLabel (NULL, lbl->key);
+ pCode *jump = newpCode(POC_GOTO, newpCodeOpLabel(NULL, lbl->key));
+
+ pCodeInsertAfter (pcprev, jump);
+
+ pCodeReplace (pcprev, pCodeInstructionCopy (PCI(pcprev), 1));
+ pcprev = NULL;
+ pCodeInsertAfter((pCode*)pci, label);
+ }
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
+#if 0
static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit)
{
pCode *new_pc;
insertPCodeInstruction(pci, PCI(new_pc));
}
-
+#endif
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
static void insertBankSel(pCodeInstruction *pci, const char *name)
{
pCode *new_pc;
- pCodeOp *pcop = popCopyReg(PCOR(pci->pcop));
+ pCodeOp *pcop;
+
+ // This is a NOP for single-banked devices.
+ if (pic14_getMaxRam() < 0x80) return;
+
+ pcop = popCopyReg(PCOR(pci->pcop));
pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
if (pcop->name == 0)
pcop->name = strdup(name);
/* Therefore banksel is only called for external registers or the */
/* first time a local register is encountered. */
/*-----------------------------------------------------------------*/
-static int LastRegIdx; /* If the previous register is the same one again then no need to change bank. */
+static int LastRegIdx = -1; /* If the previous register is the same one again then no need to change bank. */
static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
{
+#if 1
+ /* Always insert BANKSELs rather than try to be clever:
+ * Too many bugs in optimized banksels... */
+ insertBankSel(pci, reg->name); // Let linker choose the bank selection
+ return 'L';
+#else
int bank;
int a = reg->alias>>7;
if ((a&3) == 3) {
}
}
+#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
+ /* Optimized code---unfortunately this turns out to be buggy
+ * (at least on devices with more than two banks). */
if (reg->isFixed) {
bank = REG_BANK(reg);
} else if (reg->isExtern) {
} else {
bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown
}
- if ((cur_bank == 'L')&&(bank == 'L')) { // If current bank and new bank are both allocated locally by the linker, then assume it is in same bank.
- return 'L'; // Local registers are presumed to be in same linker assigned bank
- } else if ((bank == 'L')&&(cur_bank != 'L')) { // Reg is now local and linker to assign bank
- insertBankSel(pci, reg->name); // Let linker choose the bank selection
- } else if (bank == 'E') { // Reg is now extern and linker to assign bank
+ if (bank == 'E' || bank == 'L') { // Reg is now extern and linker to assign bank
insertBankSel(pci, reg->name); // Let linker choose the bank selection
} else if ((cur_bank == -1)||(cur_bank == 'L')||(cur_bank == 'E')) { // Current bank unknown and new register bank is known then can set bank bits
insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- if (getMaxRam()&0x100)
+ if (pic14_getMaxRam()&0x100)
insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
} else { // Current bank and new register banks known - can set bank bits
switch((cur_bank^bank) & 3) {
break;
case 3:
insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- if (getMaxRam()&0x100)
+ if (pic14_getMaxRam()&0x100)
insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
break;
}
}
return bank;
+#endif
}
/*-----------------------------------------------------------------*/
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
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
}
}
/* 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)) {
}
reg = getRegFromInstruction(pc);
+ if (!reg && isPCI(pc) &&
+ ((PCI(pc)->inCond | PCI(pc)->outCond) & PCC_REGISTER))
+ {
+ assert(!"Could not get register from instruction.");
+ }
if (reg) {
if (IsBankChange(pc,reg,&cur_bank))
return cur_bank;
* not a skip type instruction */
pcprev = findPrevpCode(pc->prev, PC_OPCODE);
- if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
+ /* This approach does not honor the presence of labels at this instruction... */
+ //if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
cur_bank = BankSelect(PCI(pc),cur_bank,reg);
- } else {
- cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
- }
+ //} else {
+ // cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
+ //}
if (!PCI(pc)->pcflow)
fprintf(stderr,"PCI ID=%d missing flow pointer ???\n",pc->id);
else
pCode *pc, *pcprev;
int matches =0;
- if(!pb || !peepOptimizing)
+ if(!pb || options.nopeep)
return 0;
DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
OptimizepCode('*');
-
- /*
+ /*
for(pb = the_pFile->pbHead; pb; pb = pb->next)
DumpFlow(pb);
*/
void AnalyzeBanking(void)
{
pBlock *pb;
-
+
if(!picIsInitialized()) {
- setDefMaxRam(); // Max RAM has not been included, so use default setting
+ werror(E_FILE_OPEN_ERR, "no memory size is known for this processor");
+ exit(1);
}
+ if (!the_pFile) return;
+
/* Phase x - Flow Analysis - Used Banks
*
* In this phase, the individual flow blocks are examined
void InitReuseReg(void)
{
/* Find end of statically allocated variables for start idx */
- unsigned maxIdx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */
+ /* Start from begining of GPR. Note may not be 0x20 on some PICs */
+ /* XXX: Avoid clashes with fixed registers, start late. */
+ unsigned maxIdx = 0x1000;
regs *r;
for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
if (r->type != REG_SFR) {
void ReuseReg(void)
{
pBlock *pb;
+ if (!the_pFile) return;
InitReuseReg();
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
/* Non static functions can be called from other modules so their registers must reassign */
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)));
}
}