#define STRCASECMP strcasecmp
#endif
+/****************************************************************/
+/****************************************************************/
+
+peepCommand peepCommands[] = {
+
+ {NOTBITSKIP, "_NOTBITSKIP_"},
+ {BITSKIP, "_BITSKIP_"},
+ {INVERTBITSKIP, "_INVERTBITSKIP_"},
+
+ {-1, NULL}
+};
+
+
// Eventually this will go into device dependent files:
pCodeOpReg pc_status = {{PO_STATUS, "STATUS"}, -1, NULL,0,NULL};
pCodeOpReg pc_pclath = {{PO_PCLATH, "PCLATH"}, -1, NULL,0,NULL};
pCodeOpReg pc_kzero = {{PO_GPR_REGISTER, "KZ"}, -1, NULL,0,NULL};
-pCodeOpReg pc_wsave = {{PO_GPR_REGISTER, "W_SAVE"}, -1, NULL,0,NULL};
-pCodeOpReg pc_ssave = {{PO_GPR_REGISTER, "STATUS_SAVE"}, -1, NULL,0,NULL};
+pCodeOpReg pc_wsave = {{PO_GPR_REGISTER, "WSAVE"}, -1, NULL,0,NULL};
+pCodeOpReg pc_ssave = {{PO_GPR_REGISTER, "SSAVE"}, -1, NULL,0,NULL};
+pCodeOpReg pc_psave = {{PO_GPR_REGISTER, "PSAVE"}, -1, NULL,0,NULL};
static int mnemonics_initialized = 0;
static hTab *pic14MnemonicsHash = NULL;
+static hTab *pic14pCodePeepCommandsHash = NULL;
static pFile *the_pFile = NULL;
-static int peepOptimizing = 0;
-static int GpCodeSequenceNumber = 1;
-static int GpcFlowSeq = 1;
-
-#define isPCI(x) ((PCODE(x)->type == PC_OPCODE))
-#define isPCI_BRANCH(x) ((PCODE(x)->type == PC_OPCODE) && PCI(x)->isBranch)
-#define isPCI_SKIP(x) ((PCODE(x)->type == PC_OPCODE) && PCI(x)->isSkip)
-#define isPCFL(x) ((PCODE(x)->type == PC_FLOW))
-#define isPCF(x) ((PCODE(x)->type == PC_FUNCTION))
-#define isCALL(x) ((isPCI(x)) && (PCI(x)->op == POC_CALL))
-#define isSTATUS_REG(r) ((r)->pc_type == PO_STATUS)
+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 */
+
+// static int GpCodeSequenceNumber = 1;
+int GpcFlowSeq = 1;
+
+extern void RemoveUnusedRegisters(void);
+extern void RegsUnMapLiveRanges(void);
+extern void BuildFlowTree(pBlock *pb);
+extern void pCodeRegOptimizeRegUsage(int level);
+extern int picIsInitialized(void);
/****************************************************************/
/* Forward declarations */
/****************************************************************/
-static void unlinkPC(pCode *pc);
+void unlinkpCode(pCode *pc);
#if 0
static void genericAnalyze(pCode *pc);
static void AnalyzeGOTO(pCode *pc);
static void pCodePrintLabel(FILE *of, pCode *pc);
static void pCodePrintFunction(FILE *of, pCode *pc);
static void pCodeOpPrint(FILE *of, pCodeOp *pcop);
-static char *get_op( pCodeInstruction *pcc);
+static char *get_op_from_instruction( pCodeInstruction *pcc);
+char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd);
int pCodePeepMatchRule(pCode *pc);
void pBlockStats(FILE *of, pBlock *pb);
+pBlock *newpBlock(void);
extern void pCodeInsertAfter(pCode *pc1, pCode *pc2);
+extern pCodeOp *popCopyReg(pCodeOpReg *pc);
+pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval);
+void pCodeRegMapLiveRanges(pBlock *pb);
+
+
+/****************************************************************/
+/* PIC Instructions */
+/****************************************************************/
pCodeInstruction pciADDWF = {
{PC_OPCODE, NULL, NULL, 0, NULL,
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z) // outCond
};
// genericAnalyze,
genericDestruct,
genericPrint},
- POC_ADDWF,
+ POC_ADDFW,
"ADDWF",
NULL, // from branch
NULL, // to branch
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z) // outCond
};
// genericAnalyze,
genericDestruct,
genericPrint},
- POC_ANDWF,
+ POC_ANDFW,
"ANDWF",
NULL, // from branch
NULL, // to branch
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,1, // dest, bit instruction
0,0, // branch, skip
- PCC_REGISTER, // inCond
+ 0, // literal operand
+ POC_BSF,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,1, // dest, bit instruction
0,0, // branch, skip
- PCC_REGISTER, // inCond
- PCC_REGISTER // outCond
+ 0, // literal operand
+ POC_BCF,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
pCodeInstruction pciBTFSC = {
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,1, // dest, bit instruction
1,1, // branch, skip
- PCC_REGISTER, // inCond
- PCC_NONE // outCond
+ 0, // literal operand
+ POC_BTFSS,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_EXAMINE_PCOP // outCond
};
pCodeInstruction pciBTFSS = {
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,1, // dest, bit instruction
1,1, // branch, skip
- PCC_REGISTER, // inCond
- PCC_NONE // outCond
+ 0, // literal operand
+ POC_BTFSC,
+ (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond
+ PCC_EXAMINE_PCOP // outCond
};
pCodeInstruction pciCALL = {
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_NONE // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_REGISTER, // inCond
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
0, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
PCC_W // outCond
};
+pCodeInstruction pciCLRWDT = {
+ {PC_OPCODE, NULL, NULL, 0, NULL,
+ // genericAnalyze,
+ genericDestruct,
+ genericPrint},
+ POC_CLRWDT,
+ "CLRWDT",
+ NULL, // from branch
+ NULL, // to branch
+ NULL, // label
+ NULL, // operand
+ NULL, // flow block
+ NULL, // C source
+ 0, // num ops
+ 0,0, // dest, bit instruction
+ 0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
+ PCC_NONE, // inCond
+ PCC_NONE // outCond
+};
+
pCodeInstruction pciDECF = {
{PC_OPCODE, NULL, NULL, 0, NULL,
// genericAnalyze,
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_NONE // outCond
};
-
pCodeInstruction pciINCF = {
{PC_OPCODE, NULL, NULL, 0, NULL,
// genericAnalyze,
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
1,1, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z) // outCond
};
// genericAnalyze,
genericDestruct,
genericPrint},
- POC_IORWF,
+ POC_IORFW,
"IORWF",
NULL, // from branch
NULL, // to branch
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
PCC_Z // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_REGISTER, // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_W, // inCond
PCC_REGISTER // outCond
};
pCodeInstruction pciMOVLW = {
{PC_OPCODE, NULL, NULL, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_MOVLW,
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_NONE, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_NONE | PCC_LITERAL), // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
0, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_NONE // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
0, // num ops
0,0, // dest, bit instruction
1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_NONE // outCond (not true... affects the GIE bit too)
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
1,0, // branch, skip
- PCC_NONE, // inCond
+ 1, // literal operand
+ POC_NOP,
+ PCC_LITERAL, // inCond
PCC_W // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
0, // num ops
0,0, // dest, bit instruction
1,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_NONE // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_C | PCC_REGISTER), // inCond
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z) // outCond
};
// genericAnalyze,
genericDestruct,
genericPrint},
- POC_SUBWF,
+ POC_SUBFW,
"SUBWF",
NULL, // from branch
NULL, // to branch
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_REGISTER), // inCond
(PCC_REGISTER) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_REGISTER), // inCond
(PCC_W) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
PCC_NONE, // inCond
PCC_REGISTER // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
1,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_REGISTER | PCC_Z) // outCond
};
// genericAnalyze,
genericDestruct,
genericPrint},
- POC_XORWF,
+ POC_XORFW,
"XORWF",
NULL, // from branch
NULL, // to branch
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
2, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
+ 0, // literal operand
+ POC_NOP,
(PCC_W | PCC_REGISTER), // inCond
(PCC_W | PCC_Z) // outCond
};
NULL, // label
NULL, // operand
NULL, // flow block
+ NULL, // C source
1, // num ops
0,0, // dest, bit instruction
0,0, // branch, skip
- PCC_W, // inCond
+ 1, // literal operand
+ POC_NOP,
+ (PCC_W | PCC_LITERAL), // inCond
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
#define MAX_PIC14MNEMONICS 100
pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS];
-/* This definition needs to be part of configure.in */
-// #define USE_VSNPRINTF
-#ifdef USE_VSNPRINTF
+#ifdef HAVE_VSNPRINTF
// Alas, vsnprintf is not ANSI standard, and does not exist
// on Solaris (and probably other non-Gnu flavored Unixes).
va_end (val);
len = strlen(*str);
- if(len > *size) {
+ if((size_t)len > *size) {
fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
+ fprintf(stderr,"len = %d is > str size %d\n",len,(int)*size);
}
*str += len;
}
-#else // USE_VSNPRINTF
+#else // HAVE_VSNPRINTF
// This version is *not* safe, despite the name.
len = strlen(buffer);
if(len > *size) {
fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
+ fprintf(stderr,"len = %d is > str size %d\n",len,*size);
}
strcpy(*str, buffer);
}
-#endif // USE_VSNPRINTF
+#endif // HAVE_VSNPRINTF
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 void init_pic(void);
+extern void init_pic(char *);
void pCodeInitRegisters(void)
{
+ static int initialized=0;
+ int shareBankAddress;
- initStack(0x38, 8);
- init_pic();
+ if(initialized)
+ return;
+ initialized = 1;
+
+ initStack(0xfff, 8);
+ init_pic(port->processor);
pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x80);
pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80);
pc_pcl.rIdx = IDX_PCL;
pc_pclath.rIdx = IDX_PCLATH;
- pc_kzero.r = allocInternalRegister(IDX_KZ,"KZ",PO_GPR_REGISTER,0);
- pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0x80);
- pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0);
+ pc_kzero.r = allocInternalRegister(IDX_KZ,"KZ",PO_GPR_REGISTER,0); /* Known Zero - actually just a general purpose reg. */
+ pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0x80); /* Interupt 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); /* Interupt storage for status register. */
+ pc_psave.r = allocInternalRegister(IDX_PSAVE,"PSAVE", PO_GPR_REGISTER, 0); /* Interupt storage for pclath register. */
+
+ pc_kzero.rIdx = pc_kzero.r->rIdx;
+ pc_wsave.rIdx = pc_wsave.r->rIdx;
+ pc_ssave.rIdx = pc_ssave.r->rIdx;
+ pc_psave.rIdx = pc_psave.r->rIdx;
+
+ shareBankAddress = 0x7f; /* FIXME - this is different for some PICs ICs if the sharebank does not exist then this address needs to be reserved across all banks. */
+ pc_wsave.r->isFixed = 1;
+ pc_wsave.r->address = shareBankAddress;
- pc_kzero.rIdx = IDX_KZ;
- pc_wsave.rIdx = IDX_WSAVE;
- pc_ssave.rIdx = IDX_SSAVE;
+ /* probably should put this in a separate initialization routine */
+ pb_dead_pcodes = newpBlock();
}
if(mnemonics_initialized)
return;
+//FIXME - probably should NULL out the array before making the assignments
+//since we check the array contents below this initialization.
+
pic14Mnemonics[POC_ADDLW] = &pciADDLW;
pic14Mnemonics[POC_ADDWF] = &pciADDWF;
pic14Mnemonics[POC_ADDFW] = &pciADDFW;
pic14Mnemonics[POC_COMFW] = &pciCOMFW;
pic14Mnemonics[POC_CLRF] = &pciCLRF;
pic14Mnemonics[POC_CLRW] = &pciCLRW;
+ pic14Mnemonics[POC_CLRWDT] = &pciCLRWDT;
pic14Mnemonics[POC_DECF] = &pciDECF;
pic14Mnemonics[POC_DECFW] = &pciDECFW;
pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ;
mnemonics_initialized = 1;
}
+int getpCodePeepCommand(char *cmd);
+
int getpCode(char *mnem,unsigned dest)
{
while(pci) {
if(STRCASECMP(pci->mnemonic, mnem) == 0) {
- if((pci->num_ops <= 1) || (pci->isModReg == dest))
+ if((pci->num_ops <= 1) || (pci->isModReg == dest) || (pci->isBitInst))
return(pci->op);
}
return -1;
}
+/*-----------------------------------------------------------------*
+ * pic14initpCodePeepCommands
+ *
+ *-----------------------------------------------------------------*/
+void pic14initpCodePeepCommands(void)
+{
+
+ int key, i;
+ peepCommand *pcmd;
+
+ i = 0;
+ do {
+ hTabAddItem(&pic14pCodePeepCommandsHash,
+ mnem2key(peepCommands[i].cmd), &peepCommands[i]);
+ i++;
+ } while (peepCommands[i].cmd);
+
+ pcmd = hTabFirstItem(pic14pCodePeepCommandsHash, &key);
+
+ while(pcmd) {
+ //fprintf(stderr, "peep command %s key %d\n",pcmd->cmd,pcmd->id);
+ pcmd = hTabNextItem(pic14pCodePeepCommandsHash, &key);
+ }
+
+}
+
+/*-----------------------------------------------------------------
+ *
+ *
+ *-----------------------------------------------------------------*/
+
+int getpCodePeepCommand(char *cmd)
+{
+
+ peepCommand *pcmd;
+ int key = mnem2key(cmd);
+
+
+ pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key);
+
+ while(pcmd) {
+ // fprintf(stderr," comparing %s to %s\n",pcmd->cmd,cmd);
+ if(STRCASECMP(pcmd->cmd, cmd) == 0) {
+ return pcmd->id;
+ }
+
+ pcmd = hTabNextItemWK (pic14pCodePeepCommandsHash);
+
+ }
+
+ return -1;
+}
+
char getpBlock_dbName(pBlock *pb)
{
if(!pb)
if(getpBlock_dbName(pb) == dbName) {
pBlockStats(of,pb);
printpBlock(of,pb);
+ fprintf (of, "\n");
}
}
char buffer[100];
/* create the file name */
- strcpy(buffer,srcFileName);
+ strcpy(buffer,dstFileName);
strcat(buffer,".p");
if( !(pFile = fopen(buffer, "w" ))) {
if(!pcop)
return 0;
- if(pcop->type == PO_GPR_BIT && !strcmp(pcop->name, pc_status.pcop.name)) {
- 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 (pcop->type == PO_GPR_BIT) {
+ 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;
+ }
+// }
}
return 0;
memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction));
pci->pcop = pcop;
- if(pci->inCond == PCC_EXAMINE_PCOP)
- pci->inCond = RegCond(pcop);
+ if(pci->inCond & PCC_EXAMINE_PCOP)
+ pci->inCond |= RegCond(pcop);
- if(pci->outCond == PCC_EXAMINE_PCOP)
- pci->outCond = RegCond(pcop);
+ if(pci->outCond & PCC_EXAMINE_PCOP)
+ pci->outCond |= RegCond(pcop);
pci->pc.prev = pci->pc.next = NULL;
return (pCode *)pci;
pcw->operand = optional_operand;
pcw->label = optional_label;
+ pcw->mustBeBitSkipInst = 0;
+ pcw->mustNotBeBitSkipInst = 0;
+ pcw->invertBitSkipInst = 0;
+
return ( (pCode *)pcw);
+}
+
+ /*-----------------------------------------------------------------*/
+/* newPcodeInlineP - create a new pCode from a char string */
+/*-----------------------------------------------------------------*/
+
+
+pCode *newpCodeInlineP(char *cP)
+{
+
+ pCodeComment *pcc ;
+
+ pcc = Safe_calloc(1,sizeof(pCodeComment));
+
+ pcc->pc.type = PC_INLINE;
+ pcc->pc.prev = pcc->pc.next = NULL;
+ //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
+ pcc->pc.pb = NULL;
+
+ // pcc->pc.analyze = genericAnalyze;
+ pcc->pc.destruct = genericDestruct;
+ pcc->pc.print = genericPrint;
+
+ if(cP)
+ pcc->comment = Safe_strdup(cP);
+ else
+ pcc->comment = NULL;
+
+ return ( (pCode *)pcc);
+
}
/*-----------------------------------------------------------------*/
pcf->pc.destruct = genericDestruct;
pcf->pc.print = pCodePrintFunction;
+ pcf->ncalled = 0;
+
if(mod) {
//_ALLOC_ATOMIC(pcf->modname,strlen(mod)+1);
pcf->modname = Safe_calloc(1,strlen(mod)+1);
/*-----------------------------------------------------------------*/
/* newpCodeFlow */
/*-----------------------------------------------------------------*/
+void destructpCodeFlow(pCode *pc)
+{
+ if(!pc || !isPCFL(pc))
+ return;
+
+/*
+ if(PCFL(pc)->from)
+ if(PCFL(pc)->to)
+*/
+ unlinkpCode(pc);
+
+ deleteSet(&PCFL(pc)->registers);
+ deleteSet(&PCFL(pc)->from);
+ deleteSet(&PCFL(pc)->to);
+ free(pc);
+}
pCode *newpCodeFlow(void )
{
pcflow->pc.type = PC_FLOW;
pcflow->pc.prev = pcflow->pc.next = NULL;
- //pcflow->pc.from = pcflow->pc.to = pcflow->pc.label = NULL;
pcflow->pc.pb = NULL;
// pcflow->pc.analyze = genericAnalyze;
- pcflow->pc.destruct = genericDestruct;
+ pcflow->pc.destruct = destructpCodeFlow;
pcflow->pc.print = genericPrint;
pcflow->pc.seq = GpcFlowSeq++;
- pcflow->nuses = 7;
- pcflow->uses = Safe_calloc(pcflow->nuses, sizeof(set *));
-
pcflow->from = pcflow->to = NULL;
pcflow->inCond = PCC_NONE;
pcflow->outCond = PCC_NONE;
+ pcflow->firstBank = -1;
+ pcflow->lastBank = -1;
+
+ pcflow->FromConflicts = 0;
+ pcflow->ToConflicts = 0;
+
pcflow->end = NULL;
+
+ pcflow->registers = newSet();
+
return ( (pCode *)pcflow);
}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
+{
+ pCodeFlowLink *pcflowLink;
+
+ pcflowLink = Safe_calloc(1,sizeof(pCodeFlowLink));
+
+ pcflowLink->pcflow = pcflow;
+ pcflowLink->bank_conflict = 0;
+
+ return pcflowLink;
+}
+
+/*-----------------------------------------------------------------*/
+/* newpCodeCSource - create a new pCode Source Symbol */
+/*-----------------------------------------------------------------*/
+
+pCode *newpCodeCSource(int ln, char *f, char *l)
+{
+
+ pCodeCSource *pccs;
+
+ pccs = Safe_calloc(1,sizeof(pCodeCSource));
+
+ pccs->pc.type = PC_CSOURCE;
+ pccs->pc.prev = pccs->pc.next = NULL;
+ pccs->pc.pb = NULL;
+
+ pccs->pc.destruct = genericDestruct;
+ pccs->pc.print = genericPrint;
+
+ pccs->line_number = ln;
+ if(l)
+ pccs->line = Safe_strdup(l);
+ else
+ pccs->line = NULL;
+
+ if(f)
+ pccs->file_name = Safe_strdup(f);
+ else
+ pccs->file_name = NULL;
+
+ return ( (pCode *)pccs);
+
+}
/*-----------------------------------------------------------------*/
/* pCodeLabelDestruct - free memory used by a label. */
/*-----------------------------------------------------------------*/
if(s)
pcl->label = Safe_strdup(s);
-
+ //fprintf(stderr,"newpCodeLabel: key=%d, name=%s\n",key, ((s)?s:""));
return ( (pCode *)pcl);
}
PpB->function_entries = PpB->function_exits = PpB->function_calls = NULL;
PpB->tregisters = NULL;
PpB->visited = 0;
+ PpB->FlowTree = NULL;
return PpB;
else
s = name, key = label_key--;
+ PCOLAB(pcop)->offset = 0;
if(s)
pcop->name = Safe_strdup(s);
((pCodeOpLabel *)pcop)->key = key;
+ //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:""));
return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-pCodeOp *newpCodeOpImmd(char *name, int offset)
+pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space, int is_func)
{
pCodeOp *pcop;
-
pcop = Safe_calloc(1,sizeof(pCodeOpImmd) );
pcop->type = PO_IMMEDIATE;
if(name) {
+ regs *r = NULL;
pcop->name = Safe_strdup(name);
+
+ if(!is_func)
+ r = dirregWithName(name);
+
+ PCOI(pcop)->r = r;
+ if(r) {
+ //fprintf(stderr, " newpCodeOpImmd reg %s exists\n",name);
+ PCOI(pcop)->rIdx = r->rIdx;
+ } else {
+ //fprintf(stderr, " newpCodeOpImmd reg %s doesn't exist\n",name);
+ PCOI(pcop)->rIdx = -1;
+ }
+ //fprintf(stderr,"%s %s %d\n",__FUNCTION__,name,offset);
} else {
pcop->name = NULL;
}
-
+ PCOI(pcop)->index = index;
PCOI(pcop)->offset = offset;
+ PCOI(pcop)->_const = code_space;
+ PCOI(pcop)->_function = is_func;
return pcop;
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-pCodeOp *newpCodeOpWild(int id, pCodePeep *pcp, pCodeOp *subtype)
+pCodeOp *newpCodeOpWild(int id, pCodeWildBlock *pcwb, pCodeOp *subtype)
{
char *s = buffer;
pCodeOp *pcop;
- if(!pcp || !subtype) {
+ if(!pcwb || !subtype) {
fprintf(stderr, "Wild opcode declaration error: %s-%d\n",__FILE__,__LINE__);
exit(1);
}
pcop->name = Safe_strdup(s);
PCOW(pcop)->id = id;
- PCOW(pcop)->pcp = pcp;
+ PCOW(pcop)->pcwb = pcwb;
PCOW(pcop)->subtype = subtype;
PCOW(pcop)->matched = NULL;
pCodeOp *newpCodeOpBit(char *s, int bit, int inBitSpace)
{
pCodeOp *pcop;
+ struct regs *r = 0;
pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) );
pcop->type = PO_GPR_BIT;
- if(s)
- pcop->name = Safe_strdup(s);
- else
- pcop->name = NULL;
PCORB(pcop)->bit = bit;
PCORB(pcop)->inBitSpace = inBitSpace;
+ /* pCodeOpBit is derived from pCodeOpReg. We need to init this too */
+ if (s && !inBitSpace) {
+ r = dirregWithName(s);
+ if (!r) {
+ unsigned char idx = ((s[3] - (((s[3]>='0')&&(s[3]<='9'))?'0':'A'-10))<<4)|(s[4] - (((s[4]>='0')&&(s[4]<='9'))?'0':'A'-10));
+ r = pic14_regWithIdx(idx);
+ }
+ }
+ if (r) {
+ pcop->name = NULL;
+ PCOR(pcop)->r = r;
+ PCOR(pcop)->rIdx = r->rIdx;
+ } else {
+ pcop->name = Safe_strdup(s);
+ PCOR(pcop)->r = NULL;
+ PCOR(pcop)->rIdx = 0;
+ }
return pcop;
}
+/*-----------------------------------------------------------------*
+ * pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register
+ *
+ * If rIdx >=0 then a specific register from the set of registers
+ * will be selected. If rIdx <0, then a new register will be searched
+ * for.
+ *-----------------------------------------------------------------*/
+
pCodeOp *newpCodeOpReg(int rIdx)
{
pCodeOp *pcop;
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
pcop->name = NULL;
- PCOR(pcop)->rIdx = rIdx;
- PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+
+ if(rIdx >= 0) {
+ PCOR(pcop)->rIdx = rIdx;
+ PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+ } else {
+ PCOR(pcop)->r = pic14_findFreeReg(REG_GPR);
+
+ if(PCOR(pcop)->r)
+ PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+ }
+
pcop->type = PCOR(pcop)->r->pc_type;
return pcop;
}
+
pCodeOp *newpCodeOpRegFromStr(char *name)
{
pCodeOp *pcop;
pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
- PCOR(pcop)->r = allocRegByName(name);
+ PCOR(pcop)->r = allocRegByName(name, 1);
PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
pcop->type = PCOR(pcop)->r->pc_type;
pcop->name = PCOR(pcop)->r->name;
case PO_LABEL:
pcop = newpCodeOpLabel(NULL,-1);
break;
+ case PO_GPR_TEMP:
+ pcop = newpCodeOpReg(-1);
+ break;
+
+ case PO_GPR_POINTER:
+ case PO_GPR_REGISTER:
+ if(name)
+ pcop = newpCodeOpRegFromStr(name);
+ else
+ pcop = newpCodeOpReg(-1);
+ break;
default:
pcop = Safe_calloc(1,sizeof(pCodeOp) );
/*-----------------------------------------------------------------*/
void addpCode2pBlock(pBlock *pb, pCode *pc)
{
+
+ if(!pc)
+ return;
+
if(!pb->pcHead) {
/* If this is the first pcode to be added to a block that
* was initialized with a NULL pcode, then go ahead and
* make this pcode the head and tail */
pb->pcHead = pb->pcTail = pc;
} else {
+ // if(pb->pcTail)
pb->pcTail->next = pc;
+
pc->prev = pb->pcTail;
- //pc->next = NULL;
pc->pb = pb;
+
pb->pcTail = pc;
}
}
}
/*-----------------------------------------------------------------*/
-/* printpCode - write the contents of a pCode to a file */
+/* removepBlock - remove a pBlock from the pFile */
/*-----------------------------------------------------------------*/
-void printpCode(FILE *of, pCode *pc)
+void removepBlock(pBlock *pb)
{
+ pBlock *pbs;
- if(!pc || !of)
+ if(!the_pFile)
return;
- if(pc->print) {
- pc->print(of,pc);
- return;
- }
- fprintf(of,"warning - unable to print pCode\n");
-}
+ //fprintf(stderr," Removing pBlock: dbName =%c\n",getpBlock_dbName(pb));
-/*-----------------------------------------------------------------*/
-/* printpBlock - write the contents of a pBlock to a file */
+ for(pbs = the_pFile->pbHead; pbs; pbs = pbs->next) {
+ if(pbs == pb) {
+
+ if(pbs == the_pFile->pbHead)
+ the_pFile->pbHead = pbs->next;
+
+ if (pbs == the_pFile->pbTail)
+ the_pFile->pbTail = pbs->prev;
+
+ if(pbs->next)
+ pbs->next->prev = pbs->prev;
+
+ if(pbs->prev)
+ pbs->prev->next = pbs->next;
+
+ return;
+
+ }
+ }
+
+ fprintf(stderr, "Warning: call to %s:%s didn't find pBlock\n",__FILE__,__FUNCTION__);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* printpCode - write the contents of a pCode to a file */
+/*-----------------------------------------------------------------*/
+void printpCode(FILE *of, pCode *pc)
+{
+
+ if(!pc || !of)
+ return;
+
+ if(pc->print) {
+ pc->print(of,pc);
+ return;
+ }
+
+ fprintf(of,"warning - unable to print pCode\n");
+}
+
+/*-----------------------------------------------------------------*/
+/* printpBlock - write the contents of a pBlock to a file */
/*-----------------------------------------------------------------*/
void printpBlock(FILE *of, pBlock *pb)
{
/* */
/*-----------------------------------------------------------------*/
-static void unlinkPC(pCode *pc)
+void unlinkpCode(pCode *pc)
{
if(pc) {
+#ifdef PCODE_DEBUG
+ fprintf(stderr,"Unlinking: ");
+ printpCode(stderr, pc);
+#endif
if(pc->prev)
pc->prev->next = pc->next;
if(pc->next)
pc->prev = pc->next = NULL;
}
}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+
static void genericDestruct(pCode *pc)
{
- fprintf(stderr,"warning, calling default pCode destructor\n");
- unlinkPC(pc);
+ unlinkpCode(pc);
- free(pc);
+ if(isPCI(pc)) {
+ /* For instructions, tell the register (if there's one used)
+ * that it's no longer needed */
+ regs *reg = getRegFromInstruction(pc);
+ if(reg)
+ deleteSetItem (&(reg->reglives.usedpCodes),pc);
+ }
+
+ /* Instead of deleting the memory used by this pCode, mark
+ * the object as bad so that if there's a pointer to this pCode
+ * dangling around somewhere then (hopefully) when the type is
+ * checked we'll catch it.
+ */
+
+ pc->type = PC_BAD;
+
+ addpCode2pBlock(pb_dead_pcodes, pc);
+
+ //free(pc);
}
}
-static char *get_op( pCodeInstruction *pcc)
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+char *get_op(pCodeOp *pcop,char *buffer, size_t size)
{
regs *r;
- static char buffer[50];
+ static char b[50];
char *s;
- int size;
+ int use_buffer = 1; // copy the string to the passed buffer pointer
- if(pcc && pcc->pcop) {
+ if(!buffer) {
+ buffer = b;
+ size = sizeof(b);
+ use_buffer = 0; // Don't bother copying the string to the buffer.
+ }
-
- switch(pcc->pcop->type) {
+ if(pcop) {
+ switch(pcop->type) {
case PO_INDF:
case PO_FSR:
- //fprintf(stderr,"get_op getting register name rIdx=%d\n",PCOR(pcc->pcop)->rIdx);
- //r = pic14_regWithIdx(PCOR(pcc->pcop)->rIdx);
- //return r->name;
- return PCOR(pcc->pcop)->r->name;
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
+ return buffer;
+ }
+ //return PCOR(pcop)->r->name;
+ return pcop->name;
break;
case PO_GPR_TEMP:
- r = pic14_regWithIdx(PCOR(pcc->pcop)->r->rIdx);
- //fprintf(stderr,"getop: getting %s\nfrom:\n",r->name); //pcc->pcop->name);
- pBlockRegs(stderr,pcc->pc.pb);
+ r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
+
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",r->name);
+ return buffer;
+ }
+
return r->name;
- // case PO_GPR_BIT:
- // return PCOR(pcc->pcop)->r)->name;
+
case PO_IMMEDIATE:
s = buffer;
- size = sizeof(buffer);
- if( PCOI(pcc->pcop)->offset && PCOI(pcc->pcop)->offset<4) {
- SAFE_snprintf(&s,&size,"((%s >> %d)&0xff)",
- pcc->pcop->name,
- 8 * PCOI(pcc->pcop)->offset );
- } else
- SAFE_snprintf(&s,&size,"LOW(%s)",pcc->pcop->name);
+ if(PCOI(pcop)->_const) {
+
+ if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) {
+ switch(PCOI(pcop)->offset) {
+ case 0:
+ SAFE_snprintf(&s,&size,"low %s",pcop->name);
+ break;
+ case 1:
+ SAFE_snprintf(&s,&size,"high %s",pcop->name);
+ break;
+ default:
+ SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)",
+ pcop->name,
+ PCOI(pcop)->index,
+ 8 * PCOI(pcop)->offset );
+ }
+ } else
+ SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index);
+ } else {
+ if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) {
+ SAFE_snprintf(&s,&size,"(%s + %d)",
+ pcop->name,
+ PCOI(pcop)->index );
+ } else {
+ switch(PCOI(pcop)->offset) {
+ case 0:
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ break;
+ case 1:
+ SAFE_snprintf(&s,&size,"high %s",pcop->name);
+ break;
+ default:
+ SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset);
+ }
+ }
+ }
+
+ return buffer;
+
+ case PO_DIR:
+ s = buffer;
+ //size = sizeof(buffer);
+ if( PCOR(pcop)->instance) {
+ SAFE_snprintf(&s,&size,"(%s + %d)",
+ pcop->name,
+ PCOR(pcop)->instance );
+ //fprintf(stderr,"PO_DIR %s\n",buffer);
+ } else
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ return buffer;
+
+ case PO_LABEL:
+ s = buffer;
+ if (pcop->name) {
+ if(PCOLAB(pcop)->offset == 1)
+ SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
+ else
+ SAFE_snprintf(&s,&size,"%s",pcop->name);
+ }
return buffer;
default:
- if (pcc->pcop->name)
- return pcc->pcop->name;
+ if (pcop->name) {
+ if(use_buffer) {
+ SAFE_snprintf(&buffer,&size,"%s",pcop->name);
+ return buffer;
+ }
+ return pcop->name;
+ }
}
}
return "NO operand";
+
+}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static char *get_op_from_instruction( pCodeInstruction *pcc)
+{
+
+ if(pcc )
+ return get_op(pcc->pcop,NULL,0);
+
+ /* gcc 3.2: warning: concatenation of string literals with __FUNCTION__ is deprecated
+ return ("ERROR Null: "__FUNCTION__);
+ */
+ return ("ERROR Null: get_op_from_instruction");
+
}
/*-----------------------------------------------------------------*/
static void pCodeOpPrint(FILE *of, pCodeOp *pcop)
{
- fprintf(of,"pcodeopprint\n");
+ fprintf(of,"pcodeopprint- not implemented\n");
}
-char *pCode2str(char *str, int size, pCode *pc)
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+char *pCode2str(char *str, size_t size, pCode *pc)
{
char *s = str;
if(PCI(pc)->isBitInst) {
if(PCI(pc)->pcop->type == PO_GPR_BIT) {
- if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) )
- SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)",
- PCI(pc)->pcop->name ,
- PCI(pc)->pcop->name );
- else
- SAFE_snprintf(&s,&size,"%s,%d", get_op(PCI(pc)),
- (((pCodeOpRegBit *)(PCI(pc)->pcop))->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(PCI(pc)),PCORB(PCI(pc)->pcop)->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(PCI(pc)));
+ 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(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
+ 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(PCI(pc)));
+ SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
}else {
- SAFE_snprintf(&s,&size,"%s",get_op(PCI(pc)));
+ 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'));
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_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;
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
{
}
}
+ if(PCI(pc)->cline)
+ genericPrint(of,PCODE(PCI(pc)->cline));
{
char str[256];
fprintf(of,"%s",str);
/* Debug */
- fprintf(of, "\t;key=%03x",pc->seq);
- if(PCI(pc)->pcflow)
- fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq);
+ if(debug_verbose) {
+ fprintf(of, "\t;key=%03x",pc->seq);
+ if(PCI(pc)->pcflow)
+ fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq);
+ }
}
#if 0
{
break;
case PC_FLOW:
- fprintf(of,";Start of new flow, seq=%d\n",pc->seq);
+ 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 (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) {
b = b->next;
}
-#if 0
-
- original stuff:
-
- bprev = NULL;
- b = pcl->label;
- while(b) {
- if(b->pc == pc) {
-
- /* Found a label */
- if(bprev) {
- bprev->next = b->next; /* Not first pCode in chain */
- free(b);
- } else {
- pc->destruct(pc);
- pcl->label = b->next; /* First pCode in chain */
- free(b);
- }
- return; /* A label can't occur more than once */
- }
- bprev = b;
- b = b->next;
- }
-#endif
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-static pBranch * pBranchAppend(pBranch *h, pBranch *n)
+pBranch * pBranchAppend(pBranch *h, pBranch *n)
{
pBranch *b;
if(!h)
return n;
+ if(h == n)
+ return n;
+
b = h;
while(b->next)
b = b->next;
fprintf(stderr,"analyze PC_FLOW\n");
return;
+ case PC_BAD:
+ fprintf(stderr,,";A bad pCode is being used\n");
+
}
}
#endif
+/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
{
return FALSE;
}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+int checkLabel(pCode *pc)
+{
+ pBranch *pbr;
+
+ if(pc && isPCI(pc)) {
+ pbr = PCI(pc)->label;
+ while(pbr) {
+ if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
+ return TRUE;
+
+ pbr = pbr->next;
+ }
+ }
+
+ return FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* findLabelinpBlock - Search the pCode for a particular label */
+/*-----------------------------------------------------------------*/
+pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
+{
+ pCode *pc;
+
+ if(!pb)
+ return NULL;
+
+ for(pc = pb->pcHead; pc; pc = pc->next)
+ if(compareLabel(pc,pcop_label))
+ return pc;
+
+ return NULL;
+}
+
/*-----------------------------------------------------------------*/
/* findLabel - Search the pCode for a particular label */
/*-----------------------------------------------------------------*/
return NULL;
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- for(pc = pb->pcHead; pc; pc = pc->next)
- if(compareLabel(pc,pcop_label))
- return pc;
-
+ if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
+ return pc;
}
fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name);
/* findNextInstruction - given a pCode, find the next instruction */
/* in the linked list */
/*-----------------------------------------------------------------*/
-pCode * findNextInstruction(pCode *pc)
+pCode * findNextInstruction(pCode *pci)
{
+ pCode *pc = pci;
while(pc) {
if((pc->type == PC_OPCODE) || (pc->type == PC_WILD))
return pc;
+#ifdef PCODE_DEBUG
+ fprintf(stderr,"findNextInstruction: ");
+ printpCode(stderr, pc);
+#endif
pc = pc->next;
}
return NULL;
}
+/*-----------------------------------------------------------------*/
+/* findNextInstruction - given a pCode, find the next instruction */
+/* in the linked list */
+/*-----------------------------------------------------------------*/
+pCode * findPrevInstruction(pCode *pci)
+{
+ return findPrevpCode(pci, PC_OPCODE);
+}
+
/*-----------------------------------------------------------------*/
/* findFunctionEnd - given a pCode find the end of the function */
-/* that contains it t */
+/* that contains it */
/*-----------------------------------------------------------------*/
pCode * findFunctionEnd(pCode *pc)
{
/*-----------------------------------------------------------------*/
regs * getRegFromInstruction(pCode *pc)
{
+
if(!pc ||
!isPCI(pc) ||
!PCI(pc)->pcop ||
switch(PCI(pc)->pcop->type) {
case PO_INDF:
case PO_FSR:
- return pic14_regWithIdx(PCOR(PCI(pc)->pcop)->rIdx);
+ 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");
+ //fprintf(stderr, "getRegFromInstruction - bit or temp\n");
return PCOR(PCI(pc)->pcop)->r;
case PO_IMMEDIATE:
- fprintf(stderr, "getRegFromInstruction - immediate\n");
- return NULL; // PCOR(PCI(pc)->pcop)->r;
+ if(PCOI(PCI(pc)->pcop)->r)
+ return (PCOI(PCI(pc)->pcop)->r);
+
+ //fprintf(stderr, "getRegFromInstruction - immediate\n");
+ return dirregWithName(PCI(pc)->pcop->name);
+ //return NULL; // PCOR(PCI(pc)->pcop)->r;
case PO_GPR_BIT:
return PCOR(PCI(pc)->pcop)->r;
case PO_DIR:
- fprintf(stderr, "getRegFromInstruction - dir\n");
- //return NULL; PCOR(PCI(pc)->pcop)->r;
+ //fprintf(stderr, "getRegFromInstruction - dir\n");
return PCOR(PCI(pc)->pcop)->r;
case PO_LITERAL:
- fprintf(stderr, "getRegFromInstruction - literal\n");
+ //fprintf(stderr, "getRegFromInstruction - literal\n");
break;
default:
- fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
- genericPrint(stderr, pc);
+ //fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type);
+ //genericPrint(stderr, pc);
break;
}
/* Is this an instruction with operands? */
if(pc->type == PC_OPCODE && PCI(pc)->pcop) {
- if(PCI(pc)->pcop->type == PO_GPR_TEMP) {
+ if((PCI(pc)->pcop->type == PO_GPR_TEMP)
+ || ((PCI(pc)->pcop->type == PO_GPR_BIT) && PCOR(PCI(pc)->pcop)->r && (PCOR(PCI(pc)->pcop)->r->pc_type == PO_GPR_TEMP))) {
/* Loop through all of the registers declared so far in
this block and see if we find this one there */
if(!r) {
/* register wasn't found */
- r = Safe_calloc(1, sizeof(regs));
- memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
- addSet(&pb->tregisters, r);
- PCOR(PCI(pc)->pcop)->r = r;
+ //r = Safe_calloc(1, sizeof(regs));
+ //memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs));
+ //addSet(&pb->tregisters, r);
+ addSet(&pb->tregisters, PCOR(PCI(pc)->pcop)->r);
+ //PCOR(PCI(pc)->pcop)->r = r;
//fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx);
}/* else
fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx);
void InsertpFlow(pCode *pc, pCode **pflow)
{
- PCFL(*pflow)->end = pc;
+ if(*pflow)
+ PCFL(*pflow)->end = pc;
if(!pc || !pc->next)
return;
{
pCode *pc;
pCode *last_pci=NULL;
- pCode *pflow;
+ pCode *pflow=NULL;
int seq = 0;
if(!pb)
//fprintf (stderr,"build flow start seq %d ",GpcFlowSeq);
/* Insert a pCodeFlow object at the beginning of a pBlock */
- pflow = newpCodeFlow(); /* Create a new Flow object */
- pflow->next = pb->pcHead; /* Make the current head the next object */
- pb->pcHead->prev = pflow; /* let the current head point back to the flow object */
- pb->pcHead = pflow; /* Make the Flow object the head */
- pflow->pb = pb;
+ InsertpFlow(pb->pcHead, &pflow);
+
+ //pflow = newpCodeFlow(); /* Create a new Flow object */
+ //pflow->next = pb->pcHead; /* Make the current head the next object */
+ //pb->pcHead->prev = pflow; /* let the current head point back to the flow object */
+ //pb->pcHead = pflow; /* Make the Flow object the head */
+ //pflow->pb = pb;
- for( pc = findNextInstruction(pb->pcHead);
- (pc=findNextInstruction(pc)) != NULL; ) {
+ for( pc = findNextInstruction(pb->pcHead);
+ pc != NULL;
+ pc=findNextInstruction(pc)) {
pc->seq = seq++;
PCI(pc)->pcflow = PCFL(pflow);
- if(PCI(pc)->isSkip || PCI(pc)->isBranch) {
+ //fprintf(stderr," build: ");
+ //pflow->print(stderr,pflow);
+
+ if( PCI(pc)->isSkip) {
+
+ /* The two instructions immediately following this one
+ * mark the beginning of a new flow segment */
+
+ while(pc && PCI(pc)->isSkip) {
+
+ PCI(pc)->pcflow = PCFL(pflow);
+ pc->seq = seq-1;
+ seq = 1;
+
+ InsertpFlow(pc, &pflow);
+ pc=findNextInstruction(pc->next);
+ }
+
+ seq = 0;
+
+ if(!pc)
+ break;
+
+ PCI(pc)->pcflow = PCFL(pflow);
+ pc->seq = 0;
+ InsertpFlow(pc, &pflow);
- /* The instruction immediately following this one
- * marks the beginning of a new flow segment */
+ } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next))) {
InsertpFlow(pc, &pflow);
seq = 0;
-
- } else if (PCI_HAS_LABEL(pc)) {
+
+ } else if (checkLabel(pc)) {
/* This instruction marks the beginning of a
* new flow segment */
pc->seq = 0;
- seq = 1;
- InsertpFlow(pc->prev, &pflow);
+ 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);
}
//fprintf (stderr,",end seq %d",GpcFlowSeq);
- PCFL(pflow)->end = pb->pcTail;
+ if(pflow)
+ PCFL(pflow)->end = pb->pcTail;
+}
+
+/*-------------------------------------------------------------------*/
+/* unBuildFlow(pBlock *pb) - examine the code in a pBlock and build */
+/* the flow blocks. */
+/*
+ * unBuildFlow removes pCodeFlow objects from a pCode chain
+ */
+/*-----------------------------------------------------------------*/
+void unBuildFlow(pBlock *pb)
+{
+ pCode *pc,*pcnext;
+
+ if(!pb)
+ return;
+
+ pc = pb->pcHead;
+
+ while(pc) {
+ pcnext = pc->next;
+
+ if(isPCI(pc)) {
+
+ pc->seq = 0;
+ if(PCI(pc)->pcflow) {
+ //free(PCI(pc)->pcflow);
+ PCI(pc)->pcflow = NULL;
+ }
+
+ } else if(isPCFL(pc) )
+ pc->destruct(pc);
+
+ pc = pcnext;
+ }
+
+
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void FillFlow(pCodeFlow *pcflow)
+void FlowStats(pCodeFlow *pcflow)
{
pCode *pc;
- int cur_bank;
if(!isPCFL(pcflow))
return;
- // fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
+ fprintf(stderr, " FlowStats - flow block (seq=%d)\n", pcflow->pc.seq);
pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
+
if(!pc) {
- // fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
+ fprintf(stderr, " FlowStats - empty flow (seq=%d)\n", pcflow->pc.seq);
return;
}
- cur_bank = -1;
- do {
- //regs *reg;
+ fprintf(stderr, " FlowStats inCond: ");
+ dumpCond(pcflow->inCond);
+ fprintf(stderr, " FlowStats outCond: ");
+ dumpCond(pcflow->outCond);
- int inCond = PCI(pc)->inCond;
- int outCond = PCI(pc)->outCond;
-#if 0
- if( (reg = getRegFromInstruction(pc)) != NULL) {
- if(isSTATUS_REG(reg)) {
-
- //fprintf(stderr, " FillFlow - Status register\n");
-
- /* Check to see if the register banks are changing */
- if(PCI(pc)->isModReg) {
-
- pCodeOp *pcop = PCI(pc)->pcop;
- switch(PCI(pc)->op) {
- case POC_BSF:
- if(PCORB(pcop)->bit == PIC_RP0_BIT)
- fprintf(stderr, " FillFlow - Set RP0\n");
- //outCond |= PCC_REG_BANK1;
- if(PCORB(pcop)->bit == PIC_RP1_BIT)
- fprintf(stderr, " FillFlow - Set RP1\n");
- //outCond |= PCC_REG_BANK3;
- break;
+}
- case POC_BCF:
- if(PCORB(pcop)->bit == PIC_RP0_BIT)
- fprintf(stderr, " FillFlow - Clr RP0\n");
- //outCond |= PCC_REG_BANK1;
- if(PCORB(pcop)->bit == PIC_RP1_BIT)
- fprintf(stderr, " FillFlow - Clr RP1\n");
- //outCond |= PCC_REG_BANK3;
- break;
+/*-----------------------------------------------------------------*
+ * int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
+ * if it affects the banking bits.
+ *
+ * return: -1 == Banking bits are unaffected by this pCode.
+ *
+ * return: > 0 == Banking bits are affected.
+ *
+ * If the banking bits are affected, then the returned value describes
+ * which bits are affected and how they're affected. The lower half
+ * of the integer maps to the bits that are affected, the upper half
+ * to whether they're set or cleared.
+ *
+ *-----------------------------------------------------------------*/
+#define SET_BANK_BIT (1 << 16)
+#define CLR_BANK_BIT 0
- default:
- fprintf(stderr, " FillFlow - Status register is getting Modified by:\n");
- genericPrint(stderr, pc);
- }
- }
+int isBankInstruction(pCode *pc)
+{
+ regs *reg;
+ int bank = -1;
- } else
- inCond |= PCC_REG_BANK0 << (REG_BANK(reg) & 3);
- }
-#endif
+ if(!isPCI(pc))
+ return -1;
- pcflow->inCond |= (inCond & ~pcflow->outCond);
- pcflow->outCond |= outCond;
+ if( ( (reg = getRegFromInstruction(pc)) != NULL) && isSTATUS_REG(reg)) {
-
+ /* Check to see if the register banks are changing */
+ if(PCI(pc)->isModReg) {
+ pCodeOp *pcop = PCI(pc)->pcop;
+ switch(PCI(pc)->op) {
- pc = findNextpCode(pc->next, PC_OPCODE);
- } while (pc && (pc != pcflow->end));
+ case POC_BSF:
+ if(PCORB(pcop)->bit == PIC_RP0_BIT) {
+ //fprintf(stderr, " isBankInstruction - Set RP0\n");
+ return SET_BANK_BIT | PIC_RP0_BIT;
+ }
-#if 0
- if(!pc)
- fprintf(stderr, " FillFlow - Bad end of flow\n");
+ if(PCORB(pcop)->bit == PIC_RP1_BIT) {
+ //fprintf(stderr, " isBankInstruction - Set RP1\n");
+ return CLR_BANK_BIT | PIC_RP0_BIT;
+ }
+ break;
+ case POC_BCF:
+ if(PCORB(pcop)->bit == PIC_RP0_BIT) {
+ //fprintf(stderr, " isBankInstruction - Clr RP0\n");
+ return CLR_BANK_BIT | PIC_RP1_BIT;
+ }
+ if(PCORB(pcop)->bit == PIC_RP1_BIT) {
+ //fprintf(stderr, " isBankInstruction - Clr RP1\n");
+ return CLR_BANK_BIT | PIC_RP1_BIT;
+ }
+ break;
+ default:
+ //fprintf(stderr, " isBankInstruction - Status register is getting Modified by:\n");
+ //genericPrint(stderr, pc);
+ ;
+ }
+ }
- fprintf(stderr, " FillFlow inCond: ");
- dumpCond(pcflow->inCond);
- fprintf(stderr, " FillFlow outCond: ");
- dumpCond(pcflow->outCond);
-#endif
+ }
+
+ return bank;
}
+
+
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
+void FillFlow(pCodeFlow *pcflow)
{
- if(!from || !to || !to->pcflow || !from->pcflow)
+ pCode *pc;
+ int cur_bank;
+
+ if(!isPCFL(pcflow))
+ return;
+
+ // fprintf(stderr, " FillFlow - flow block (seq=%d)\n", pcflow->pc.seq);
+
+ pc = findNextpCode(PCODE(pcflow), PC_OPCODE);
+
+ if(!pc) {
+ //fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq);
return;
+ }
+
+ cur_bank = -1;
- addSet(&(from->pcflow->to), to->pcflow);
- addSet(&(to->pcflow->from), from->pcflow);
+ do {
+ isBankInstruction(pc);
+ pc = pc->next;
+ } while (pc && (pc != pcflow->end) && !isPCFL(pc));
+
+/*
+ if(!pc ) {
+ fprintf(stderr, " FillFlow - Bad end of flow\n");
+ } else {
+ fprintf(stderr, " FillFlow - Ending flow with\n ");
+ pc->print(stderr,pc);
+ }
+ fprintf(stderr, " FillFlow inCond: ");
+ dumpCond(pcflow->inCond);
+ fprintf(stderr, " FillFlow outCond: ");
+ dumpCond(pcflow->outCond);
+*/
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
+void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
+{
+ pCodeFlowLink *fromLink, *toLink;
+
+ if(!from || !to || !to->pcflow || !from->pcflow)
+ return;
+
+ fromLink = newpCodeFlowLink(from->pcflow);
+ toLink = newpCodeFlowLink(to->pcflow);
+
+ addSetIfnotP(&(from->pcflow->to), toLink); //to->pcflow);
+ addSetIfnotP(&(to->pcflow->from), fromLink); //from->pcflow);
+
+}
+
+/*-----------------------------------------------------------------*
+ * void LinkFlow(pBlock *pb)
+ *
+ * In BuildFlow, the PIC code has been partitioned into contiguous
+ * non-branching segments. In LinkFlow, we determine the execution
+ * order of these segments. For example, if one of the segments ends
+ * with a skip, then we know that there are two possible flow segments
+ * to which control may be passed.
+ *-----------------------------------------------------------------*/
void LinkFlow(pBlock *pb)
{
pCode *pc=NULL;
pCode *pcflow;
pCode *pct;
-
+ //fprintf(stderr,"linkflow \n");
+
for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
- pcflow = pcflow->next) {
+ pcflow != NULL;
+ pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
if(!isPCFL(pcflow))
fprintf(stderr, "LinkFlow - pcflow is not a flow object ");
+ //fprintf(stderr," link: ");
+ //pcflow->print(stderr,pcflow);
+
//FillFlow(PCFL(pcflow));
pc = PCFL(pcflow)->end;
//fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq);
if(isPCI_SKIP(pc)) {
//fprintf(stderr, "ends with skip\n");
+ //pc->print(stderr,pc);
pct=findNextInstruction(pc->next);
LinkFlow_pCode(PCI(pc),PCI(pct));
pct=findNextInstruction(pct->next);
}
if(isPCI_BRANCH(pc)) {
- //fprintf(stderr, "ends with branch\n");
+ pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
+
+ //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) ) {
+ 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:""));
continue;
}
-#if 0
+
+ if(isPCI(pc)) {
+ //fprintf(stderr, "ends with non-branching instruction:\n");
+ //pc->print(stderr,pc);
+
+ LinkFlow_pCode(PCI(pc),PCI(findNextInstruction(pc->next)));
+
+ continue;
+ }
+
if(pc) {
- fprintf(stderr, "has an unrecognized ending:\n");
- pc->print(stderr,pc);
+ //fprintf(stderr, "ends with unknown\n");
+ //pc->print(stderr,pc);
+ continue;
}
- else
- fprintf(stderr, "has no end pcode\n");
-#endif
+
+ //fprintf(stderr, "ends with nothing: ERROR\n");
}
}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+int isPCinFlow(pCode *pc, pCode *pcflow)
+{
+
+ if(!pc || !pcflow)
+ return 0;
+
+ if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
+ return 0;
+
+ if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
+ return 1;
+
+ return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void BanksUsedFlow2(pCode *pcflow)
+{
+ pCode *pc=NULL;
+
+ int bank = -1;
+ bool RegUsed = 0;
+
+ regs *reg;
+
+ if(!isPCFL(pcflow)) {
+ fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
+ return;
+ }
+
+ pc = findNextInstruction(pcflow->next);
+
+ PCFL(pcflow)->lastBank = -1;
+
+ while(isPCinFlow(pc,pcflow)) {
+
+ int bank_selected = isBankInstruction(pc);
+
+ //if(PCI(pc)->pcflow)
+ //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
+
+ if(bank_selected > 0) {
+ //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
+
+ /* This instruction is modifying banking bits before accessing registers */
+ if(!RegUsed)
+ PCFL(pcflow)->firstBank = -1;
+
+ if(PCFL(pcflow)->lastBank == -1)
+ PCFL(pcflow)->lastBank = 0;
+
+ bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
+ if(bank_selected & SET_BANK_BIT)
+ PCFL(pcflow)->lastBank |= bank;
+
+
+ } else {
+ reg = getRegFromInstruction(pc);
+
+ if(reg && !isREGinBank(reg, bank)) {
+ int allbanks = REGallBanks(reg);
+ if(bank == -1)
+ PCFL(pcflow)->firstBank = allbanks;
+
+ PCFL(pcflow)->lastBank = allbanks;
+
+ bank = allbanks;
+ }
+ RegUsed = 1;
+ }
+
+ pc = findNextInstruction(pc->next);
+ }
+
+// fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
+// pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
+
+
+
+}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void BanksUsedFlow(pBlock *pb)
+{
+ pCode *pcflow;
+
+
+ //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) ) {
+
+ BanksUsedFlow2(pcflow);
+ }
+
+}
+
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void insertBankSwitch(int position, pCode *pc, int Set_Clear, int RP_BankBit)
+{
+ pCode *new_pc;
+
+ if(!pc)
+ return;
+
+ if(RP_BankBit < 0)
+ new_pc = newpCode(POC_CLRF, popCopyReg(&pc_status));
+ else
+ new_pc = newpCode((Set_Clear ? POC_BSF : POC_BCF),
+ popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
+
+ if(position) {
+ /* insert the bank switch after this pc instruction */
+ pCode *pcnext = findNextInstruction(pc);
+ pCodeInsertAfter(pc, new_pc);
+ if(pcnext)
+ pc = pcnext;
+
+ } else
+ pCodeInsertAfter(pc->prev, new_pc);
+
+ /* Move the label, if there is one */
+
+ if(PCI(pc)->label) {
+ PCI(new_pc)->label = PCI(pc)->label;
+ PCI(pc)->label = NULL;
+ }
+
+ /* The new instruction has the same pcflow block */
+ PCI(new_pc)->pcflow = PCI(pc)->pcflow;
+
+}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank)
+{
+ pCode *pc=NULL;
+ pCode *pcprev=NULL;
+ pCode *new_pc;
+
+ regs *reg;
+
+ if(!pcfl)
+ return;
+
+ pc = findNextInstruction(pcfl->pc.next);
+
+ while(isPCinFlow(pc,PCODE(pcfl))) {
+
+ reg = getRegFromInstruction(pc);
+#if 0
+ if(reg) {
+ fprintf(stderr, " %s ",reg->name);
+ fprintf(stderr, "addr = 0x%03x, bank = %d\n",reg->address,REG_BANK(reg));
+
+ }
+#endif
+
+ if( ( (reg && REG_BANK(reg)!=cur_bank) ||
+ ((PCI(pc)->op == POC_CALL) && (cur_bank != 0) ) ) &&
+ (!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))) {
+ int b;
+ int reg_bank;
+
+ reg_bank = (reg) ? REG_BANK(reg) : 0;
+
+ b = cur_bank ^ reg_bank;
+
+ //fprintf(stderr, "Cool! can switch banks\n");
+ cur_bank = reg_bank;
+ switch(b & 3) {
+ case 0:
+ break;
+ case 1:
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ break;
+ case 2:
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ break;
+ case 3:
+ if(cur_bank & 3) {
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ } else
+ insertBankSwitch(0, pc, -1, -1);
+ break;
+
+ }
+
+ } else {
+ //fprintf(stderr, "Bummer can't switch banks\n");
+ ;
+ }
+ }
+
+ pcprev = pc;
+ pc = findNextInstruction(pc->next);
+
+ }
+
+ if(pcprev && cur_bank) {
+ /* Brute force - make sure that we point to bank 0 at the
+ * end of each flow block */
+ new_pc = newpCode(POC_BCF,
+ popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT));
+ pCodeInsertAfter(pcprev, new_pc);
+ cur_bank = 0;
+ }
+
+}
+
+/*-----------------------------------------------------------------*/
+/*int compareBankFlow - compare the banking requirements between */
+/* flow objects. */
+/*-----------------------------------------------------------------*/
+int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
+{
+
+ 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);
+ }
+
+ 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++;
+
+ }
+ /*
+ 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);
+
+ }
+ }
+
+ //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 ");
+ 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),0);
+ 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),0);
+ 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 ");
+ 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);
+ }
+
+ }
+
+ }
+
+}
+
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
int OptimizepBlock(pBlock *pb)
{
- pCode *pc;
+ pCode *pc, *pcprev;
int matches =0;
if(!pb || !peepOptimizing)
return 0;
DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb)));
+/*
for(pc = pb->pcHead; pc; pc = pc->next)
matches += pCodePeepMatchRule(pc);
+*/
+
+ pc = findNextInstruction(pb->pcHead);
+ if(!pc)
+ return 0;
+
+ pcprev = pc->prev;
+ do {
+
+
+ if(pCodePeepMatchRule(pc)) {
+
+ matches++;
+
+ if(pcprev)
+ pc = findNextInstruction(pcprev->next);
+ else
+ pc = findNextInstruction(pb->pcHead);
+ } else
+ pc = findNextInstruction(pc->next);
+ } while(pc);
+
if(matches)
DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
return matches;
return NULL;
}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+void exchangeLabels(pCodeLabel *pcl, pCode *pc)
+{
+
+ char *s=NULL;
+
+ if(isPCI(pc) &&
+ (PCI(pc)->pcop) &&
+ (PCI(pc)->pcop->type == PO_LABEL)) {
+
+ pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
+
+ //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
+ if(pcol->pcop.name)
+ free(pcol->pcop.name);
+
+ /* If the key is negative, then we (probably) have a label to
+ * a function and the name is already defined */
+
+ if(pcl->key>0)
+ sprintf(s=buffer,"_%05d_DS_",pcl->key);
+ else
+ s = pcl->label;
+
+ //sprintf(buffer,"_%05d_DS_",pcl->key);
+ if(!s) {
+ fprintf(stderr, "ERROR %s:%d function label is null\n",__FUNCTION__,__LINE__);
+ }
+ pcol->pcop.name = Safe_strdup(s);
+ pcol->key = pcl->key;
+ //pc->print(stderr,pc);
+
+ }
+
+
+}
+
/*-----------------------------------------------------------------*/
/* pBlockRemoveUnusedLabels - remove the pCode labels from the */
/* pCode chain if they're not used. */
if(!pb)
return;
+ for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
+
+ pBranch *pbr = PCI(pc)->label;
+ if(pbr && pbr->next) {
+ pCode *pcd = pb->pcHead;
+
+ //fprintf(stderr, "multiple labels\n");
+ //pc->print(stderr,pc);
+
+ pbr = pbr->next;
+ while(pbr) {
+
+ while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
+ //fprintf(stderr,"Used by:\n");
+ //pcd->print(stderr,pcd);
+
+ exchangeLabels(PCL(pbr->pc),pcd);
+
+ pcd = pcd->next;
+ }
+ pbr = pbr->next;
+ }
+ }
+ }
+
for(pc = pb->pcHead; pc; pc = pc->next) {
- if(pc->type == PC_LABEL)
+ if(isPCL(pc)) // pc->type == PC_LABEL)
pcl = PCL(pc);
- else if ((pc->type == PC_OPCODE) && PCI(pc)->label)
+ else if (isPCI(pc) && PCI(pc)->label) //((pc->type == PC_OPCODE) && PCI(pc)->label)
pcl = PCL(PCI(pc)->label->pc);
else continue;
- /* This pCode is a label, so search the pBlock to see if anyone
- * refers to it */
+ //fprintf(stderr," found A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
+
+ /* This pCode is a label, so search the pBlock to see if anyone
+ * refers to it */
if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
+ //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
/* Couldn't find an instruction that refers to this label
* So, unlink the pCode label from it's pCode chain
* and destroy the label */
+ //fprintf(stderr," removed A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
- DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d\n", pcl->key));
-
+ DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
if(pc->type == PC_LABEL) {
- unlinkPC(pc);
+ unlinkpCode(pc);
pCodeLabelDestruct(pc);
} else {
unlinkpCodeFromBranch(pc, PCODE(pcl));
/* Now loop through the pBlock and merge the labels with the opcodes */
- for(pc = pb->pcHead; pc; pc = pc->next) {
+ pc = pb->pcHead;
+ // for(pc = pb->pcHead; pc; pc = pc->next) {
+
+ while(pc) {
+ pCode *pcn = pc->next;
if(pc->type == PC_LABEL) {
+
+ //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
//fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
- if( !(pcnext = findNextInstruction(pc)) )
- return; // Couldn't find an instruction associated with this label
-
- // Unlink the pCode label from it's pCode chain
- unlinkPC(pc);
-
- //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
- // And link it into the instruction's pBranch labels. (Note, since
- // it's possible to have multiple labels associated with one instruction
- // we must provide a means to accomodate the additional labels. Thus
- // the labels are placed into the singly-linked list "label" as
- // opposed to being a single member of the pCodeInstruction.)
-
- //_ALLOC(pbr,sizeof(pBranch));
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = pc;
- pbr->next = NULL;
-
- PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
- if(pcnext->prev)
- pc = pcnext->prev;
- else
- pc = pcnext;
- }
+ if((pcnext = findNextInstruction(pc) )) {
+
+ // Unlink the pCode label from it's pCode chain
+ unlinkpCode(pc);
+
+ //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key);
+ // And link it into the instruction's pBranch labels. (Note, since
+ // it's possible to have multiple labels associated with one instruction
+ // we must provide a means to accomodate the additional labels. Thus
+ // the labels are placed into the singly-linked list "label" as
+ // opposed to being a single member of the pCodeInstruction.)
+
+ //_ALLOC(pbr,sizeof(pBranch));
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = pc;
+ pbr->next = NULL;
+
+ PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
+
+ } else {
+ fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
+ }
+ } else if(pc->type == PC_CSOURCE) {
+
+ /* merge the source line symbolic info into the next instruction */
+ if((pcnext = findNextInstruction(pc) )) {
+ // Unlink the pCode label from it's pCode chain
+ unlinkpCode(pc);
+ PCI(pcnext)->cline = PCCS(pc);
+ //fprintf(stderr, "merging CSRC\n");
+ //genericPrint(stderr,pcnext);
+ }
+
+ }
+ pc = pcn;
}
pBlockRemoveUnusedLabels(pb);
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void OptimizepCode(char dbName)
+int OptimizepCode(char dbName)
{
#define MAX_PASSES 4
pBlock *pb;
if(!the_pFile)
- return;
+ return 0;
DFPRINTF((stderr," Optimizing pCode\n"));
do {
+ matches = 0;
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
if('*' == dbName || getpBlock_dbName(pb) == dbName)
matches += OptimizepBlock(pb);
}
while(matches && ++passes < MAX_PASSES);
+ return matches;
}
/*-----------------------------------------------------------------*/
-/* popCopy - copy a pcode operator */
+/* popCopyGPR2Bit - copy a pcode operator */
/*-----------------------------------------------------------------*/
+
pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
{
pCodeOp *pcop;
{
pCode *pc=NULL;
pCode *pcprev=NULL;
- pCode *new_pc;
int cur_bank;
regs *reg;
- return;
+
if(!pb)
return;
- pc = findNextpCode(pb->pcHead, PC_FLOW);
+ //pc = findNextpCode(pb->pcHead, PC_FLOW);
+ pc = findNextpCode(pb->pcHead, PC_OPCODE);
if(!pc)
return;
/* loop through all of the flow blocks with in one pblock */
- // fprintf(stderr,"Register banking\n");
+ //fprintf(stderr,"Register banking\n");
cur_bank = 0;
do {
/* at this point, pc should point to a PC_FLOW object */
/* for each flow block, determine the register banking
requirements */
- do {
+ // do {
if(isPCI(pc)) {
- genericPrint(stderr, pc);
+ //genericPrint(stderr, pc);
reg = getRegFromInstruction(pc);
- //#if 0
+#if 0
if(reg) {
fprintf(stderr, " %s ",reg->name);
- fprintf(stderr, "addr = 0x%03x, bank = %d\n",reg->address,REG_BANK(reg));
+ fprintf(stderr, "addr = 0x%03x, bank = %d, bit=%d\n",
+ reg->address,REG_BANK(reg),reg->isBitField);
}
- //#endif
- if(reg && REG_BANK(reg)!=cur_bank) {
+#endif
+
+ if( ( (reg && REG_BANK(reg)!=cur_bank) ||
+ ((PCI(pc)->op == POC_CALL) && (cur_bank != 0) ) ) &&
+ (!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 && !isPCI_SKIP(pcprev)) {
- int b = cur_bank ^ REG_BANK(reg);
- //fprintf(stderr, "Cool! can switch banks\n");
- cur_bank = REG_BANK(reg);
- if(b & 1) {
- new_pc = newpCode(((cur_bank&1) ? POC_BSF : POC_BCF),
- popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT));
- pCodeInsertAfter(pc->prev, new_pc);
- if(PCI(pc)->label) {
- PCI(new_pc)->label = PCI(pc)->label;
- PCI(pc)->label = NULL;
- }
- /*
- new_pc = newpCode(((cur_bank&1) ? POC_BCF : POC_BSF),
- popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT));
- pCodeInsertAfter(pc, new_pc);
- */
+ if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
+ int b;
+ int reg_bank;
+
+ reg_bank = (reg) ? REG_BANK(reg) : 0;
+
+ b = cur_bank ^ reg_bank;
+
+ cur_bank = reg_bank;
+ switch(b & 3) {
+ case 0:
+ break;
+ case 1:
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ break;
+ case 2:
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ break;
+ case 3:
+ if(cur_bank & 3) {
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ } else
+ insertBankSwitch(0, pc, -1, -1);
+ break;
}
- } else
- fprintf(stderr, "Bummer can't switch banks\n");
+ }else {
+ //fprintf(stderr, "Bummer can't switch banks\n");
+ ;
+ }
}
+
+ pcprev = pc;
+
}
- pcprev = pc;
pc = pc->next;
- } while(pc && !(isPCFL(pc)));
-
- if(pcprev && cur_bank) {
- /* Brute force - make sure that we point to bank 0 at the
- * end of each flow block */
- new_pc = newpCode(POC_BCF,
- popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT));
- pCodeInsertAfter(pcprev, new_pc);
- cur_bank = 0;
- }
+ // } while(pc && !(isPCFL(pc)));
+
}while (pc);
+ if(pcprev && cur_bank) {
+
+ int pos = 1; /* Assume that the bank swithc instruction(s)
+ * are inserted after this instruction */
+
+ if((PCI(pcprev)->op == POC_RETLW) ||
+ (PCI(pcprev)->op == POC_RETURN) ||
+ (PCI(pcprev)->op == POC_RETFIE)) {
+
+ /* oops, a RETURN - we need to switch banks *before* the RETURN */
+
+ pos = 0;
+
+ }
+
+ /* Brute force - make sure that we point to bank 0 at the
+ * end of each flow block */
+
+ switch(cur_bank & 3) {
+ case 0:
+ break;
+ case 1:
+ insertBankSwitch(pos, pcprev, 0, PIC_RP0_BIT);
+ break;
+ case 2:
+ insertBankSwitch(pos, pcprev, 0, PIC_RP1_BIT);
+ insertBankSwitch(pos, pcprev, 0, PIC_RP1_BIT);
+ break;
+ case 3:
+ insertBankSwitch(pos, pcprev, -1, -1);
+ break;
+
+ }
+/*
+ new_pc = newpCode(POC_BCF,
+ popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT));
+ pCodeInsertAfter(pcprev, new_pc);
+*/
+ cur_bank = 0;
+ //fprintf(stderr, "Brute force switch\n");
+ }
+
}
+
+
+
+#if 0
+ if(reg && REG_BANK(reg)!=cur_bank) {
+ //fprintf(stderr,"need to switch banks\n");
+ /* 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))) {
+ int b = cur_bank ^ REG_BANK(reg);
+
+ cur_bank = REG_BANK(reg);
+
+ switch(b & 3) {
+ case 0:
+ break;
+ case 1:
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ break;
+ case 2:
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ break;
+ case 3:
+ if(cur_bank & 3) {
+ insertBankSwitch(0, pc, cur_bank&1, PIC_RP0_BIT);
+ insertBankSwitch(0, pc, cur_bank&2, PIC_RP1_BIT);
+ } else
+ insertBankSwitch(0, pc, -1, -1);
+ break;
+
+ }
+#endif
+
+
+
+
void pBlockDestruct(pBlock *pb)
{
}
/*-----------------------------------------------------------------*/
-/* AnalyzeBanking - Called after the memory addresses have been */
-/* assigned to the registers. */
+/* AnalyzeFlow - Examine the flow of the code and optimize */
/* */
+/* level 0 == minimal optimization */
+/* optimize registers that are used only by two instructions */
+/* level 1 == maximal optimization */
+/* optimize by looking at pairs of instructions that use the */
+/* register. */
/*-----------------------------------------------------------------*/
-void AnalyzeBanking(void)
+
+void AnalyzeFlow(int level)
{
+ static int times_called=0;
pBlock *pb;
return;
+ /* if this is not the first time this function has been called,
+ then clean up old flow information */
+ if(times_called++) {
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ unBuildFlow(pb);
+
+ RegsUnMapLiveRanges();
+
+ }
+
+ GpcFlowSeq = 1;
+
+ /* Phase 2 - Flow Analysis - Register Banking
+ *
+ * In this phase, the individual flow blocks are examined
+ * and register banking is fixed.
+ */
+
+ //for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ //FixRegisterBanking(pb);
+
/* Phase 2 - Flow Analysis
*
* In this phase, the pCode is partition into pCodeFlow
for(pb = the_pFile->pbHead; pb; pb = pb->next)
BuildFlow(pb);
+
/* Phase 2 - Flow Analysis - linking flow blocks
*
* In this phase, the individual flow blocks are examined
for(pb = the_pFile->pbHead; pb; pb = pb->next)
LinkFlow(pb);
+ /* Phase 3 - Flow Analysis - Flow Tree
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine their order of excution.
+ */
+
for(pb = the_pFile->pbHead; pb; pb = pb->next)
- FixRegisterBanking(pb);
+ BuildFlowTree(pb);
+
+
+ /* Phase x - Flow Analysis - Used Banks
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine the Register Banks they use
+ */
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ FixBankFlow(pb);
+
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegMapLiveRanges(pb);
+
+ RemoveUnusedRegisters();
+
+ // for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegOptimizeRegUsage(level);
+
+ OptimizepCode('*');
+
+/*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ DumpFlow(pb);
+*/
/* debug stuff */
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
pCode *pcflow;
}
}
+/*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ pCode *pcflow;
+ for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
+ (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL;
+ pcflow = pcflow->next) {
+
+ FlowStats(PCFL(pcflow));
+ }
+ }
+*/
+}
+
+/*-----------------------------------------------------------------*/
+/* AnalyzeBanking - Called after the memory addresses have been */
+/* assigned to the registers. */
+/* */
+/*-----------------------------------------------------------------*/
+
+void AnalyzeBanking(void)
+{
+ pBlock *pb;
+
+ if(!picIsInitialized()) {
+ fprintf(stderr,"Temporary ERROR: at the moment you have to use\n");
+ fprintf(stderr,"an include file create by inc2h.pl. See SDCC source:\n");
+ fprintf(stderr,"support/scripts/inc2h.pl\n");
+ fprintf(stderr,"this is a nuisance bug that will be fixed shortly\n");
+
+ exit(1);
+ }
+
+ /* Phase x - Flow Analysis - Used Banks
+ *
+ * In this phase, the individual flow blocks are examined
+ * to determine the Register Banks they use
+ */
+
+ AnalyzeFlow(0);
+ AnalyzeFlow(1);
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ BanksUsedFlow(pb);
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ FixRegisterBanking(pb);
+
+}
+
+// Undefine REUSE_GPR in files pcode.c & device.c to prevent local function registers being reused.
+#define REUSE_GPR
+#ifdef REUSE_GPR
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+DEFSETFUNC (resetrIdx)
+{
+ if (!((regs *)item)->isFixed)
+ ((regs *)item)->rIdx = 0;
+
+ return 0;
+}
+
+pCode *findFunction(char *fname);
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+unsigned register_reassign(pBlock *pb, unsigned idx)
+{
+ pCode *pc;
+
+ /* check recursion */
+ pc = setFirstItem(pb->function_entries);
+ if(!pc)
+ return idx;
+
+ DFPRINTF((stderr," reassigning registers for function \"%s\"\n",PCF(pc)->fname));
+
+ if (pb->tregisters) {
+ regs *r;
+ for (r = setFirstItem(pb->tregisters); r; r = setNextItem(pb->tregisters)) {
+ if (r->type == REG_GPR) {
+ if (!r->isFixed) {
+ if (r->rIdx < (int)idx) {
+ char s[20];
+ r->rIdx = idx++;
+ sprintf(s,"r0x%02X", r->rIdx);
+ DFPRINTF((stderr," reassigning register \"%s\" to \"%s\"\n",r->name,s));
+ free(r->name);
+ r->name = Safe_strdup(s);
+ }
+ }
+ }
+ }
+ }
+ for(pc = setFirstItem(pb->function_calls); pc; pc = setNextItem(pb->function_calls)) {
+
+ if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
+ char *dest = get_op_from_instruction(PCI(pc));
+
+ pCode *pcn = findFunction(dest);
+ if(pcn) {
+ register_reassign(pcn->pb,idx);
+ }
+ }
+
+ }
+
+ return idx;
+}
+
+/*-----------------------------------------------------------------*/
+/* Re-allocate the GPR for optimum reuse for a given pblock */
+/* eg if a function m() calls function f1() and f2(), where f1 */
+/* allocates a local variable vf1 and f2 allocates a local */
+/* variable vf2. Then providing f1 and f2 do not call each other */
+/* they may share the same general purpose registers for vf1 and */
+/* vf2. */
+/* This is done by first setting the the regs rIdx to start after */
+/* all the global variables, then walking through the call tree */
+/* renaming the registers to match their new idx and incrementng */
+/* it as it goes. If a function has already been called it will */
+/* only rename the registers if it has already used up those */
+/* registers ie rIdx of the function's registers is lower than the */
+/* current rIdx. That way the register will not be reused while */
+/* still being used by an eariler function call. */
+/*-----------------------------------------------------------------*/
+void register_reusage(pBlock *mainPb)
+{
+ static int exercised = 0;
+ if (!exercised) { /* Only do this once */
+ /* Find end of statically allocated variables for start idx */
+ unsigned idx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */
+ regs *r;
+ for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) {
+ if (r->type != REG_SFR) {
+ idx += r->size; /* Increment for all statically allocated variables */
+ }
+ }
+
+ applyToSet(dynAllocRegs,resetrIdx); /* Reset all rIdx to zero. */
+ if (mainPb)
+ idx = register_reassign(mainPb,idx); /* Do main and all the functions that are called from it. */
+ idx = register_reassign(the_pFile->pbHead,idx); /* Do the other functions such as interrupts. */
+ }
+ exercised++;
}
+#endif // REUSE_GPR
/*-----------------------------------------------------------------*/
/* buildCallTree - look at the flow and extract all of the calls */
/*-----------------------------------------------------------------*/
set *register_usage(pBlock *pb);
+
void buildCallTree(void )
{
pBranch *pbr;
- pBlock *pb;
+ pBlock *pb, *mainPb = 0;
pCode *pc;
if(!the_pFile)
return;
-
-
/* Now build the call tree.
First we examine all of the pCodes for functions.
Keep in mind that the function boundaries coincide
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
pCode *pc_fstart=NULL;
for(pc = pb->pcHead; pc; pc = pc->next) {
- if(isPCF(pc)) { //pc->type == PC_FUNCTION) {
- if (PCF(pc)->fname) {
-
- if(STRCASECMP(PCF(pc)->fname, "_main") == 0) {
- fprintf(stderr," found main \n");
- pb->cmemmap = NULL; /* FIXME do we need to free ? */
- pb->dbName = 'M';
- }
-
- //_ALLOC(pbr,sizeof(pBranch));
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = pc_fstart = pc;
- pbr->next = NULL;
-
- the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
-
- // Here's a better way of doing the same:
- addSet(&pb->function_entries, pc);
-
- } else {
- // Found an exit point in a function, e.g. return
- // (Note, there may be more than one return per function)
- if(pc_fstart)
- pBranchLink(PCF(pc_fstart), PCF(pc));
-
- addSet(&pb->function_exits, pc);
- }
- } else if(isCALL(pc)) {// if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- addSet(&pb->function_calls,pc);
+ if(isPCF(pc)) {
+ pCodeFunction *pcf = PCF(pc);
+ if (pcf->fname) {
+
+ if(STRCASECMP(pcf->fname, "_main") == 0) {
+ //fprintf(stderr," found main \n");
+ pb->cmemmap = NULL; /* FIXME do we need to free ? */
+ pb->dbName = 'M';
+ mainPb = pb;
+ }
+
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = pc_fstart = pc;
+ pbr->next = NULL;
+
+ the_pFile->functions = pBranchAppend(the_pFile->functions,pbr);
+
+ // Here's a better way of doing the same:
+ addSet(&pb->function_entries, pc);
+
+ } else {
+ // Found an exit point in a function, e.g. return
+ // (Note, there may be more than one return per function)
+ if(pc_fstart)
+ pBranchLink(PCF(pc_fstart), pcf);
+
+ addSet(&pb->function_exits, pc);
+ }
+ } else if(isCALL(pc)) {
+ addSet(&pb->function_calls,pc);
}
}
}
+#ifdef REUSE_GPR
+ register_reusage(mainPb); /* Comment out this line to prevent local function registers being reused. Note from this point onwards finding a GPR by its rIdx value will no longer work.*/
+#endif // REUSE_GPR
+
/* Re-allocate the registers so that there are no collisions
* between local variables when one function call another */
- pic14_deallocateAllRegs();
+ // this is weird...
+ // pic14_deallocateAllRegs();
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
if(!pb->visited)
do {
DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1));
+ //fprintf(stderr," Analyzing pCode: PASS #%d\n",i+1);
/* First, merge the labels with the instructions */
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
if('*' == dbName || getpBlock_dbName(pb) == dbName) {
DFPRINTF((stderr," analyze and merging block %c\n",dbName));
- //fprintf(stderr," analyze and merging block %c\n",getpBlock_dbName(pb));
+ //fprintf(stderr," analyze and merging block %c\n",dbName);
pBlockMergeLabels(pb);
AnalyzepBlock(pb);
+ } else {
+ DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName));
}
}
- changes = 0;
+ changes = OptimizepCode(dbName);
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if('*' == dbName || getpBlock_dbName(pb) == dbName)
- changes += OptimizepBlock(pb);
- }
-
} while(changes && (i++ < MAX_PASSES));
buildCallTree();
while(pc) {
if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- fprintf(of,"; %s\n",get_op(PCI(pc)));
+ fprintf(of,"; %s\n",get_op_from_instruction(PCI(pc)));
}
pc = setNextItem(pb->function_calls);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
+#if 0
static void sequencepCode(void)
{
pBlock *pb;
}
}
+#endif
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
for( ; pc; pc = setNextItem(pb->function_calls)) {
if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- char *dest = get_op(PCI(pc));
+ char *dest = get_op_from_instruction(PCI(pc));
pcn = findFunction(dest);
if(pcn)
// set *registersInCallPath = NULL;
if(!of)
- return;// registers;
+ return;
if(indent > 10)
- return; // registers; //recursion ?
+ return; //recursion ?
pc = setFirstItem(pb->function_entries);
for( ; pc; pc = setNextItem(pb->function_calls)) {
if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) {
- char *dest = get_op(PCI(pc));
+ char *dest = get_op_from_instruction(PCI(pc));
pcn = findFunction(dest);
if(pcn)
}
-#if 0
- fprintf(stderr,"pBlock before register optim.\n");
- pBlockStats(stderr,pb); // debug
-
- if(registersInCallPath) {
- /* registers were used in the functions this pBlock has called */
- /* so now, we need to see if these collide with the ones we are using here */
-
- regs *r1,*r2, *newreg;
-
- fprintf(stderr,"comparing registers\n");
-
- r1 = setFirstItem(registersInCallPath);
- while(r1) {
-
- r2 = setFirstItem(pb->registers);
-
- while(r2) {
-
- if(r2->rIdx == r1->rIdx) {
- newreg = pic14_findFreeReg();
-
-
- if(!newreg) {
- fprintf(stderr,"Bummer, no more registers.\n");
- exit(1);
- }
-
- fprintf(stderr,"Cool found register collision nIdx=%d moving to %d\n",
- r1->rIdx, newreg->rIdx);
- r2->rIdx = newreg->rIdx;
- //if(r2->name) free(r2->name);
- if(newreg->name)
- r2->name = Safe_strdup(newreg->name);
- else
- r2->name = NULL;
- newreg->isFree = 0;
- newreg->wasUsed = 1;
- }
- r2 = setNextItem(pb->registers);
- }
-
- r1 = setNextItem(registersInCallPath);
- }
-
- /* Collisions have been resolved. Now free the registers in the call path */
- r1 = setFirstItem(registersInCallPath);
- while(r1) {
- newreg = pic14_regWithIdx(r1->rIdx);
- newreg->isFree = 1;
- r1 = setNextItem(registersInCallPath);
- }
-
- } else
- MarkUsedRegisters(pb->registers);
-
- registers = unionSets(pb->registers, registersInCallPath, THROW_NONE);
-
- if(registers)
- fprintf(stderr,"returning regs\n");
- else
- fprintf(stderr,"not returning regs\n");
-
- fprintf(stderr,"pBlock after register optim.\n");
- pBlockStats(stderr,pb); // debug
-
-
- return registers;
-
-#endif
-
/*-----------------------------------------------------------------*/
/* printCallTree - writes the call tree to a file */
while(pc->next && !ispCodeFunction(pc->next)) {
pc = pc->next;
if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL)
- fprintf(of,"\t%s\n",get_op(PCI(pc)));
+ fprintf(of,"\t%s\n",get_op_from_instruction(PCI(pc)));
}
}
}
- /* Re-allocate the registers so that there are no collisions
- * between local variables when one function call another */
-#if 0
- pic14_deallocateAllRegs();
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if(!pb->visited)
- register_usage(pb);
- }
-#endif
-
fprintf(of,"\n**************\n\na better call tree\n");
for(pb = the_pFile->pbHead; pb; pb = pb->next) {
if(pb->visited)
fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
}
}
+
+
+
+/*-----------------------------------------------------------------*/
+/* */
+/*-----------------------------------------------------------------*/
+
+void InlineFunction(pBlock *pb)
+{
+ pCode *pc;
+ pCode *pc_call;
+
+ if(!pb)
+ return;
+
+ pc = setFirstItem(pb->function_calls);
+
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
+
+ if(isCALL(pc)) {
+ pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
+ pCode *pct;
+ pCode *pce;
+
+ pBranch *pbr;
+
+ if(pcn && isPCF(pcn) && (PCF(pcn)->ncalled == 1)) {
+
+ //fprintf(stderr,"Cool can inline:\n");
+ //pcn->print(stderr,pcn);
+
+ //fprintf(stderr,"recursive call Inline\n");
+ InlineFunction(pcn->pb);
+ //fprintf(stderr,"return from recursive call Inline\n");
+
+ /*
+ At this point, *pc points to a CALL mnemonic, and
+ *pcn points to the function that is being called.
+
+ To in-line this call, we need to remove the CALL
+ and RETURN(s), and link the function pCode in with
+ the CALLee pCode.
+
+ */
+
+
+ /* Remove the CALL */
+ pc_call = pc;
+ pc = pc->prev;
+
+ /* remove callee pBlock from the pBlock linked list */
+ removepBlock(pcn->pb);
+
+ pce = pcn;
+ while(pce) {
+ pce->pb = pb;
+ pce = pce->next;
+ }
+
+ /* Remove the Function pCode */
+ pct = findNextInstruction(pcn->next);
+
+ /* Link the function with the callee */
+ pc->next = pcn->next;
+ pcn->next->prev = pc;
+
+ /* Convert the function name into a label */
+
+ pbr = Safe_calloc(1,sizeof(pBranch));
+ pbr->pc = newpCodeLabel(PCF(pcn)->fname, -1);
+ pbr->next = NULL;
+ PCI(pct)->label = pBranchAppend(PCI(pct)->label,pbr);
+ PCI(pct)->label = pBranchAppend(PCI(pct)->label,PCI(pc_call)->label);
+
+ /* turn all of the return's except the last into goto's */
+ /* check case for 2 instruction pBlocks */
+ pce = findNextInstruction(pcn->next);
+ while(pce) {
+ pCode *pce_next = findNextInstruction(pce->next);
+
+ if(pce_next == NULL) {
+ /* found the last return */
+ pCode *pc_call_next = findNextInstruction(pc_call->next);
+
+ //fprintf(stderr,"found last return\n");
+ //pce->print(stderr,pce);
+ pce->prev->next = pc_call->next;
+ pc_call->next->prev = pce->prev;
+ PCI(pc_call_next)->label = pBranchAppend(PCI(pc_call_next)->label,
+ PCI(pce)->label);
+ }
+
+ pce = pce_next;
+ }
+
+
+ }
+ } else
+ fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+
+ }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* */
+/*-----------------------------------------------------------------*/
+
+void InlinepCode(void)
+{
+
+ pBlock *pb;
+ pCode *pc;
+
+ if(!the_pFile)
+ return;
+
+ if(!functionInlining)
+ return;
+
+ /* Loop through all of the function definitions and count the
+ * number of times each one is called */
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+
+ pc = setFirstItem(pb->function_calls);
+
+ for( ; pc; pc = setNextItem(pb->function_calls)) {
+
+ if(isCALL(pc)) {
+ pCode *pcn = findFunction(get_op_from_instruction(PCI(pc)));
+ if(pcn && isPCF(pcn)) {
+ PCF(pcn)->ncalled++;
+ }
+ } else
+ fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__);
+
+ }
+ }
+
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ /* Now, Loop through the function definitions again, but this
+ * time inline those functions that have only been called once. */
+
+ InlineFunction(the_pFile->pbHead);
+ //fprintf(stderr,"inlining %d\n",__LINE__);
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ unBuildFlow(pb);
+
+}