pCode *findFunction(char *fname);
-static void FixRegisterBanking(pBlock *pb,int cur_bank);
+static void FixRegisterBanking(pBlock *pb);
#if defined(__BORLANDC__) || defined(_MSC_VER)
#define STRCASECMP stricmp
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 */
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 = {
1,0, // dest, bit instruction
1,1, // branch, skip
0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ POC_DECF, // followed by BTFSC STATUS, Z --> also kills STATUS
+ PCC_REGISTER, // inCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciDECFSZW = {
0,0, // dest, bit instruction
1,1, // branch, skip
0, // literal operand
- POC_NOP,
+ POC_DECFW, // followed by BTFSC STATUS, Z --> also kills STATUS
PCC_REGISTER, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciGOTO = {
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 = {
1,0, // dest, bit instruction
1,1, // branch, skip
0, // literal operand
- POC_NOP,
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ POC_INCF, // followed by BTFSC STATUS, Z --> also kills STATUS
+ PCC_REGISTER, // inCond
+ PCC_REGISTER | PCC_Z // outCond
};
pCodeInstruction pciINCFSZW = {
0,0, // dest, bit instruction
1,1, // branch, skip
0, // literal operand
- POC_NOP,
+ POC_INCFW, // followed by BTFSC STATUS, Z --> also kills STATUS
PCC_REGISTER, // inCond
- PCC_W // outCond
+ PCC_W | PCC_Z // outCond
};
pCodeInstruction pciIORWF = {
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;
}
sym = symFindWithName(bit, name);
if (!sym) sym = symFindWithName(sfrbit, name);
if (!sym) sym = symFindWithName(sfr, name);
+ if (!sym) sym = symFindWithName(reg, name);
+ // Hack to fix accesses to _INTCON_bits (e.g. GIE=0), see #1579535.
+ // XXX: This ignores nesting levels, but works for globals...
+ if (!sym) sym = findSym(SymbolTab, NULL, name);
+ if (!sym && name && name[0] == '_') sym = findSym(SymbolTab, NULL, &name[1]);
if (sym) {
r = allocNewDirReg(sym->etype,name);
}
return pcop;
}
+#if 0
+pCodeOp *newpCodeOpBitReg(regs *reg, int ibit, int inBitSpace)
+{
+ pCodeOp *pcop;
+
+ assert(reg);
+
+ pcop = Safe_calloc(1,sizeof(pCodeOpRegBit));
+ pcop->name = reg->name;
+ pcop->type = PO_GPR_BIT;
+ PCORB(pcop)->bit = ibit;
+ PCORB(pcop)->inBitSpace = inBitSpace;
+ PCOR(pcop)->r = reg;
+ PCOR(pcop)->index = 0;
+ PCOR(pcop)->rIdx = reg->rIdx;
+ return pcop;
+}
+#endif
+
/*-----------------------------------------------------------------*
* pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register
*
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);
+}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void addpCodeComment(pCode *pc, const char *fmt, ...)
+{
+ va_list ap;
+ char buffer[4096];
+ pCode *newpc;
+
+ va_start(ap, fmt);
+ if (options.verbose || debug_verbose) {
+ buffer[0] = ';';
+ buffer[1] = ' ';
+ vsprintf(&buffer[2], fmt, ap);
+
+ newpc = newpCodeCharP(&buffer[0]); // strdup's the string
+ pCodeInsertAfter(pc, newpc);
+ }
+ va_end(ap);
+}
+
+void pBlockMergeLabels(pBlock *pb);
/*-----------------------------------------------------------------*/
/* 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;
-
-}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit)
-{
- pCode *new_pc;
-
- new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
-
- insertPCodeInstruction(pci, PCI(new_pc));
+ /* 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);
+
+ // Yuck: Cannot simply replace INCFSZ/INCFSZW/DECFSZ/DECFSZW
+ // We replace them with INCF/INCFW/DECF/DECFW followed by 'BTFSS STATUS, Z'
+ switch (PCI(pcprev)->op) {
+ case POC_INCFSZ:
+ case POC_INCFSZW:
+ case POC_DECFSZ:
+ case POC_DECFSZW:
+ // These are turned into non-skipping instructions, so
+ // insert 'BTFSC STATUS, Z' after pcprev
+ pCodeInsertAfter (jump->prev, newpCode(POC_BTFSC, popCopyGPR2Bit(PCOP(&pc_status), PIC_Z_BIT)));
+ break;
+ default:
+ // no special actions required
+ break;
+ }
+ pCodeReplace (pcprev, pCodeInstructionCopy (PCI(pcprev), 1));
+ pcprev = NULL;
+ pCodeInsertAfter((pCode*)pci, label);
+ pBlockMergeLabels(pci->pc.pb);
+ }
}
/*-----------------------------------------------------------------*/
{
pCode *new_pc;
- pCodeOp *pcop = popCopyReg(PCOR(pci->pcop));
+ pCodeOp *pcop;
+
+ // This is a NOP for single-banked devices.
+ if (pic14_getMaxRam() < 0x80) return;
+ // Never BANKSEL STATUS, this breaks all kinds of code (e.g., interrupt handlers).
+ if (!strcmp("STATUS", name) || !strcmp("_STATUS", name)) 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);
}
/*-----------------------------------------------------------------*/
-/* If the register is a fixed known addess then we can assign the */
-/* bank selection bits. Otherwise the linker is going to assign */
-/* the register location and thus has to set bank selection bits */
-/* through the banksel directive. */
-/* One critical assumption here is that within this C module all */
-/* the locally allocated registers are in the same udata sector. */
-/* 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 BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
-{
- int bank;
- int a = reg->alias>>7;
- if ((a&3) == 3) {
- return cur_bank; // This register is available in all banks
- } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) {
- return cur_bank; // This register is available in banks 0 & 1
- } else if (a&2) {
- if (reg->address&0x80) {
- if ((cur_bank==1)||(cur_bank==3)) {
- return cur_bank; // This register is available in banks 1 & 3
- }
- } else {
- if ((cur_bank==0)||(cur_bank==1)) {
- return cur_bank; // This register is available in banks 0 & 2
- }
- }
- }
-
-#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);
- } else if (reg->isExtern) {
- bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown
- } 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
- 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)
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- } else { // Current bank and new register banks known - can set bank bits
- switch((cur_bank^bank) & 3) {
- case 0:
- break;
- case 1:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- break;
- case 2:
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- case 3:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- if (getMaxRam()&0x100)
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- }
- }
-
- return bank;
-}
-
-/*-----------------------------------------------------------------*/
-/* Check for bank selection pcodes instructions and modify */
-/* cur_bank to match. */
-/*-----------------------------------------------------------------*/
-static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) {
-
- if (isSTATUS_REG(reg)) {
-
- if (PCI(pc)->op == POC_BCF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x2;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x1;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- if (PCI(pc)->op == POC_BSF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x1;
- else
- *cur_bank = (*cur_bank&0x2) | 0x1;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x2;
- else
- *cur_bank = (*cur_bank&0x1) | 0x2;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- } else if (PCI(pc)->op == POC_BANKSEL) {
- int old_bank = *cur_bank;
- regs *r = PCOR(PCI(pc)->pcop)->r;
- *cur_bank = (!r || r->isExtern) ? 'E' : 'L';
- LastRegIdx = reg->rIdx;
- return old_bank != *cur_bank;
- }
-
- return 0;
-}
-
-/*-----------------------------------------------------------------*/
-/* Set bank selection if necessary */
/*-----------------------------------------------------------------*/
-static int DoBankSelect(pCode *pc, int cur_bank) {
- pCode *pcprev;
- regs *reg;
-
- if(!isPCI(pc))
- return 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
- FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done
- // Check all the returns to work out what bank is selected
- for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) {
- if (isPCI(pcfr)) {
- if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
- if (rbank == 'U')
- rbank = PCI(pcfr)->pcflow->lastBank;
- else
- if (rbank != PCI(pcfr)->pcflow->lastBank)
- return -1; // Unknown bank - multiple returns with different banks
- }
- }
- }
- if (rbank == 'U')
- return -1; // Unknown bank
- return rbank;
- } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) {
- /* 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)) {
- return -1; /* New bank unknown - linkers choice. */
- }
-
- 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
- * not a skip type instruction */
- pcprev = findPrevpCode(pc->prev, PC_OPCODE);
-
- if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
- cur_bank = BankSelect(PCI(pc),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
- PCI(pc)->pcflow->lastBank = cur_bank; /* Maintain pCodeFlow lastBank state */
- }
- }
- return cur_bank;
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-/*
-static void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank)
+static int sameBank(regs *reg, const char *new_bank, const char *cur_bank)
{
- pCode *pc=NULL;
- pCode *pcprev=NULL;
-
- if(!pcfl)
- return;
-
- pc = findNextInstruction(pcfl->pc.next);
-
- while(isPCinFlow(pc,PCODE(pcfl))) {
-
- cur_bank = DoBankSelect(pc,cur_bank);
- pcprev = pc;
- pc = findNextInstruction(pc->next);
-
- }
-
- if(pcprev && cur_bank) {
- // Set bank state to unknown at the end of each flow block
- cur_bank = -1;
- }
-
+ if (!cur_bank) return 0;
+
+ // identify '(regname + X)' and 'regname'
+ if (reg && reg->name && reg->name[0] == '(' && !strncmp(®->name[1], cur_bank, strlen(cur_bank))) return 1;
+ if (new_bank && new_bank[0] == '(' && !strncmp(&new_bank[1], cur_bank, strlen(cur_bank))) return 1;
+ if (cur_bank[0] == '(' && reg && reg->name && !strncmp(reg->name, &cur_bank[1], strlen(reg->name))) return 1;
+ if (cur_bank[0] == '(' && new_bank && !strncmp(new_bank, &cur_bank[1], strlen(new_bank))) return 1;
+
+ // XXX: identify '(regname + X)' and '(regname + Y)'
+
+ return ((reg && reg->name && !strcmp(reg->name, cur_bank)) || (new_bank && !strcmp(new_bank, cur_bank)));
}
-*/
+
/*-----------------------------------------------------------------*/
-/*int compareBankFlow - compare the banking requirements between */
-/* flow objects. */
/*-----------------------------------------------------------------*/
-/*
-int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
+void FixRegisterBanking(pBlock *pb)
{
-
- if(!pcflow || !pcflowLink || !pcflowLink->pcflow)
- return 0;
-
- if(!isPCFL(pcflow) || !isPCFL(pcflowLink->pcflow))
- return 0;
-
- if(pcflow->firstBank == -1)
- return 0;
-
-
- if(pcflowLink->pcflow->firstBank == -1) {
- pCodeFlowLink *pctl = setFirstItem( toORfrom ?
- pcflowLink->pcflow->to :
- pcflowLink->pcflow->from);
- return compareBankFlow(pcflow, pctl, toORfrom);
+ pCode *pc;
+ pCodeInstruction *pci;
+ regs *reg;
+ const char *cur_bank, *new_bank;
+ unsigned cur_mask, new_mask, max_mask;
+
+ if (!pb) return;
+
+ max_mask = pic14_getPIC()->bankMask;
+ cur_mask = max_mask;
+ cur_bank = NULL;
+
+ for (pc = pb->pcHead; pc; pc = pc->next)
+ {
+ // this one has a label---might check bank at all jumps here...
+ if (isPCI(pc) && (PCI(pc)->label || PCI(pc)->op == POC_CALL)) {
+ addpCodeComment(pc->prev, "BANKOPT3 drop assumptions: PCI with label or call found");
+ cur_bank = NULL; // start new flow
+ cur_mask = max_mask;
}
- if(toORfrom) {
- if(pcflow->lastBank == pcflowLink->pcflow->firstBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->FromConflicts++;
- pcflow->ToConflicts++;
- } else {
-
- if(pcflow->firstBank == pcflowLink->pcflow->lastBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->ToConflicts++;
- pcflow->FromConflicts++;
-
+ // this one is/might be a label or BANKSEL---assume nothing
+ if (isPCL(pc) || isPCASMDIR(pc)) {
+ addpCodeComment(pc->prev, "BANKOPT4 drop assumptions: label or ASMDIR found");
+ cur_bank = NULL;
+ cur_mask = max_mask;
}
- / *
- fprintf(stderr,"compare flow found conflict: seq %d from conflicts %d, to conflicts %d\n",
- pcflowLink->pcflow->pc.seq,
- pcflowLink->pcflow->FromConflicts,
- pcflowLink->pcflow->ToConflicts);
- * /
- return 1;
-
-}
-*/
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-/*
-void FixBankFlow(pBlock *pb)
-{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
- pCode *pcflow_max_To=NULL;
- pCode *pcflow_max_From=NULL;
- int max_ToConflicts=0;
- int max_FromConflicts=0;
-
- /fprintf(stderr,"Fix Bank flow \n");
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
-
-
- / *
- First loop through all of the flow objects in this pcode block
- and fix the ones that have banking conflicts between the
- entry and exit.
- * /
-
- //fprintf(stderr, "FixBankFlow - Phase 1\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
-
- if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank &&
- PCFL(pcflow)->firstBank >= 0 &&
- PCFL(pcflow)->lastBank >= 0 ) {
-
- int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
- PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
-
- FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
- BanksUsedFlow2(pcflow);
-
+
+ // this one modifies STATUS
+ // XXX: this should be checked, but usually BANKSELs are not done this way in generated code
+
+ if (isPCI(pc)) {
+ pci = PCI(pc);
+ if ((pci->inCond | pci->outCond) & PCC_REGISTER) {
+ // might need a BANKSEL
+ reg = getRegFromInstruction(pc);
+
+ if (reg) {
+ new_bank = reg->name;
+ // reg->alias == 0: reg is in only one bank, we do not know which (may be any bank)
+ // reg->alias != 0: reg is in 2/4/8/2**N banks, we select one of them
+ new_mask = reg->alias;
+ } else if (pci->pcop && pci->pcop->name) {
+ new_bank = pci->pcop->name;
+ new_mask = 0; // unknown, assume worst case
+ } else {
+ assert(!"Could not get register from instruction.");
}
- }
-
- //fprintf(stderr, "FixBankFlow - Phase 2\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- int nFlows;
- int nConflicts;
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
+
+ // optimizations...
+ // XXX: add switch to disable these
+ if (1) {
+ // reg present in all banks possibly selected?
+ if (new_mask == max_mask || (cur_mask && ((new_mask & cur_mask) == cur_mask))) {
+ // no BANKSEL required
+ addpCodeComment(pc->prev, "BANKOPT1 BANKSEL dropped; %s present in all of %s's banks", new_bank, cur_bank);
continue;
- }
-
- PCFL(pcflow)->FromConflicts = 0;
- PCFL(pcflow)->ToConflicts = 0;
-
- nFlows = 0;
- nConflicts = 0;
-
- //fprintf(stderr, " FixBankFlow flow seq %d\n",pcflow->seq);
- pcfl = setFirstItem(PCFL(pcflow)->from);
- while (pcfl) {
-
- pc = PCODE(pcfl->pcflow);
-
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 0);
- nFlows++;
-
- pcfl=setNextItem(PCFL(pcflow)->from);
- }
-
- if((nFlows >= 2) && nConflicts && (PCFL(pcflow)->firstBank>0)) {
- //fprintf(stderr, " From conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
-
- FixRegisterBankingInFlow(PCFL(pcflow),-1);
- BanksUsedFlow2(pcflow);
-
- continue; / * Don't need to check the flow from here - it's already been fixed * /
-
- }
-
- nFlows = 0;
- nConflicts = 0;
-
- pcfl = setFirstItem(PCFL(pcflow)->to);
- while (pcfl) {
-
- pc = PCODE(pcfl->pcflow);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
- nFlows++;
-
- pcfl=setNextItem(PCFL(pcflow)->to);
- }
-
- if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
- //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
-
- FixRegisterBankingInFlow(PCFL(pcflow),-1);
- BanksUsedFlow2(pcflow);
- }
- }
-
- / *
- Loop through the flow objects again and find the ones with the
- maximum conflicts
- * /
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
- pcflow_max_To = pcflow;
-
- if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
- pcflow_max_From = pcflow;
- }
- / *
- if(pcflow_max_To)
- fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_To)->pc.seq,
- PCFL(pcflow_max_To)->ToConflicts);
-
- if(pcflow_max_From)
- fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_From)->pc.seq,
- PCFL(pcflow_max_From)->FromConflicts);
- * /
-}
-*/
+ }
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void DumpFlow(pBlock *pb)
-{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
-
- fprintf(stderr,"Dump flow \n");
- pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
+ cur_mask &= new_mask;
+
+ if (sameBank(reg, new_bank, cur_bank)) {
+ // no BANKSEL required
+ addpCodeComment(pc->prev, "BANKOPT2 BANKSEL dropped; %s present in same bank as %s", new_bank, cur_bank);
continue;
- }
- fprintf(stderr,"dumping: ");
- pcflow->print(stderr,pcflow);
- FlowStats(PCFL(pcflow));
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " from seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - from is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " to seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- }
-
+ }
+ } // if
+
+ cur_mask = new_mask;
+ cur_bank = new_bank;
+ insertBankSel(pci, cur_bank);
+ } // if
+ } // if
+ } // for
}
/*-----------------------------------------------------------------*/
pCode *pc, *pcprev;
int matches =0;
- if(!pb || !peepOptimizing)
+ if(!pb || options.nopeep)
return 0;
DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
return pcop;
}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-static void FixRegisterBanking(pBlock *pb,int cur_bank)
-{
- pCode *pc;
- int firstBank = 'U';
-
- if(!pb)
- return;
-
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- firstBank = PCFL(pc)->firstBank;
- break;
- }
- }
- if (firstBank != 'U') {
- /* This block has already been done */
- if (firstBank != cur_bank) {
- /* This block has started with a different bank - must adjust it */
- if ((firstBank != -1)&&(firstBank != 'E')) { /* The first bank start off unknown or extern then need not worry as banksel will be called */
- while (pc) {
- if (isPCI(pc)) {
- regs *reg = getRegFromInstruction(pc);
- if (reg) {
- DoBankSelect(pc,cur_bank);
- }
- }
- pc = pc->next;
- }
- }
- }
- return;
- }
-
- /* loop through all of the pCodes within this pblock setting the bank selection, ignoring any branching */
- LastRegIdx = -1;
- cur_bank = -1;
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- PCFL(pc)->firstBank = cur_bank;
- continue;
- }
- cur_bank = DoBankSelect(pc,cur_bank);
- }
-
- /* Trace through branches and set the bank selection as required. */
- LastRegIdx = -1;
- cur_bank = -1;
- for (pc=pb->pcHead; pc; pc=pc->next) {
- if (isPCFL(pc)) {
- PCFL(pc)->firstBank = cur_bank;
- continue;
- }
- if (isPCI(pc)) {
- if (PCI(pc)->op == POC_GOTO) {
- int lastRegIdx = LastRegIdx;
- pCode *pcb = pc;
- /* Trace through branch */
- pCode *pcl = findLabel(PCOLAB(PCI(pcb)->pcop));
- while (pcl) {
- if (isPCI(pcl)) {
- regs *reg = getRegFromInstruction(pcl);
- if (reg) {
- int bankUnknown = -1;
- if (IsBankChange(pcl,reg,&bankUnknown)) /* Look for any bank change */
- break;
- if (cur_bank != DoBankSelect(pcl,cur_bank)) /* Set bank selection if necessary */
- break;
- }
- }
- pcl = pcl->next;
- }
- LastRegIdx = lastRegIdx;
- } else {
- /* Keep track out current bank */
- regs *reg = getRegFromInstruction(pc);
- if (reg)
- IsBankChange(pc,reg,&cur_bank);
- }
- }
- }
-}
-
-
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void pBlockDestruct(pBlock *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
// for(pb = the_pFile->pbHead; pb; pb = pb->next)
// BanksUsedFlow(pb);
for(pb = the_pFile->pbHead; pb; pb = pb->next)
- FixRegisterBanking(pb,-1); // cur_bank is unknown
+ FixRegisterBanking(pb);
+
+ AnalyzeFlow(0);
+ AnalyzeFlow(1);
}
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 */