X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic%2Fpcode.c;h=1e7b0fa06c4e3c35dc380d5e4476ae883f2f0940;hb=3062f96ccb55d1d05caf9c8782f4961f87b341ce;hp=74715026521ca3a5baca915f79052ccd511884fd;hpb=7d62747bb2c0eabe49ab9833343b028f2676c5c3;p=fw%2Fsdcc diff --git a/src/pic/pcode.c b/src/pic/pcode.c index 74715026..1e7b0fa0 100644 --- a/src/pic/pcode.c +++ b/src/pic/pcode.c @@ -1,21 +1,21 @@ /*------------------------------------------------------------------------- - pcode.c - post code generation - Written By - Scott Dattalo scott@dattalo.com - - This program is free software; you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by the - Free Software Foundation; either version 2, or (at your option) any - later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + pcode.c - post code generation + Written By - Scott Dattalo scott@dattalo.com + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -------------------------------------------------------------------------*/ #include @@ -31,13 +31,7 @@ pCode *findFunction(char *fname); -static void FixRegisterBanking(pBlock *pb,int cur_bank); - -#if defined(__BORLANDC__) || defined(_MSC_VER) -#define STRCASECMP stricmp -#else -#define STRCASECMP strcasecmp -#endif +static void FixRegisterBanking(pBlock *pb); /****************************************************************/ /****************************************************************/ @@ -57,7 +51,7 @@ peepCommand peepCommands[] = { pCodeOpReg pc_status = {{PO_STATUS, "STATUS"}, -1, NULL,0,NULL}; pCodeOpReg pc_indf = {{PO_INDF, "INDF"}, -1, NULL,0,NULL}; pCodeOpReg pc_fsr = {{PO_FSR, "FSR"}, -1, NULL,0,NULL}; -pCodeOpReg pc_intcon = {{PO_INTCON, ""}, -1, NULL,0,NULL}; +pCodeOpReg pc_intcon = {{PO_INTCON, "INTCON"}, -1, NULL,0,NULL}; pCodeOpReg pc_pcl = {{PO_PCL, "PCL"}, -1, NULL,0,NULL}; pCodeOpReg pc_pclath = {{PO_PCLATH, "PCLATH"}, -1, NULL,0,NULL}; @@ -71,17 +65,21 @@ static hTab *pic14MnemonicsHash = NULL; static hTab *pic14pCodePeepCommandsHash = NULL; -static pFile *the_pFile = NULL; +pFile *the_pFile = NULL; static pBlock *pb_dead_pcodes = NULL; /* Hardcoded flags to change the behavior of the PIC port */ -static int peepOptimizing = 1; /* run the peephole optimizer if nonzero */ static int functionInlining = 1; /* inline functions if nonzero */ int debug_verbose = 0; /* Set true to inundate .asm file */ // static int GpCodeSequenceNumber = 1; int GpcFlowSeq = 1; +/* statistics (code size estimation) */ +static unsigned int pcode_insns = 0; +static unsigned int pcode_doubles = 0; + + unsigned maxIdx; /* This keeps track of the maximum register index for call tree register reuse */ unsigned peakIdx; /* This keeps track of the peak register index for call tree register reuse */ @@ -90,6 +88,7 @@ extern void RegsUnMapLiveRanges(void); extern void BuildFlowTree(pBlock *pb); extern void pCodeRegOptimizeRegUsage(int level); extern int picIsInitialized(void); +extern const char *pCodeOpType(pCodeOp *pcop); /****************************************************************/ /* Forward declarations */ @@ -118,6 +117,8 @@ pBlock *newpBlock(void); pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval); void pCodeRegMapLiveRanges(pBlock *pb); +pBranch * pBranchAppend(pBranch *h, pBranch *n); + /****************************************************************/ /* PIC Instructions */ @@ -142,7 +143,7 @@ pCodeInstruction pciADDWF = { 0, // literal operand POC_NOP, (PCC_W | PCC_REGISTER), // inCond - (PCC_REGISTER | PCC_Z) // outCond + (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond }; pCodeInstruction pciADDFW = { @@ -164,7 +165,7 @@ pCodeInstruction pciADDFW = { 0, // literal operand POC_NOP, (PCC_W | PCC_REGISTER), // inCond - (PCC_W | PCC_Z) // outCond + (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond }; pCodeInstruction pciADDLW = { @@ -273,8 +274,8 @@ pCodeInstruction pciBCF = { 0,0, // branch, skip 0, // literal operand POC_BSF, - (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond - PCC_REGISTER // outCond + (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond + (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond }; pCodeInstruction pciBSF = { @@ -295,8 +296,8 @@ pCodeInstruction pciBSF = { 0,0, // branch, skip 0, // literal operand POC_BCF, - (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond - (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond + (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond + (PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond }; pCodeInstruction pciBTFSC = { @@ -317,8 +318,8 @@ pCodeInstruction pciBTFSC = { 1,1, // branch, skip 0, // literal operand POC_BTFSS, - (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond - PCC_EXAMINE_PCOP // outCond + (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond + PCC_NONE // outCond }; pCodeInstruction pciBTFSS = { @@ -340,7 +341,7 @@ pCodeInstruction pciBTFSS = { 0, // literal operand POC_BTFSC, (PCC_REGISTER | PCC_EXAMINE_PCOP), // inCond - PCC_EXAMINE_PCOP // outCond + PCC_NONE // outCond }; pCodeInstruction pciCALL = { @@ -361,8 +362,8 @@ pCodeInstruction pciCALL = { 1,0, // branch, skip 0, // literal operand POC_NOP, - PCC_NONE, // inCond - PCC_NONE // outCond + (PCC_NONE | PCC_W), // inCond, reads argument from WREG + (PCC_NONE | PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond, flags are destroyed by called function }; pCodeInstruction pciCOMF = { @@ -384,7 +385,7 @@ pCodeInstruction pciCOMF = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_REGISTER // outCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciCOMFW = { @@ -406,7 +407,7 @@ pCodeInstruction pciCOMFW = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciCLRF = { @@ -428,7 +429,7 @@ pCodeInstruction pciCLRF = { 0, // literal operand POC_NOP, PCC_NONE, // inCond - PCC_REGISTER // outCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciCLRW = { @@ -450,7 +451,7 @@ pCodeInstruction pciCLRW = { 0, // literal operand POC_NOP, PCC_NONE, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciCLRWDT = { @@ -494,7 +495,7 @@ pCodeInstruction pciDECF = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_REGISTER // outCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciDECFW = { @@ -516,7 +517,7 @@ pCodeInstruction pciDECFW = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciDECFSZ = { @@ -536,9 +537,9 @@ pCodeInstruction pciDECFSZ = { 1,0, // dest, bit instruction 1,1, // branch, skip 0, // literal operand - POC_NOP, - PCC_REGISTER, // inCond - PCC_REGISTER // outCond + POC_DECF, // followed by BTFSC STATUS, Z --> also kills STATUS + PCC_REGISTER, // inCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciDECFSZW = { @@ -558,9 +559,9 @@ pCodeInstruction pciDECFSZW = { 0,0, // dest, bit instruction 1,1, // branch, skip 0, // literal operand - POC_NOP, + POC_DECFW, // followed by BTFSC STATUS, Z --> also kills STATUS PCC_REGISTER, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciGOTO = { @@ -604,7 +605,7 @@ pCodeInstruction pciINCF = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_REGISTER // outCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciINCFW = { @@ -626,7 +627,7 @@ pCodeInstruction pciINCFW = { 0, // literal operand POC_NOP, PCC_REGISTER, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciINCFSZ = { @@ -646,9 +647,9 @@ pCodeInstruction pciINCFSZ = { 1,0, // dest, bit instruction 1,1, // branch, skip 0, // literal operand - POC_NOP, - PCC_REGISTER, // inCond - PCC_REGISTER // outCond + POC_INCF, // followed by BTFSC STATUS, Z --> also kills STATUS + PCC_REGISTER, // inCond + PCC_REGISTER | PCC_Z // outCond }; pCodeInstruction pciINCFSZW = { @@ -668,9 +669,9 @@ pCodeInstruction pciINCFSZW = { 0,0, // dest, bit instruction 1,1, // branch, skip 0, // literal operand - POC_NOP, + POC_INCFW, // followed by BTFSC STATUS, Z --> also kills STATUS PCC_REGISTER, // inCond - PCC_W // outCond + PCC_W | PCC_Z // outCond }; pCodeInstruction pciIORWF = { @@ -866,7 +867,7 @@ pCodeInstruction pciRETFIE = { 0, // literal operand POC_NOP, PCC_NONE, // inCond - PCC_NONE // outCond (not true... affects the GIE bit too) + (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond (not true... affects the GIE bit too), STATUS bit are retored }; pCodeInstruction pciRETLW = { @@ -888,7 +889,7 @@ pCodeInstruction pciRETLW = { 1, // literal operand POC_NOP, PCC_LITERAL, // inCond - PCC_W // outCond + (PCC_W| PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETLW }; pCodeInstruction pciRETURN = { @@ -909,8 +910,8 @@ pCodeInstruction pciRETURN = { 1,0, // branch, skip 0, // literal operand POC_NOP, - PCC_NONE, // inCond - PCC_NONE // outCond + PCC_NONE | PCC_W, // inCond, return value is possibly present in W + (PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETURN }; pCodeInstruction pciRLF = { @@ -932,7 +933,7 @@ pCodeInstruction pciRLF = { 0, // literal operand POC_NOP, (PCC_C | PCC_REGISTER), // inCond - (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond + (PCC_REGISTER | PCC_C ) // outCond }; pCodeInstruction pciRLFW = { @@ -954,7 +955,7 @@ pCodeInstruction pciRLFW = { 0, // literal operand POC_NOP, (PCC_C | PCC_REGISTER), // inCond - (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond + (PCC_W | PCC_C) // outCond }; pCodeInstruction pciRRF = { @@ -976,7 +977,7 @@ pCodeInstruction pciRRF = { 0, // literal operand POC_NOP, (PCC_C | PCC_REGISTER), // inCond - (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond + (PCC_REGISTER | PCC_C) // outCond }; pCodeInstruction pciRRFW = { @@ -998,7 +999,7 @@ pCodeInstruction pciRRFW = { 0, // literal operand POC_NOP, (PCC_C | PCC_REGISTER), // inCond - (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond + (PCC_W | PCC_C) // outCond }; pCodeInstruction pciSUBWF = { @@ -1020,7 +1021,7 @@ pCodeInstruction pciSUBWF = { 0, // literal operand POC_NOP, (PCC_W | PCC_REGISTER), // inCond - (PCC_REGISTER | PCC_Z) // outCond + (PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond }; pCodeInstruction pciSUBFW = { @@ -1042,7 +1043,7 @@ pCodeInstruction pciSUBFW = { 0, // literal operand POC_NOP, (PCC_W | PCC_REGISTER), // inCond - (PCC_W | PCC_Z) // outCond + (PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond }; pCodeInstruction pciSUBLW = { @@ -1129,8 +1130,8 @@ pCodeInstruction pciTRIS = { 0,0, // branch, skip 0, // literal operand POC_NOP, - PCC_NONE, // inCond - PCC_REGISTER // outCond + PCC_NONE, // inCond /* FIXME: what's TRIS doing? */ + PCC_REGISTER // outCond /* FIXME: what's TRIS doing */ }; pCodeInstruction pciXORWF = { @@ -1196,7 +1197,7 @@ pCodeInstruction pciXORLW = { 1, // literal operand POC_NOP, (PCC_W | PCC_LITERAL), // inCond - (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond + (PCC_W | PCC_Z) // outCond }; @@ -1219,7 +1220,7 @@ pCodeInstruction pciBANKSEL = { 0, // literal operand POC_NOP, PCC_NONE, // inCond - PCC_REGISTER // outCond + PCC_NONE // outCond }; pCodeInstruction pciPAGESEL = { @@ -1241,7 +1242,7 @@ pCodeInstruction pciPAGESEL = { 0, // literal operand POC_NOP, PCC_NONE, // inCond - PCC_REGISTER // outCond + PCC_NONE // outCond }; pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS]; @@ -1254,10 +1255,8 @@ unsigned PCodeID(void) { static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */ /* static unsigned int stop; - if (pcodeId == 5801) - stop++; - if ((pcodeId >= 855)&&(pcodeId <= 856)) - stop++; + if (pcodeId == 1448) + stop++; // Place break point here */ return pcodeId++; } @@ -1330,30 +1329,37 @@ void SAFE_snprintf(char **str, size_t *size, const char *format, ...) #endif // HAVE_VSNPRINTF -extern void initStack(int base_address, int size); +extern void initStack(int base_address, int size, int shared); 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(char *); +extern regs *allocInternalRegister(int rIdx, char * name, PIC_OPTYPE po_type, int alias); +extern PIC_device *init_pic(char *); void pCodeInitRegisters(void) { static int initialized=0; - int shareBankAddress,stkSize; + int shareBankAddress, stkSize, haveShared; + PIC_device *pic; if(initialized) return; initialized = 1; - shareBankAddress = 0x7f; /* FIXME - some PIC ICs like 16C7X which do not have a shared bank need a different approach. */ - stkSize = 8; // Set pseudo stack size to 8 - initStack(shareBankAddress, stkSize); // Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters - init_pic(port->processor); - + pic = init_pic(port->processor); + haveShared = pic14_getSharedStack(NULL, &shareBankAddress, &stkSize); + /* Set pseudo stack size to SHAREBANKSIZE - 3. + * On multi memory bank ICs this leaves room for WSAVE/SSAVE/PSAVE + * (used for interrupts) to fit into the shared portion of the + * memory bank. */ + stkSize = stkSize - 3; + assert(stkSize >= 0); + initStack(shareBankAddress, stkSize, haveShared); + + /* TODO: Read aliases for SFRs from regmap lines in device description. */ pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x180); pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80); pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x180); pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x180); - pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x80); + pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x180); pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x180); pc_status.rIdx = IDX_STATUS; @@ -1363,9 +1369,12 @@ void pCodeInitRegisters(void) pc_pcl.rIdx = IDX_PCL; pc_pclath.rIdx = IDX_PCLATH; - pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */ - pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for status register. */ - pc_psave.r = allocInternalRegister(IDX_PSAVE,"PSAVE", PO_GPR_REGISTER, 0); /* Interrupt storage for pclath register. */ + /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */ + pc_wsave.r = allocInternalRegister(IDX_WSAVE,pc_wsave.pcop.name,pc_wsave.pcop.type, pic ? pic->bankMask : 0x180); + /* Interrupt storage for status register. */ + pc_ssave.r = allocInternalRegister(IDX_SSAVE,pc_ssave.pcop.name,pc_ssave.pcop.type, (pic && haveShared) ? pic->bankMask : 0); + /* Interrupt storage for pclath register. */ + pc_psave.r = allocInternalRegister(IDX_PSAVE,pc_psave.pcop.name,pc_psave.pcop.type, (pic && haveShared) ? pic->bankMask : 0); pc_wsave.rIdx = pc_wsave.r->rIdx; pc_ssave.rIdx = pc_ssave.r->rIdx; @@ -1389,7 +1398,7 @@ void pCodeInitRegisters(void) /* */ /*-----------------------------------------------------------------*/ -int mnem2key(char const *mnem) +int mnem2key(unsigned char const *mnem) { int key = 0; @@ -1473,7 +1482,7 @@ void pic14initMnemonics(void) for(i=0; imnemonic), pic14Mnemonics[i]); + hTabAddItem(&pic14MnemonicsHash, mnem2key((unsigned char *)pic14Mnemonics[i]->mnemonic), pic14Mnemonics[i]); pci = hTabFirstItem(pic14MnemonicsHash, &key); while(pci) { @@ -1490,7 +1499,7 @@ int getpCode(char *mnem,unsigned dest) { pCodeInstruction *pci; - int key = mnem2key(mnem); + int key = mnem2key((unsigned char *)mnem); if(!mnemonics_initialized) pic14initMnemonics(); @@ -1524,7 +1533,7 @@ void pic14initpCodePeepCommands(void) i = 0; do { hTabAddItem(&pic14pCodePeepCommandsHash, - mnem2key(peepCommands[i].cmd), &peepCommands[i]); + mnem2key((unsigned char *)peepCommands[i].cmd), &peepCommands[i]); i++; } while (peepCommands[i].cmd); @@ -1546,7 +1555,7 @@ int getpCodePeepCommand(char *cmd) { peepCommand *pcmd; - int key = mnem2key(cmd); + int key = mnem2key((unsigned char *)cmd); pcmd = hTabFirstItemWK(pic14pCodePeepCommandsHash, key); @@ -1594,12 +1603,12 @@ void pBlockConvert2ISR(pBlock *pb) void movepBlock2Head(char dbName) { pBlock *pb; - + if (!the_pFile) return; - + pb = the_pFile->pbHead; - + while(pb) { if(getpBlock_dbName(pb) == dbName) { @@ -1638,7 +1647,7 @@ void copypCode(FILE *of, char dbName) if(!of || !the_pFile) return; - + for(pb = the_pFile->pbHead; pb; pb = pb->next) { if(getpBlock_dbName(pb) == dbName) { pBlockStats(of,pb); @@ -1648,6 +1657,21 @@ void copypCode(FILE *of, char dbName) } } + +void resetpCodeStatistics (void) +{ + pcode_insns = pcode_doubles = 0; +} + +void dumppCodeStatistics (FILE *of) +{ + /* dump statistics */ + fprintf (of, "\n"); + fprintf (of, ";\tcode size estimation:\n"); + fprintf (of, ";\t%5u+%5u = %5u instructions (%5u byte)\n", pcode_insns, pcode_doubles, pcode_insns + pcode_doubles, 2*(pcode_insns + 2*pcode_doubles)); + fprintf (of, "\n"); +} + void pcode_test(void) { @@ -1701,16 +1725,17 @@ static int RegCond(pCodeOp *pcop) char *name = pcop->name; if (!name) name = PCOR(pcop)->r->name; - // if (strcmp(name, pc_status.pcop.name) != 0) { <<< This breaks the peep 2 optimisation - switch(PCORB(pcop)->bit) { - case PIC_C_BIT: - return PCC_C; - case PIC_DC_BIT: - return PCC_DC; - case PIC_Z_BIT: - return PCC_Z; + if (strcmp(name, pc_status.pcop.name) == 0) + { + switch(PCORB(pcop)->bit) { + case PIC_C_BIT: + return PCC_C; + case PIC_DC_BIT: + return PCC_DC; + case PIC_Z_BIT: + return PCC_Z; + } } - // } } return 0; @@ -1743,7 +1768,7 @@ pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) if(!mnemonics_initialized) pic14initMnemonics(); - + pci = Safe_calloc(1, sizeof(pCodeInstruction)); if((op>=0) && (op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) { @@ -1765,7 +1790,7 @@ pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) exit(1); return NULL; -} +} /*-----------------------------------------------------------------*/ /* newpCodeWild - create a "wild" as in wild card pCode */ @@ -1788,7 +1813,7 @@ pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_la { pCodeWild *pcw; - + pcw = Safe_calloc(1,sizeof(pCodeWild)); pcw->pci.pc.type = PC_WILD; @@ -1822,7 +1847,7 @@ pCode *newpCodeInlineP(char *cP) { pCodeComment *pcc ; - + pcc = Safe_calloc(1,sizeof(pCodeComment)); pcc->pc.type = PC_INLINE; @@ -1852,7 +1877,7 @@ pCode *newpCodeCharP(char *cP) { pCodeComment *pcc ; - + pcc = Safe_calloc(1,sizeof(pCodeComment)); pcc->pc.type = PC_COMMENT; @@ -1993,11 +2018,11 @@ pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow) /* newpCodeCSource - create a new pCode Source Symbol */ /*-----------------------------------------------------------------*/ -pCode *newpCodeCSource(int ln, char *f, char *l) +pCode *newpCodeCSource(int ln, char *f, const char *l) { pCodeCSource *pccs; - + pccs = Safe_calloc(1,sizeof(pCodeCSource)); pccs->pc.type = PC_CSOURCE; @@ -2022,6 +2047,49 @@ pCode *newpCodeCSource(int ln, char *f, char *l) return ( (pCode *)pccs); } + +/*******************************************************************/ +/* pic16_newpCodeAsmDir - create a new pCode Assembler Directive */ +/* added by VR 6-Jun-2003 */ +/*******************************************************************/ + +pCode *newpCodeAsmDir(char *asdir, char *argfmt, ...) +{ + pCodeAsmDir *pcad; + va_list ap; + char buffer[512]; + char *lbp=buffer; + + pcad = Safe_calloc(1, sizeof(pCodeAsmDir)); + pcad->pci.pc.type = PC_ASMDIR; + pcad->pci.pc.prev = pcad->pci.pc.next = NULL; + pcad->pci.pc.pb = NULL; + pcad->pci.pc.destruct = genericDestruct; + pcad->pci.pc.print = genericPrint; + + if(asdir && *asdir) { + + while(isspace((unsigned char)*asdir))asdir++; // strip any white space from the beginning + + pcad->directive = Safe_strdup( asdir ); + } + + va_start(ap, argfmt); + + memset(buffer, 0, sizeof(buffer)); + if(argfmt && *argfmt) + vsprintf(buffer, argfmt, ap); + + va_end(ap); + + while(isspace((unsigned char)*lbp))lbp++; + + if(lbp && *lbp) + pcad->arg = Safe_strdup( lbp ); + + return ((pCode *)pcad); +} + /*-----------------------------------------------------------------*/ /* pCodeLabelDestruct - free memory used by a label. */ /*-----------------------------------------------------------------*/ @@ -2043,7 +2111,7 @@ pCode *newpCodeLabel(char *name, int key) char *s = buffer; pCodeLabel *pcl; - + pcl = Safe_calloc(1,sizeof(pCodeLabel) ); pcl->pc.type = PC_LABEL; @@ -2161,12 +2229,12 @@ pCodeOp *newpCodeOpLit(int lit) pcop->name = NULL; if(lit>=0) { - sprintf(s,"0x%02x",lit); + sprintf(s,"0x%02x", (unsigned char)lit); if(s) pcop->name = Safe_strdup(s); } - ((pCodeOpLit *)pcop)->lit = lit; + ((pCodeOpLit *)pcop)->lit = (unsigned char)lit; return pcop; } @@ -2266,6 +2334,11 @@ pCodeOp *newpCodeOpBit(char *name, int ibit, int inBitSpace) sym = symFindWithName(bit, name); if (!sym) sym = symFindWithName(sfrbit, name); if (!sym) sym = symFindWithName(sfr, name); + if (!sym) sym = symFindWithName(reg, name); + // Hack to fix accesses to _INTCON_bits (e.g. GIE=0), see #1579535. + // XXX: This ignores nesting levels, but works for globals... + if (!sym) sym = findSym(SymbolTab, NULL, name); + if (!sym && name && name[0] == '_') sym = findSym(SymbolTab, NULL, &name[1]); if (sym) { r = allocNewDirReg(sym->etype,name); } @@ -2282,6 +2355,25 @@ pCodeOp *newpCodeOpBit(char *name, int ibit, int inBitSpace) return pcop; } +#if 0 +pCodeOp *newpCodeOpBitReg(regs *reg, int ibit, int inBitSpace) +{ + pCodeOp *pcop; + + assert(reg); + + pcop = Safe_calloc(1,sizeof(pCodeOpRegBit)); + pcop->name = reg->name; + pcop->type = PO_GPR_BIT; + PCORB(pcop)->bit = ibit; + PCORB(pcop)->inBitSpace = inBitSpace; + PCOR(pcop)->r = reg; + PCOR(pcop)->index = 0; + PCOR(pcop)->rIdx = reg->rIdx; + return pcop; +} +#endif + /*-----------------------------------------------------------------* * pCodeOp *newpCodeOpReg(int rIdx) - allocate a new register * @@ -2395,6 +2487,7 @@ pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type) void pCodeConstString(char *name, char *value) { pBlock *pb; + unsigned i; // fprintf(stderr, " %s %s %s\n",__FUNCTION__,name,value); @@ -2406,6 +2499,15 @@ void pCodeConstString(char *name, char *value) addpBlock(pb); sprintf(buffer,"; %s = %s",name,value); + for (i=strlen(buffer); i--; ) { + unsigned char c = buffer[i]; + if (c=='\r' || c=='\n') { + memmove(buffer+i+1,buffer+i,strlen(buffer)-i+1); + buffer[i] = '\\'; + if (c=='\r') buffer[i+1] = 'r'; + else if (c=='\n') buffer[i+1] = 'n'; + } + } addpCode2pBlock(pb,newpCodeCharP(buffer)); addpCode2pBlock(pb,newpCodeLabel(name,-1)); @@ -2556,9 +2658,19 @@ void printpBlock(FILE *of, pBlock *pb) if(!of) of = stderr; - for(pc = pb->pcHead; pc; pc = pc->next) + for(pc = pb->pcHead; pc; pc = pc->next) { printpCode(of,pc); - + + if (isPCI(pc)) + { + if (isPCI(pc) && (PCI(pc)->op == POC_PAGESEL || PCI(pc)->op == POC_BANKSEL)) { + pcode_doubles++; + } else { + pcode_insns++; + } + } + } // for + } /*-----------------------------------------------------------------*/ @@ -2582,7 +2694,20 @@ void unlinkpCode(pCode *pc) pc->prev->next = pc->next; if(pc->next) pc->next->prev = pc->prev; - + +#if 0 + /* RN: I believe this should be right here, but this did not + * cure the bug I was hunting... */ + /* must keep labels -- attach to following instruction */ + if (isPCI(pc) && PCI(pc)->label && pc->next) + { + pCodeInstruction *pcnext = PCI(findNextInstruction (pc->next)); + if (pcnext) + { + pBranchAppend (pcnext->label, PCI(pc)->label); + } + } +#endif pc->prev = pc->next = NULL; } } @@ -2694,13 +2819,53 @@ pCodeOp *pCodeOpCopy(pCodeOp *pcop) return NULL; switch(pcop->type) { + case PO_NONE: + case PO_STR: + pcopnew = Safe_calloc (1, sizeof (pCodeOp)); + memcpy (pcopnew, pcop, sizeof (pCodeOp)); + break; + + case PO_W: + case PO_STATUS: + case PO_FSR: + case PO_INDF: + case PO_INTCON: + case PO_GPR_REGISTER: + case PO_GPR_TEMP: + case PO_GPR_POINTER: + case PO_SFR_REGISTER: + case PO_PCL: + case PO_PCLATH: + case PO_DIR: + //DFPRINTF((stderr,"pCodeOpCopy GPR register\n")); + pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) ); + memcpy (pcopnew, pcop, sizeof (pCodeOpReg)); + DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx)); + break; + + case PO_LITERAL: + //DFPRINTF((stderr,"pCodeOpCopy lit\n")); + pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) ); + memcpy (pcopnew, pcop, sizeof (pCodeOpLit)); + break; + + case PO_IMMEDIATE: + pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) ); + memcpy (pcopnew, pcop, sizeof (pCodeOpImmd)); + break; + + case PO_GPR_BIT: case PO_CRY: case PO_BIT: //DFPRINTF((stderr,"pCodeOpCopy bit\n")); pcopnew = Safe_calloc(1,sizeof(pCodeOpRegBit) ); - PCORB(pcopnew)->bit = PCORB(pcop)->bit; - PCORB(pcopnew)->inBitSpace = PCORB(pcop)->inBitSpace; - + memcpy (pcopnew, pcop, sizeof (pCodeOpRegBit)); + break; + + case PO_LABEL: + //DFPRINTF((stderr,"pCodeOpCopy label\n")); + pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) ); + memcpy (pcopnew, pcop, sizeof(pCodeOpLabel)); break; case PO_WILD: @@ -2718,72 +2883,12 @@ pCodeOp *pCodeOpCopy(pCodeOp *pcop) return pcopnew; break; - - case PO_LABEL: - //DFPRINTF((stderr,"pCodeOpCopy label\n")); - pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) ); - PCOLAB(pcopnew)->key = PCOLAB(pcop)->key; - break; - - case PO_IMMEDIATE: - pcopnew = Safe_calloc(1,sizeof(pCodeOpImmd) ); - PCOI(pcopnew)->index = PCOI(pcop)->index; - PCOI(pcopnew)->offset = PCOI(pcop)->offset; - PCOI(pcopnew)->_const = PCOI(pcop)->_const; - PCOI(pcopnew)->_function = PCOI(pcop)->_function; - break; - - case PO_LITERAL: - //DFPRINTF((stderr,"pCodeOpCopy lit\n")); - pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) ); - PCOL(pcopnew)->lit = PCOL(pcop)->lit; - break; - - case PO_GPR_BIT: - - pcopnew = newpCodeOpBit(pcop->name, PCORB(pcop)->bit,PCORB(pcop)->inBitSpace); - PCOR(pcopnew)->r = PCOR(pcop)->r; - PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx; - DFPRINTF((stderr," pCodeOpCopy Bit -register index\n")); - return pcopnew; - break; - - case PO_GPR_POINTER: - case PO_GPR_REGISTER: - case PO_GPR_TEMP: - case PO_FSR: - case PO_INDF: - //DFPRINTF((stderr,"pCodeOpCopy GPR register\n")); - pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) ); - PCOR(pcopnew)->r = PCOR(pcop)->r; - PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx; - PCOR(pcopnew)->instance = PCOR(pcop)->instance; - DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx)); - break; - - case PO_DIR: - //fprintf(stderr,"pCodeOpCopy PO_DIR\n"); - pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) ); - PCOR(pcopnew)->r = PCOR(pcop)->r; - PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx; - PCOR(pcopnew)->instance = PCOR(pcop)->instance; + + default: + assert ( !"unhandled pCodeOp type copied" ); break; - case PO_STATUS: - DFPRINTF((stderr,"pCodeOpCopy PO_STATUS\n")); - case PO_SFR_REGISTER: - case PO_STR: - case PO_NONE: - case PO_W: - case PO_INTCON: - case PO_PCL: - case PO_PCLATH: - - //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type)); - pcopnew = Safe_calloc(1,sizeof(pCodeOp) ); - - } + } // switch - pcopnew->type = pcop->type; if(pcop->name) pcopnew->name = Safe_strdup(pcop->name); else @@ -2807,10 +2912,14 @@ pCodeOp *popCopyReg(pCodeOpReg *pc) } else pcor->pcop.name = NULL; - pcor->r = pc->r; - pcor->rIdx = pc->rIdx; - pcor->r->wasUsed=1; - + if (pcor->pcop.type == PO_IMMEDIATE){ + PCOL(pcor)->lit = PCOL(pc)->lit; + } else { + pcor->r = pc->r; + pcor->rIdx = pc->rIdx; + if (pcor->r) + pcor->r->wasUsed=1; + } //DEBUGpic14_emitcode ("; ***","%s , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx); return PCOP(pcor); @@ -2908,83 +3017,105 @@ char *get_op(pCodeOp *pcop,char *buffer, size_t size) case PO_IMMEDIATE: s = buffer; - if(PCOI(pcop)->_const) { - if( PCOI(pcop)->offset && PCOI(pcop)->offset<4) { + if( PCOI(pcop)->offset >= 0 && PCOI(pcop)->offset<4) { switch(PCOI(pcop)->offset) { case 0: - SAFE_snprintf(&s,&size,"low %s",pcop->name); + SAFE_snprintf(&s,&size,"low (%s+%d)",pcop->name, PCOI(pcop)->index); break; case 1: - SAFE_snprintf(&s,&size,"high %s",pcop->name); + SAFE_snprintf(&s,&size,"high (%s+%d)",pcop->name, PCOI(pcop)->index); + break; + case 2: + SAFE_snprintf(&s,&size,"0x%02x",PCOI(pcop)->_const ? GPTRTAG_CODE : GPTRTAG_DATA); break; default: + fprintf (stderr, "PO_IMMEDIATE/_const/offset=%d\n", PCOI(pcop)->offset); + assert ( !"offset too large" ); SAFE_snprintf(&s,&size,"(((%s+%d) >> %d)&0xff)", pcop->name, PCOI(pcop)->index, 8 * PCOI(pcop)->offset ); } } else - SAFE_snprintf(&s,&size,"LOW(%s+%d)",pcop->name,PCOI(pcop)->index); + SAFE_snprintf(&s,&size,"LOW (%s+%d)",pcop->name,PCOI(pcop)->index); } else { - - if( PCOI(pcop)->index) { // && PCOI(pcc->pcop)->offset<4) { + if( !PCOI(pcop)->offset) { // && PCOI(pcc->pcop)->offset<4) SAFE_snprintf(&s,&size,"(%s + %d)", pcop->name, - PCOI(pcop)->index ); + PCOI(pcop)->index); } else { switch(PCOI(pcop)->offset) { case 0: - SAFE_snprintf(&s,&size,"%s",pcop->name); + SAFE_snprintf(&s,&size,"(%s + %d)",pcop->name, PCOI(pcop)->index); break; case 1: - SAFE_snprintf(&s,&size,"high %s",pcop->name); + SAFE_snprintf(&s,&size,"high (%s + %d)",pcop->name, PCOI(pcop)->index); + break; + case 2: + SAFE_snprintf(&s,&size,"0x%02x",PCOI(pcop)->_const ? GPTRTAG_CODE : GPTRTAG_DATA); break; default: - SAFE_snprintf(&s,&size,"(%s >> %d)&0xff",pcop->name, 8*PCOI(pcop)->offset); + fprintf (stderr, "PO_IMMEDIATE/mutable/offset=%d\n", PCOI(pcop)->offset); + assert ( !"offset too large" ); + SAFE_snprintf(&s,&size,"((%s + %d) >> %d)&0xff",pcop->name, PCOI(pcop)->index, 8*PCOI(pcop)->offset); + break; } } } 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 (pcop->name) { - if(use_buffer) { - SAFE_snprintf(&buffer,&size,"%s",pcop->name); - return buffer; - } - return pcop->name; - } - + 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; + + case PO_GPR_BIT: + if(PCOR(pcop)->r) { + if(use_buffer) { + SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name); + return buffer; + } + return PCOR(pcop)->r->name; + } + + /* fall through to the default case */ + default: + if(pcop->name) { + if(use_buffer) { + SAFE_snprintf(&buffer,&size,"%s",pcop->name); + return buffer; + } + return pcop->name; + } } } - + + printf("PIC port internal warning: (%s:%d(%s)) %s not found\n", + __FILE__, __LINE__, __FUNCTION__, + pCodeOpType(pcop)); + return "NO operand"; - + } /*-----------------------------------------------------------------*/ @@ -2992,12 +3123,9 @@ char *get_op(pCodeOp *pcop,char *buffer, size_t size) static char *get_op_from_instruction( pCodeInstruction *pcc) { - if(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"); } @@ -3006,220 +3134,260 @@ static char *get_op_from_instruction( pCodeInstruction *pcc) /*-----------------------------------------------------------------*/ static void pCodeOpPrint(FILE *of, pCodeOp *pcop) { - fprintf(of,"pcodeopprint- not implemented\n"); } /*-----------------------------------------------------------------*/ +/* pCode2str - convert a pCode instruction to string */ /*-----------------------------------------------------------------*/ char *pCode2str(char *str, size_t size, pCode *pc) { - char *s = str; + char *s = str; + + switch(pc->type) { + + case PC_OPCODE: + + SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic); + + if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) { + + if(PCI(pc)->isBitInst) { + if(PCI(pc)->pcop->type == PO_GPR_BIT) { + char *name = PCI(pc)->pcop->name; + if (!name) + name = PCOR(PCI(pc)->pcop)->r->name; + if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) ) + SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name); + else + SAFE_snprintf(&s,&size,"%s,%d", name, + (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7); + } else if(PCI(pc)->pcop->type == PO_GPR_BIT) { + SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit); + } else + SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc))); + //PCI(pc)->pcop->t.bit ); + } else { + if(PCI(pc)->pcop->type == PO_GPR_BIT) { + if( PCI(pc)->num_ops == 2) + SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W')); + else + SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc))); + } else { + SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc))); + if( PCI(pc)->num_ops == 2) + SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W')); + } + } + } + break; + + case PC_COMMENT: + /* assuming that comment ends with a \n */ + SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment); + break; + + case PC_INLINE: + /* assuming that inline code ends with a \n */ + SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment); + break; + + case PC_LABEL: + SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key); + break; + case PC_FUNCTION: + SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname); + break; + case PC_WILD: + SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id); + break; + case PC_FLOW: + SAFE_snprintf(&s,&size,";\t--FLOW change\n"); + break; + case PC_CSOURCE: +// SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line); + SAFE_snprintf(&s,&size,"%s\t.line\t%d; \"%s\"\t%s\n",(options.debug?"":";"),PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line); + break; + case PC_ASMDIR: + if(PCAD(pc)->directive) { + SAFE_snprintf(&s,&size,"\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:""); + } else if(PCAD(pc)->arg) { + /* special case to handle inline labels without a tab */ + SAFE_snprintf(&s,&size,"%s\n", PCAD(pc)->arg); + } + break; + + case PC_BAD: + SAFE_snprintf(&s,&size,";A bad pCode is being used\n"); + } + + return str; +} + +/*-----------------------------------------------------------------*/ +/* genericPrint - the contents of a pCode to a file */ +/*-----------------------------------------------------------------*/ +static void genericPrint(FILE *of, pCode *pc) +{ + if(!pc || !of) + return; + + switch(pc->type) { + case PC_COMMENT: + fprintf(of,";%s\n", ((pCodeComment *)pc)->comment); + break; + + case PC_INLINE: + fprintf(of,"%s\n", ((pCodeComment *)pc)->comment); + break; + + case PC_OPCODE: + // If the opcode has a label, print that first + { + char str[256]; + pCodeInstruction *pci = PCI(pc); + pBranch *pbl = pci->label; + while(pbl && pbl->pc) { + if(pbl->pc->type == PC_LABEL) + pCodePrintLabel(of, pbl->pc); + pbl = pbl->next; + } + + if(pci->cline) + genericPrint(of,PCODE(pci->cline)); + + + pCode2str(str, 256, pc); + + fprintf(of,"%s",str); + + /* Debug */ + if(debug_verbose) { + pCodeOpReg *pcor = PCOR(pci->pcop); + fprintf(of, "\t;id=%u,key=%03x,inCond:%x,outCond:%x",pc->id,pc->seq, pci->inCond, pci->outCond); + if(pci->pcflow) + fprintf(of,",flow seq=%03x",pci->pcflow->pc.seq); + if (pcor && pcor->pcop.type==PO_GPR_TEMP && !pcor->r->isFixed) + fprintf(of,",rIdx=r0x%X",pcor->rIdx); + } + } +#if 0 + { + pBranch *dpb = pc->to; // debug + while(dpb) { + switch ( dpb->pc->type) { + case PC_OPCODE: + fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic); + break; + case PC_LABEL: + fprintf(of, "\t;label %d", PCL(dpb->pc)->key); + break; + case PC_FUNCTION: + fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]")); + break; + case PC_FLOW: + fprintf(of, "\t;flow"); + break; + case PC_COMMENT: + case PC_WILD: + break; + } + dpb = dpb->next; + } + } +#endif + fprintf(of,"\n"); + break; + + case PC_WILD: + fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id); + if(PCW(pc)->pci.label) + pCodePrintLabel(of, PCW(pc)->pci.label->pc); + + if(PCW(pc)->operand) { + fprintf(of,";\toperand "); + pCodeOpPrint(of,PCW(pc)->operand ); + } + break; + + case PC_FLOW: + if(debug_verbose) { + fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq); + if(PCFL(pc)->ancestor) + fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq); + fprintf(of,"\n"); + fprintf(of,"; from: "); + { + pCodeFlowLink *link; + for (link = setFirstItem(PCFL(pc)->from); link; link = setNextItem (PCFL(pc)->from)) + { + fprintf(of,"%03x ",link->pcflow->pc.seq); + } + } + fprintf(of,"; to: "); + { + pCodeFlowLink *link; + for (link = setFirstItem(PCFL(pc)->to); link; link = setNextItem (PCFL(pc)->to)) + { + fprintf(of,"%03x ",link->pcflow->pc.seq); + } + } + fprintf(of,"\n"); + } + break; + + case PC_CSOURCE: +// fprintf(of,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line); + fprintf(of,"%s\t.line\t%d; \"%s\"\t%s\n", (options.debug?"":";"), PCCS(pc)->line_number, PCCS(pc)->file_name, PCCS(pc)->line); + break; + + case PC_ASMDIR: + { + pBranch *pbl = PCAD(pc)->pci.label; + while(pbl && pbl->pc) { + if(pbl->pc->type == PC_LABEL) + pCodePrintLabel(of, pbl->pc); + pbl = pbl->next; + } + } + if(PCAD(pc)->directive) { + fprintf(of, "\t%s%s%s\n", PCAD(pc)->directive, PCAD(pc)->arg?"\t":"", PCAD(pc)->arg?PCAD(pc)->arg:""); + } else + if(PCAD(pc)->arg) { + /* special case to handle inline labels without tab */ + fprintf(of, "%s\n", PCAD(pc)->arg); + } + break; + + case PC_LABEL: + default: + fprintf(of,"unknown pCode type %d\n",pc->type); + } +} + +/*-----------------------------------------------------------------*/ +/* pCodePrintFunction - prints function begin/end */ +/*-----------------------------------------------------------------*/ + +static void pCodePrintFunction(FILE *of, pCode *pc) +{ - switch(pc->type) { - - case PC_OPCODE: - - SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic); - - if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) { - - if(PCI(pc)->isBitInst) { - if(PCI(pc)->pcop->type == PO_GPR_BIT) { - char *name = PCI(pc)->pcop->name; - if (!name) - name = PCOR(PCI(pc)->pcop)->r->name; - if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) ) - SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", name, name); - else - SAFE_snprintf(&s,&size,"%s,%d", name, - (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7); - } else if(PCI(pc)->pcop->type == PO_GPR_BIT) { - SAFE_snprintf(&s,&size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit); - }else - SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc))); - //PCI(pc)->pcop->t.bit ); - } else { - - if(PCI(pc)->pcop->type == PO_GPR_BIT) { - if( PCI(pc)->num_ops == 2) - SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W')); - else - SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc))); - - }else { - SAFE_snprintf(&s,&size,"%s",get_op_from_instruction(PCI(pc))); - - if( PCI(pc)->num_ops == 2) - SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W')); - } - } - - } - break; - - case PC_COMMENT: - /* assuming that comment ends with a \n */ - SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment); - break; - - case PC_INLINE: - /* assuming that inline code ends with a \n */ - SAFE_snprintf(&s,&size,"%s", ((pCodeComment *)pc)->comment); - break; - - case PC_LABEL: - SAFE_snprintf(&s,&size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key); - break; - case PC_FUNCTION: - SAFE_snprintf(&s,&size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname); - break; - case PC_WILD: - SAFE_snprintf(&s,&size,";\tWild opcode: id=%d\n",PCW(pc)->id); - break; - case PC_FLOW: - SAFE_snprintf(&s,&size,";\t--FLOW change\n"); - break; - case PC_CSOURCE: - SAFE_snprintf(&s,&size,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line); - break; - - case PC_BAD: - SAFE_snprintf(&s,&size,";A bad pCode is being used\n"); - } - - return str; - -} - -/*-----------------------------------------------------------------*/ -/* genericPrint - the contents of a pCode to a file */ -/*-----------------------------------------------------------------*/ -static void genericPrint(FILE *of, pCode *pc) -{ - - if(!pc || !of) - return; - - switch(pc->type) { - case PC_COMMENT: - fprintf(of,";%s\n", ((pCodeComment *)pc)->comment); - break; - - case PC_INLINE: - fprintf(of,"%s\n", ((pCodeComment *)pc)->comment); - break; - - case PC_OPCODE: - // If the opcode has a label, print that first - { - pBranch *pbl = PCI(pc)->label; - while(pbl && pbl->pc) { - if(pbl->pc->type == PC_LABEL) - pCodePrintLabel(of, pbl->pc); - pbl = pbl->next; - } - } - - if(PCI(pc)->cline) - genericPrint(of,PCODE(PCI(pc)->cline)); - - { - char str[256]; - - pCode2str(str, 256, pc); - - fprintf(of,"%s",str); - - /* Debug */ - if(debug_verbose) { - fprintf(of, "\t;id=%u,key=%03x",pc->id,pc->seq); - if(PCI(pc)->pcflow) - fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq); - } - } -#if 0 - { - pBranch *dpb = pc->to; // debug - while(dpb) { - switch ( dpb->pc->type) { - case PC_OPCODE: - fprintf(of, "\t;%s", PCI(dpb->pc)->mnemonic); - break; - case PC_LABEL: - fprintf(of, "\t;label %d", PCL(dpb->pc)->key); - break; - case PC_FUNCTION: - fprintf(of, "\t;function %s", ( (PCF(dpb->pc)->fname) ? (PCF(dpb->pc)->fname) : "[END]")); - break; - case PC_FLOW: - fprintf(of, "\t;flow"); - break; - case PC_COMMENT: - case PC_WILD: - break; - } - dpb = dpb->next; - } - } -#endif - fprintf(of,"\n"); - break; - - case PC_WILD: - fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id); - if(PCW(pc)->pci.label) - pCodePrintLabel(of, PCW(pc)->pci.label->pc); - - if(PCW(pc)->operand) { - fprintf(of,";\toperand "); - pCodeOpPrint(of,PCW(pc)->operand ); - } - break; - - case PC_FLOW: - if(debug_verbose) { - fprintf(of,";<>Start of new flow, seq=0x%x",pc->seq); - if(PCFL(pc)->ancestor) - fprintf(of," ancestor = 0x%x", PCODE(PCFL(pc)->ancestor)->seq); - fprintf(of,"\n"); - - } - break; - - case PC_CSOURCE: - fprintf(of,";#CSRC\t%s %d\n; %s\n", PCCS(pc)->file_name, PCCS(pc)->line_number, PCCS(pc)->line); - break; - case PC_LABEL: - default: - fprintf(of,"unknown pCode type %d\n",pc->type); - } - -} - -/*-----------------------------------------------------------------*/ -/* pCodePrintFunction - prints function begin/end */ -/*-----------------------------------------------------------------*/ - -static void pCodePrintFunction(FILE *of, pCode *pc) -{ - - if(!pc || !of) - return; - - if( ((pCodeFunction *)pc)->modname) - fprintf(of,"F_%s",((pCodeFunction *)pc)->modname); - - if(PCF(pc)->fname) { - pBranch *exits = PCF(pc)->to; - int i=0; - fprintf(of,"%s\t;Function start\n",PCF(pc)->fname); - while(exits) { - i++; - exits = exits->next; - } - //if(i) i--; - fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s')); + if(!pc || !of) + return; + + if( ((pCodeFunction *)pc)->modname) + fprintf(of,"F_%s",((pCodeFunction *)pc)->modname); + + if(PCF(pc)->fname) { + pBranch *exits = PCF(pc)->to; + int i=0; + fprintf(of,"%s\t;Function start\n",PCF(pc)->fname); + while(exits) { + i++; + exits = exits->next; + } + //if(i) i--; + fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s')); }else { if((PCF(pc)->from && @@ -3248,47 +3416,45 @@ static void pCodePrintLabel(FILE *of, pCode *pc) fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key); } + /*-----------------------------------------------------------------*/ /* unlinkpCodeFromBranch - Search for a label in a pBranch and */ /* remove it if it is found. */ /*-----------------------------------------------------------------*/ static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc) { - pBranch *b, *bprev; - - - bprev = NULL; - - if(pcl->type == PC_OPCODE) - b = PCI(pcl)->label; - else { - fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__); - exit(1); - - } - - //fprintf (stderr, "%s \n",__FUNCTION__); - //pcl->print(stderr,pcl); - //pc->print(stderr,pc); - while(b) { - if(b->pc == pc) { - //fprintf (stderr, "found label\n"); - - /* Found a label */ - if(bprev) { - bprev->next = b->next; /* Not first pCode in chain */ - free(b); - } else { - pc->destruct(pc); - PCI(pcl)->label = b->next; /* First pCode in chain */ - free(b); - } - return; /* A label can't occur more than once */ - } - bprev = b; - b = b->next; - } - + pBranch *b, *bprev; + + bprev = NULL; + + if(pcl->type == PC_OPCODE || pcl->type == PC_INLINE || pcl->type == PC_ASMDIR) + b = PCI(pcl)->label; + else { + fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__); + exit(1); + } + + //fprintf (stderr, "%s \n",__FUNCTION__); + //pcl->print(stderr,pcl); + //pc->print(stderr,pc); + while(b) { + if(b->pc == pc) { + //fprintf (stderr, "found label\n"); + + /* Found a label */ + if(bprev) { + bprev->next = b->next; /* Not first pCode in chain */ + free(b); + } else { + pc->destruct(pc); + PCI(pcl)->label = b->next; /* First pCode in chain */ + free(b); + } + return; /* A label can't occur more than once */ + } + bprev = b; + b = b->next; + } } /*-----------------------------------------------------------------*/ @@ -3395,7 +3561,7 @@ static void pCodeUnlink(pCode *pc) if(pc->to->next) pBranchAppend(pb2, pc->to->next); } - + pb1 = pb1->next; } @@ -3448,24 +3614,24 @@ static void genericAnalyze(pCode *pc) /*-----------------------------------------------------------------*/ int compareLabel(pCode *pc, pCodeOpLabel *pcop_label) { - pBranch *pbr; - - if(pc->type == PC_LABEL) { - if( ((pCodeLabel *)pc)->key == pcop_label->key) - return TRUE; - } - if(pc->type == PC_OPCODE) { - pbr = PCI(pc)->label; - while(pbr) { - if(pbr->pc->type == PC_LABEL) { - if( ((pCodeLabel *)(pbr->pc))->key == pcop_label->key) - return TRUE; - } - pbr = pbr->next; - } - } - - return FALSE; + pBranch *pbr; + + if(pc->type == PC_LABEL) { + if( ((pCodeLabel *)pc)->key == pcop_label->key) + return TRUE; + } + if(pc->type == PC_OPCODE || pc->type == PC_ASMDIR) { + pbr = PCI(pc)->label; + while(pbr) { + if(pbr->pc->type == PC_LABEL) { + if( ((pCodeLabel *)(pbr->pc))->key == pcop_label->key) + return TRUE; + } + pbr = pbr->next; + } + } + + return FALSE; } /*-----------------------------------------------------------------*/ @@ -3520,7 +3686,7 @@ pCode * findLabel(pCodeOpLabel *pcop_label) return pc; } - fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name); + fprintf(stderr,"Couldn't find label %s\n", pcop_label->pcop.name); return NULL; } @@ -3549,35 +3715,44 @@ pCode * findPrevpCode(pCode *pc, PC_TYPE pct) { while(pc) { - if(pc->type == pct) + if(pc->type == pct) { + /* + static unsigned int stop; + if (pc->id == 524) + stop++; // Place break point here + */ return pc; + } pc = pc->prev; } return NULL; } + /*-----------------------------------------------------------------*/ /* findNextInstruction - given a pCode, find the next instruction */ /* in the linked list */ /*-----------------------------------------------------------------*/ pCode * findNextInstruction(pCode *pci) { - pCode *pc = pci; - - while(pc) { - if((pc->type == PC_OPCODE) || (pc->type == PC_WILD)) - return pc; - + pCode *pc = pci; + + while(pc) { + if((pc->type == PC_OPCODE) + || (pc->type == PC_WILD) + || (pc->type == PC_ASMDIR)) + return pc; + #ifdef PCODE_DEBUG - fprintf(stderr,"findNextInstruction: "); - printpCode(stderr, pc); + fprintf(stderr,"findNextInstruction: "); + printpCode(stderr, pc); #endif - pc = pc->next; - } - - //fprintf(stderr,"Couldn't find instruction\n"); - return NULL; + pc = pc->next; + } + + //fprintf(stderr,"Couldn't find instruction\n"); + return NULL; } /*-----------------------------------------------------------------*/ @@ -3586,7 +3761,25 @@ pCode * findNextInstruction(pCode *pci) /*-----------------------------------------------------------------*/ pCode * findPrevInstruction(pCode *pci) { - return findPrevpCode(pci, PC_OPCODE); + pCode *pc = pci; + + while(pc) { + + if((pc->type == PC_OPCODE) + || (pc->type == PC_WILD) + || (pc->type == PC_ASMDIR)) + return pc; + + +#ifdef PCODE_DEBUG + fprintf(stderr,"pic16_findPrevInstruction: "); + printpCode(stderr, pc); +#endif + pc = pc->prev; + } + + //fprintf(stderr,"Couldn't find instruction\n"); + return NULL; } /*-----------------------------------------------------------------*/ @@ -3595,7 +3788,6 @@ pCode * findPrevInstruction(pCode *pci) /*-----------------------------------------------------------------*/ pCode * findFunctionEnd(pCode *pc) { - while(pc) { if(pc->type == PC_FUNCTION && !(PCF(pc)->fname)) return pc; @@ -3649,7 +3841,7 @@ static void AnalyzeRETURN(pCode *pc) /*-----------------------------------------------------------------*/ regs * getRegFromInstruction(pCode *pc) { - + regs *r; if(!pc || !isPCI(pc) || !PCI(pc)->pcop || @@ -3657,39 +3849,35 @@ regs * getRegFromInstruction(pCode *pc) return NULL; switch(PCI(pc)->pcop->type) { - case PO_INDF: + case PO_STATUS: case PO_FSR: - return PCOR(PCI(pc)->pcop)->r; - - // return typeRegWithIdx (PCOR(PCI(pc)->pcop)->rIdx, REG_SFR, 0); - + case PO_INDF: + case PO_INTCON: case PO_BIT: case PO_GPR_TEMP: - //fprintf(stderr, "getRegFromInstruction - bit or temp\n"); - return PCOR(PCI(pc)->pcop)->r; - - case PO_IMMEDIATE: - if(PCOI(PCI(pc)->pcop)->r) - return (PCOI(PCI(pc)->pcop)->r); - - //fprintf(stderr, "getRegFromInstruction - immediate\n"); - return dirregWithName(PCI(pc)->pcop->name); - //return NULL; // PCOR(PCI(pc)->pcop)->r; - - case PO_GPR_BIT: + case PO_SFR_REGISTER: + case PO_PCL: + case PO_PCLATH: return PCOR(PCI(pc)->pcop)->r; - + case PO_GPR_REGISTER: + case PO_GPR_BIT: case PO_DIR: - //fprintf(stderr, "getRegFromInstruction - dir\n"); - return PCOR(PCI(pc)->pcop)->r; + r = PCOR(PCI(pc)->pcop)->r; + if (r) + return r; + return dirregWithName(PCI(pc)->pcop->name); + case PO_LITERAL: - //fprintf(stderr, "getRegFromInstruction - literal\n"); break; + case PO_IMMEDIATE: + r = PCOI(PCI(pc)->pcop)->r; + if (r) + return r; + return dirregWithName(PCI(pc)->pcop->name); + default: - //fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type); - //genericPrint(stderr, pc); break; } @@ -3813,14 +4001,38 @@ void BuildFlow(pBlock *pb) PCI(pc)->pcflow = PCFL(pflow); //fprintf(stderr," build: "); + //pc->print(stderr, pc); //pflow->print(stderr,pflow); - if( PCI(pc)->isSkip) { + if (checkLabel(pc)) { + + /* This instruction marks the beginning of a + * new flow segment */ + + pc->seq = 0; + seq = 1; + + /* If the previous pCode is not a flow object, then + * insert a new flow object. (This check prevents + * two consecutive flow objects from being insert in + * the case where a skip instruction preceeds an + * instruction containing a label.) */ + + last_pci = findPrevInstruction (pc->prev); + + if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow))) + InsertpFlow(last_pci, &pflow); + + PCI(pc)->pcflow = PCFL(pflow); + + } + + if(isPCI_SKIP(pc)) { /* The two instructions immediately following this one * mark the beginning of a new flow segment */ - while(pc && PCI(pc)->isSkip) { + while(pc && isPCI_SKIP(pc)) { PCI(pc)->pcflow = PCFL(pflow); pc->seq = seq-1; @@ -3839,31 +4051,13 @@ void BuildFlow(pBlock *pb) pc->seq = 0; InsertpFlow(pc, &pflow); - } else if ( PCI(pc)->isBranch && !checkLabel(findNextInstruction(pc->next))) { + } else if ( isPCI_BRANCH(pc) && !checkLabel(findNextInstruction(pc->next))) { InsertpFlow(pc, &pflow); seq = 0; - } else if (checkLabel(pc)) { - - /* This instruction marks the beginning of a - * new flow segment */ - - pc->seq = 0; - seq = 1; - - /* If the previous pCode is not a flow object, then - * insert a new flow object. (This check prevents - * two consecutive flow objects from being insert in - * the case where a skip instruction preceeds an - * instruction containing a label.) */ - - if(last_pci && (PCI(last_pci)->pcflow == PCFL(pflow))) - InsertpFlow(findPrevInstruction(pc->prev), &pflow); - - PCI(pc)->pcflow = PCFL(pflow); - } + last_pci = pc; pc = pc->next; } @@ -4029,8 +4223,8 @@ static int isBankInstruction(pCode *pc) } } - } - + } + return bank; } */ @@ -4056,24 +4250,24 @@ static void FillFlow(pCodeFlow *pcflow) } cur_bank = -1; - + 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); - * / + 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); + * / } */ @@ -4082,7 +4276,17 @@ static void FillFlow(pCodeFlow *pcflow) void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to) { pCodeFlowLink *fromLink, *toLink; - +#if 0 + fprintf(stderr, "%s: linking ", __FUNCTION__ ); + if (from) from->pc.print(stderr, &from->pc); + else fprintf(stderr, "(null)"); + fprintf(stderr, " -(%u)-> with -(%u)-> ", + from && from->pcflow ? from->pcflow->pc.seq : 0, + to && to->pcflow ? to->pcflow->pc.seq : 0); + if (to) to->pc.print(stderr, &to->pc); + else fprintf(stderr, "(null)"); +#endif + if(!from || !to || !to->pcflow || !from->pcflow) return; @@ -4123,9 +4327,16 @@ void LinkFlow(pBlock *pb) //FillFlow(PCFL(pcflow)); - pc = PCFL(pcflow)->end; + /* find last instruction in flow */ + pc = findPrevInstruction (PCFL(pcflow)->end); + if (!pc) { + fprintf(stderr, "%s: flow without end (%u)?\n", + __FUNCTION__, pcflow->seq ); + continue; + } //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq); + //pc->print(stderr, pc); if(isPCI_SKIP(pc)) { //fprintf(stderr, "ends with skip\n"); //pc->print(stderr,pc); @@ -4141,23 +4352,27 @@ void LinkFlow(pBlock *pb) //fprintf(stderr, "ends with branch\n "); //pc->print(stderr,pc); - + if(!(pcol && isPCOLAB(pcol))) { - if((PCI(pc)->op != POC_RETLW) && (PCI(pc)->op != POC_RETURN) && (PCI(pc)->op != POC_CALL) && (PCI(pc)->op != POC_RETFIE) ) { + if((PCI(pc)->op != POC_RETLW) + && (PCI(pc)->op != POC_RETURN) + && (PCI(pc)->op != POC_CALL) + && (PCI(pc)->op != POC_RETFIE) ) + { pc->print(stderr,pc); fprintf(stderr, "ERROR: %s, branch instruction doesn't have label\n",__FUNCTION__); } - continue; - } - - if( (pct = findLabelinpBlock(pb,pcol)) != NULL) - LinkFlow_pCode(PCI(pc),PCI(pct)); - else - fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n", - __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-")); - //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:"")); + } else { - continue; + if( (pct = findLabelinpBlock(pb,pcol)) != NULL) + LinkFlow_pCode(PCI(pc),PCI(pct)); + else + fprintf(stderr, "ERROR: %s, couldn't find label. key=%d,lab=%s\n", + __FUNCTION__,pcol->key,((PCOP(pcol)->name)?PCOP(pcol)->name:"-")); + //fprintf(stderr,"newpCodeOpLabel: key=%d, name=%s\n",key,((s)?s:"")); + } + /* link CALLs to next instruction */ + if (PCI(pc)->op != POC_CALL) continue; } if(isPCI(pc)) { @@ -4175,7 +4390,7 @@ void LinkFlow(pBlock *pb) continue; } - //fprintf(stderr, "ends with nothing: ERROR\n"); + fprintf(stderr, "ends with nothing: ERROR\n"); } } @@ -4218,606 +4433,310 @@ static void BanksUsedFlow2(pCode *pcflow) 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); -} -*/ -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -/* -static 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); - } - -} -*/ - -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -static void pCodeInstructionInsertAfter(pCodeInstruction *pci, pCodeInstruction *new_pci) -{ - - pCodeInsertAfter(pci->pc.prev, &new_pci->pc); - - /* Move the label, if there is one */ - - if(pci->label) { - new_pci->label = pci->label; - pci->label = NULL; - } - - /* Move the C code comment, if there is one */ - - if(pci->cline) { - new_pci->cline = pci->cline; - pci->cline = NULL; - } - - /* The new instruction has the same pcflow block */ - new_pci->pcflow = pci->pcflow; - -} - -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit) -{ - pCode *new_pc; - - new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit)); - - pCodeInstructionInsertAfter(pci, PCI(new_pc)); -} - -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -static void insertBankSel(pCodeInstruction *pci, const char *name) -{ - pCode *new_pc; - - pCodeOp *pcop = popCopyReg(PCOR(pci->pcop)); - pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it - if (pcop->name == 0) - pcop->name = strdup(name); - new_pc = newpCode(POC_BANKSEL, pcop); - - pCodeInstructionInsertAfter(pci, PCI(new_pc)); -} - -/*-----------------------------------------------------------------*/ -/* If the register is a fixed known addess then we can assign the */ -/* bank selection bits. Otherwise the linker is going to assign */ -/* the register location and thus has to set bank selection bits */ -/* through the banksel directive. */ -/* One critical assumption here is that within this C module all */ -/* the locally allocated registers are in the same udata sector. */ -/* Therefore banksel is only called for external registers or the */ -/* first time a local register is encountered. */ -/*-----------------------------------------------------------------*/ -static int LastRegIdx; /* If the previous register is the same one again then no need to change bank. */ -static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg) -{ - int bank; - int a = reg->alias>>7; - if ((a&3) == 3) { - return cur_bank; // This register is available in all banks - } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) { - return cur_bank; // This register is available in banks 0 & 1 - } else if (a&2) { - if (reg->address&0x80) { - if ((cur_bank==1)||(cur_bank==3)) { - return cur_bank; // This register is available in banks 1 & 3 - } - } else { - if ((cur_bank==0)||(cur_bank==1)) { - return cur_bank; // This register is available in banks 0 & 2 - } - } - } - - if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank - return cur_bank; - LastRegIdx = reg->rIdx; - - if (reg->isFixed) { - bank = REG_BANK(reg); - } else if (reg->isExtern) { - bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown - } else { - bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown - } - if ((cur_bank == 'L')&&(bank == 'L')) { // If current bank and new bank are both allocated locally by the linker, then assume it is in same bank. - return 'L'; // Local registers are presumed to be in same linker assigned bank - } else if ((bank == 'L')&&(cur_bank != 'L')) { // Reg is now local and linker to assign bank - insertBankSel(pci, reg->name); // Let linker choose the bank selection - } else if (bank == 'E') { // Reg is now extern and linker to assign bank - insertBankSel(pci, reg->name); // Let linker choose the bank selection - } else if ((cur_bank == -1)||(cur_bank == 'L')||(cur_bank == 'E')) { // Current bank unknown and new register bank is known then can set bank bits - insertBankSwitch(pci, bank&1, PIC_RP0_BIT); - insertBankSwitch(pci, bank&2, PIC_RP1_BIT); - } else { // Current bank and new register banks known - can set bank bits - switch((cur_bank^bank) & 3) { - case 0: - break; - case 1: - insertBankSwitch(pci, bank&1, PIC_RP0_BIT); - break; - case 2: - insertBankSwitch(pci, bank&2, PIC_RP1_BIT); - break; - case 3: - insertBankSwitch(pci, bank&1, PIC_RP0_BIT); - insertBankSwitch(pci, bank&2, PIC_RP1_BIT); - break; - } - } - - return bank; -} - -/*-----------------------------------------------------------------*/ -/* Check for bank selection pcodes instructions and modify */ -/* cur_bank to match. */ -/*-----------------------------------------------------------------*/ -static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) { + PCFL(pcflow)->lastBank = -1; - if (isSTATUS_REG(reg)) { + while(isPCinFlow(pc,pcflow)) { - if (PCI(pc)->op == POC_BCF) { - int old_bank = *cur_bank; - if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) { - /* If current bank is unknown or linker assigned then set to 0 else just change the bit */ - if (*cur_bank & ~(0x3)) - *cur_bank = 0; - else - *cur_bank = *cur_bank&0x2; - LastRegIdx = reg->rIdx; - } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) { - /* If current bank is unknown or linker assigned then set to 0 else just change the bit */ - if (*cur_bank & ~(0x3)) - *cur_bank = 0; - else - *cur_bank = *cur_bank&0x1; - LastRegIdx = reg->rIdx; - } - return old_bank != *cur_bank; - } + int bank_selected = isBankInstruction(pc); - if (PCI(pc)->op == POC_BSF) { - int old_bank = *cur_bank; - if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) { - /* If current bank is unknown or linker assigned then set to bit else just change the bit */ - if (*cur_bank & ~(0x3)) - *cur_bank = 0x1; - else - *cur_bank = (*cur_bank&0x2) | 0x1; - LastRegIdx = reg->rIdx; - } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) { - /* If current bank is unknown or linker assigned then set to bit else just change the bit */ - if (*cur_bank & ~(0x3)) - *cur_bank = 0x2; - else - *cur_bank = (*cur_bank&0x1) | 0x2; - LastRegIdx = reg->rIdx; - } - return old_bank != *cur_bank; - } + //if(PCI(pc)->pcflow) + //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq); - } else if (PCI(pc)->op == POC_BANKSEL) { - int old_bank = *cur_bank; - *cur_bank = (PCOR(PCI(pc)->pcop)->r->isExtern) ? 'E' : 'L'; - LastRegIdx = reg->rIdx; - return old_bank != *cur_bank; - } - - return 0; -} - -/*-----------------------------------------------------------------*/ -/* Set bank selection if necessary */ -/*-----------------------------------------------------------------*/ -static int DoBankSelect(pCode *pc, int cur_bank) { - pCode *pcprev; - regs *reg; - - if(!isPCI(pc)) - return cur_bank; - - if (isCALL(pc)) { - pCode *pcf = findFunction(get_op_from_instruction(PCI(pc))); - if (pcf && isPCF(pcf)) { - pCode *pcfr; - int rbank = 'U'; // Undetermined - FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done - // Check all the returns to work out what bank is selected - for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) { - if (isPCI(pcfr)) { - if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) { - if (rbank == 'U') - rbank = PCFL(pcfr)->lastBank; - else - if (rbank != PCFL(pcfr)->lastBank) - return -1; // Unknown bank - multiple returns with different banks - } - } - } - if (rbank == 'U') - return -1; // Unknown bank - return rbank; - } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) { - /* Extern functions may use registers in different bank - must call banksel */ - return -1; /* Unknown bank */ - } - } - - if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) { - return -1; /* New bank unknown - linkers choice. */ - } - - reg = getRegFromInstruction(pc); - if (reg) { - - if (IsBankChange(pc,reg,&cur_bank)) - return cur_bank; - - if (!isPCI_LIT(pc)) { + if(bank_selected > 0) { + //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected); - /* Examine the instruction before this one to make sure it is - * not a skip type instruction */ - pcprev = findPrevpCode(pc->prev, PC_OPCODE); + // This instruction is modifying banking bits before accessing registers + if(!RegUsed) + PCFL(pcflow)->firstBank = -1; - if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) { - cur_bank = BankSelect(PCI(pc),cur_bank,reg); - } else { - cur_bank = BankSelect(PCI(pcprev),cur_bank,reg); + 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; } - if (!PCI(pc)->pcflow) - fprintf(stderr,"PCI ID=%d missing flow pointer ???\n",pc->id); - else - PCI(pc)->pcflow->lastBank = cur_bank; /* Maintain pCodeFlow lastBank state */ - } - } - return cur_bank; -} - -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -/* -static void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank) -{ - pCode *pc=NULL; - pCode *pcprev=NULL; - - if(!pcfl) - return; - - pc = findNextInstruction(pcfl->pc.next); - - while(isPCinFlow(pc,PCODE(pcfl))) { - - cur_bank = DoBankSelect(pc,cur_bank); - pcprev = pc; + RegUsed = 1; + } + pc = findNextInstruction(pc->next); - - } - - if(pcprev && cur_bank) { - // Set bank state to unknown at the end of each flow block - cur_bank = -1; } - -} -*/ -/*-----------------------------------------------------------------*/ -/*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; - + // fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n", + // pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank); } */ /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ /* -void FixBankFlow(pBlock *pb) +static void BanksUsedFlow(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); + //pb->pcHead->print(stderr, pb->pcHead); - / * - 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"); + 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, "FixBankFlow - pcflow is not a flow object "); - continue; - } + pcflow != NULL; + pcflow = findNextpCode(pcflow->next, PC_FLOW) ) { - 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); - - } + 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),-1); - BanksUsedFlow2(pcflow); + +} +*/ - continue; / * Don't need to check the flow from here - it's already been fixed * / +void pCodeReplace (pCode *old, pCode *new) +{ + pCodeInsertAfter (old, new); - } + /* special handling for pCodeInstructions */ + if (isPCI(new) && isPCI(old)) + { + //assert (!PCI(new)->from && !PCI(new)->to && !PCI(new)->label && /*!PCI(new)->pcflow && */!PCI(new)->cline); + PCI(new)->from = PCI(old)->from; + PCI(new)->to = PCI(old)->to; + PCI(new)->label = PCI(old)->label; + PCI(new)->pcflow = PCI(old)->pcflow; + PCI(new)->cline = PCI(old)->cline; + } // if - nFlows = 0; - nConflicts = 0; + old->destruct (old); +} - pcfl = setFirstItem(PCFL(pcflow)->to); - while (pcfl) { +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void addpCodeComment(pCode *pc, const char *fmt, ...) +{ + va_list ap; + char buffer[4096]; + pCode *newpc; - pc = PCODE(pcfl->pcflow); - if(!isPCFL(pc)) { - fprintf(stderr,"oops dumpflow - to is not a pcflow\n"); - pc->print(stderr,pc); - } + va_start(ap, fmt); + if (options.verbose || debug_verbose) { + buffer[0] = ';'; + buffer[1] = ' '; + vsprintf(&buffer[2], fmt, ap); - nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1); - nFlows++; + newpc = newpCodeCharP(&buffer[0]); // strdup's the string + pCodeInsertAfter(pc, newpc); + } + va_end(ap); +} - pcfl=setNextItem(PCFL(pcflow)->to); - } +void pBlockMergeLabels(pBlock *pb); +/*-----------------------------------------------------------------*/ +/* Inserts a new pCodeInstruction before an existing one */ +/*-----------------------------------------------------------------*/ +static void insertPCodeInstruction(pCodeInstruction *pci, pCodeInstruction *new_pci) +{ + pCode *pcprev; - 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); + pcprev = findPrevInstruction(pci->pc.prev); + + pCodeInsertAfter(pci->pc.prev, &new_pci->pc); + + /* Move the label, if there is one */ + + if(pci->label) { + new_pci->label = pci->label; + pci->label = NULL; + } + + /* Move the C code comment, if there is one */ + + if(pci->cline) { + new_pci->cline = pci->cline; + pci->cline = NULL; + } + + /* The new instruction has the same pcflow block */ + new_pci->pcflow = pci->pcflow; - FixRegisterBankingInFlow(PCFL(pcflow),-1); - BanksUsedFlow2(pcflow); + /* Arrrrg: is pci's previous instruction is a skip, we need to + * change that into a jump (over pci and the new instruction) ... */ + if (pcprev && isPCI_SKIP(pcprev)) + { + symbol *lbl = newiTempLabel (NULL); + pCode *label = newpCodeLabel (NULL, lbl->key); + pCode *jump = newpCode(POC_GOTO, newpCodeOpLabel(NULL, lbl->key)); + + pCodeInsertAfter (pcprev, jump); + + // Yuck: Cannot simply replace INCFSZ/INCFSZW/DECFSZ/DECFSZW + // We replace them with INCF/INCFW/DECF/DECFW followed by 'BTFSS STATUS, Z' + switch (PCI(pcprev)->op) { + case POC_INCFSZ: + case POC_INCFSZW: + case POC_DECFSZ: + case POC_DECFSZW: + // These are turned into non-skipping instructions, so + // insert 'BTFSC STATUS, Z' after pcprev + pCodeInsertAfter (jump->prev, newpCode(POC_BTFSC, popCopyGPR2Bit(PCOP(&pc_status), PIC_Z_BIT))); + break; + default: + // no special actions required + break; } + pCodeReplace (pcprev, pCodeInstructionCopy (PCI(pcprev), 1)); + pcprev = NULL; + pCodeInsertAfter((pCode*)pci, label); + pBlockMergeLabels(pci->pc.pb); } +} - / * - Loop through the flow objects again and find the ones with the - maximum conflicts - * / +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static void insertBankSel(pCodeInstruction *pci, const char *name) +{ + pCode *new_pc; + + pCodeOp *pcop; - for( pcflow = findNextpCode(pb->pcHead, PC_FLOW); - pcflow != NULL; - pcflow = findNextpCode(pcflow->next, PC_FLOW) ) { + // Never BANKSEL STATUS, this breaks all kinds of code (e.g., interrupt handlers). + if (!strcmp("STATUS", name) || !strcmp("_STATUS", name)) return; + + pcop = popCopyReg(PCOR(pci->pcop)); + pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it + if (pcop->name == 0) + pcop->name = strdup(name); + new_pc = newpCode(POC_BANKSEL, pcop); + + insertPCodeInstruction(pci, PCI(new_pc)); +} - if(PCFL(pcflow)->ToConflicts > max_ToConflicts) - pcflow_max_To = pcflow; +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static int sameBank(regs *reg, regs *previous_reg, const char *new_bank, const char *cur_bank, unsigned max_mask) +{ + if (!cur_bank) return 0; - 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); + // identify '(regname + X)' and 'regname' + if (reg && reg->name && reg->name[0] == '(' && !strncmp(®->name[1], cur_bank, strlen(cur_bank))) return 1; + if (new_bank && new_bank[0] == '(' && !strncmp(&new_bank[1], cur_bank, strlen(cur_bank))) return 1; + if (cur_bank[0] == '(' && reg && reg->name && !strncmp(reg->name, &cur_bank[1], strlen(reg->name))) return 1; + if (cur_bank[0] == '(' && new_bank && !strncmp(new_bank, &cur_bank[1], strlen(new_bank))) return 1; + + if (previous_reg && reg && previous_reg->isFixed && reg->isFixed && ((previous_reg->address & max_mask) == (reg->address & max_mask))) // only if exists + return 1; // if we have address info, we use it for banksel optimization - 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); - * / + // XXX: identify '(regname + X)' and '(regname + Y)' + + return ((reg && reg->name && !strcmp(reg->name, cur_bank)) || (new_bank && !strcmp(new_bank, cur_bank))); } -*/ - + /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ -void DumpFlow(pBlock *pb) +void FixRegisterBanking(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); - } - - } - + pCode *pc; + pCodeInstruction *pci; + regs *reg; + regs *previous_reg; // contains the previous variable access info + const char *cur_bank, *new_bank; + unsigned cur_mask, new_mask, max_mask; + int allRAMmshared; + + if (!pb) return; + + max_mask = pic14_getPIC()->bankMask; + cur_mask = max_mask; + cur_bank = NULL; + previous_reg = NULL; + + allRAMmshared = pic14_allRAMShared(); + + for (pc = pb->pcHead; pc; pc = pc->next) + { + // this one has a label---might check bank at all jumps here... + if (isPCI(pc) && (PCI(pc)->label || PCI(pc)->op == POC_CALL)) { + addpCodeComment(pc->prev, "BANKOPT3 drop assumptions: PCI with label or call found"); + previous_reg = NULL; + cur_bank = NULL; // start new flow + cur_mask = max_mask; } + // this one is/might be a label or BANKSEL---assume nothing + if (isPCL(pc) || isPCASMDIR(pc)) { + addpCodeComment(pc->prev, "BANKOPT4 drop assumptions: label or ASMDIR found"); + previous_reg = NULL; + cur_bank = NULL; + cur_mask = max_mask; + } + + // this one modifies STATUS + // XXX: this should be checked, but usually BANKSELs are not done this way in generated code + + if (isPCI(pc)) { + pci = PCI(pc); + if ((pci->inCond | pci->outCond) & PCC_REGISTER) { + // might need a BANKSEL + reg = getRegFromInstruction(pc); + + if (reg) { + new_bank = reg->name; + // reg->alias == 0: reg is in only one bank, we do not know which (may be any bank) + // reg->alias != 0: reg is in 2/4/8/2**N banks, we select one of them + new_mask = reg->alias; + } else if (pci->pcop && pci->pcop->name) { + new_bank = pci->pcop->name; + new_mask = 0; // unknown, assume worst case + } else { + assert(!"Could not get register from instruction."); + } + + // optimizations... + // XXX: add switch to disable these + if (1) { + // reg present in all banks possibly selected? + if (new_mask == max_mask || (cur_mask && ((new_mask & cur_mask) == cur_mask))) { + // no BANKSEL required + addpCodeComment(pc->prev, "BANKOPT1 BANKSEL dropped; %s present in all of %s's banks", new_bank, cur_bank); + continue; + } + + // only one bank of memory and no SFR accessed? + // XXX: We can do better with fixed registers. + if (allRAMmshared && reg && (reg->type != REG_SFR) && (!reg->isFixed)) { + // no BANKSEL required + addpCodeComment(pc->prev, "BANKOPT1b BANKSEL dropped; %s present in all of %s's banks", new_bank, cur_bank); + continue; + } + + // restrict cur_mask to cover only the banks this register + // is in (as well as the previous registers) + cur_mask &= new_mask; + + if (sameBank(reg, previous_reg, new_bank, cur_bank, max_mask)) { + // no BANKSEL required + addpCodeComment(pc->prev, "BANKOPT2 BANKSEL dropped; %s present in same bank as %s", new_bank, cur_bank); + continue; + } + } // if + + cur_mask = new_mask; + cur_bank = new_bank; + previous_reg = reg; + insertBankSel(pci, cur_bank); + } // if + } // if + } // for } /*-----------------------------------------------------------------*/ @@ -4827,7 +4746,7 @@ int OptimizepBlock(pBlock *pb) pCode *pc, *pcprev; int matches =0; - if(!pb || !peepOptimizing) + if(!pb || options.nopeep) return 0; DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb))); @@ -4867,19 +4786,18 @@ int OptimizepBlock(pBlock *pb) /*-----------------------------------------------------------------*/ pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs) { - pCode *pc; - - for(pc = pcs; pc; pc = pc->next) { - - if((pc->type == PC_OPCODE) && - (PCI(pc)->pcop) && - (PCI(pc)->pcop->type == PO_LABEL) && - (PCOLAB(PCI(pc)->pcop)->key == pcl->key)) - return pc; - } - - - return NULL; + pCode *pc; + + for(pc = pcs; pc; pc = pc->next) { + + if(((pc->type == PC_OPCODE) || (pc->type == PC_INLINE) || (pc->type == PC_ASMDIR)) && + (PCI(pc)->pcop) && + (PCI(pc)->pcop->type == PO_LABEL) && + (PCOLAB(PCI(pc)->pcop)->key == pcl->key)) + return pc; + } + + return NULL; } /*-----------------------------------------------------------------*/ @@ -5108,92 +5026,6 @@ pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval) return pcop; } - -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ -static void FixRegisterBanking(pBlock *pb,int cur_bank) -{ - pCode *pc; - int firstBank = 'U'; - - if(!pb) - return; - - for (pc=pb->pcHead; pc; pc=pc->next) { - if (isPCFL(pc)) { - firstBank = PCFL(pc)->firstBank; - break; - } - } - if (firstBank != 'U') { - /* This block has already been done */ - if (firstBank != cur_bank) { - /* This block has started with a different bank - must adjust it */ - if ((firstBank != -1)&&(firstBank != 'E')) { /* The first bank start off unknown or extern then need not worry as banksel will be called */ - while (pc) { - if (isPCI(pc)) { - regs *reg = getRegFromInstruction(pc); - if (reg) { - DoBankSelect(pc,cur_bank); - } - } - pc = pc->next; - } - } - } - return; - } - - /* loop through all of the pCodes within this pblock setting the bank selection, ignoring any branching */ - LastRegIdx = -1; - cur_bank = -1; - for (pc=pb->pcHead; pc; pc=pc->next) { - if (isPCFL(pc)) { - PCFL(pc)->firstBank = cur_bank; - continue; - } - cur_bank = DoBankSelect(pc,cur_bank); - } - - /* Trace through branches and set the bank selection as required. */ - LastRegIdx = -1; - cur_bank = -1; - for (pc=pb->pcHead; pc; pc=pc->next) { - if (isPCFL(pc)) { - PCFL(pc)->firstBank = cur_bank; - continue; - } - if (isPCI(pc)) { - if (PCI(pc)->op == POC_GOTO) { - int lastRegIdx = LastRegIdx; - pCode *pcb = pc; - /* Trace through branch */ - pCode *pcl = findLabel(PCOLAB(PCI(pcb)->pcop)); - while (pcl) { - if (isPCI(pcl)) { - regs *reg = getRegFromInstruction(pcl); - if (reg) { - int bankUnknown = -1; - if (IsBankChange(pcl,reg,&bankUnknown)) /* Look for any bank change */ - break; - if (cur_bank != DoBankSelect(pcl,cur_bank)) /* Set bank selection if necessary */ - break; - } - } - pcl = pcl->next; - } - LastRegIdx = lastRegIdx; - } else { - /* Keep track out current bank */ - regs *reg = getRegFromInstruction(pc); - if (reg) - IsBankChange(pc,reg,&cur_bank); - } - } - } -} - - /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ void pBlockDestruct(pBlock *pb) @@ -5269,7 +5101,7 @@ void AnalyzeFlow(int level) return; - /* if this is not the first time this function has been called, + /* 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) @@ -5302,29 +5134,29 @@ void AnalyzeFlow(int level) BuildFlow(pb); - /* Phase 2 - Flow Analysis - linking flow blocks - * - * In this phase, the individual flow blocks are examined - * to determine their order of excution. + /* Phase 2 - Flow Analysis - linking flow blocks + * + * In this phase, the individual flow blocks are examined + * to determine their order of excution. */ 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. + /* 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) BuildFlowTree(pb); - /* Phase x - Flow Analysis - Used Banks - * - * In this phase, the individual flow blocks are examined - * to determine the Register Banks they use + /* 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) @@ -5341,33 +5173,32 @@ void AnalyzeFlow(int 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( pcflow = findNextpCode(pb->pcHead, PC_FLOW); - (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL; - pcflow = pcflow->next) { - - FillFlow(PCFL(pcflow)); - } - } + pCode *pcflow; + for( pcflow = findNextpCode(pb->pcHead, PC_FLOW); + (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL; + pcflow = pcflow->next) { + + FillFlow(PCFL(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)); - } - } + pCode *pcflow; + for( pcflow = findNextpCode(pb->pcHead, PC_FLOW); + (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL; + pcflow = pcflow->next) { + + FlowStats(PCFL(pcflow)); + } + } */ } @@ -5380,16 +5211,14 @@ void AnalyzeFlow(int level) 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"); - + werror(E_FILE_OPEN_ERR, "no memory size is known for this processor"); exit(1); } + if (!the_pFile) return; + /* Phase x - Flow Analysis - Used Banks * * In this phase, the individual flow blocks are examined @@ -5402,7 +5231,10 @@ void AnalyzeBanking(void) // for(pb = the_pFile->pbHead; pb; pb = pb->next) // BanksUsedFlow(pb); for(pb = the_pFile->pbHead; pb; pb = pb->next) - FixRegisterBanking(pb,-1); // cur_bank is unknown + FixRegisterBanking(pb); + + AnalyzeFlow(0); + AnalyzeFlow(1); } @@ -5410,8 +5242,10 @@ void AnalyzeBanking(void) /*-----------------------------------------------------------------*/ DEFSETFUNC (resetrIdx) { - if (!((regs *)item)->isFixed) - ((regs *)item)->rIdx = 0; + regs *r = (regs *)item; + if (!r->isFixed) { + r->rIdx = 0; + } return 0; } @@ -5419,11 +5253,12 @@ DEFSETFUNC (resetrIdx) /*-----------------------------------------------------------------*/ /* InitRegReuse - Initialises variables for code analyzer */ /*-----------------------------------------------------------------*/ - void InitReuseReg(void) { /* Find end of statically allocated variables for start idx */ - unsigned maxIdx = 0x20; /* Start from begining of GPR. Note may not be 0x20 on some PICs */ + /* Start from begining of GPR. Note may not be 0x20 on some PICs */ + /* XXX: Avoid clashes with fixed registers, start late. */ + unsigned maxIdx = 0x1000; regs *r; for (r = setFirstItem(dynDirectRegs); r; r = setNextItem(dynDirectRegs)) { if (r->type != REG_SFR) { @@ -5436,82 +5271,109 @@ void InitReuseReg(void) /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ -static unsigned register_reassign(pBlock *pb, unsigned idx) +static unsigned register_reassign(pBlock *pb, unsigned idx, unsigned level) { - pCode *pc; - - /* check recursion */ - pc = setFirstItem(pb->function_entries); - if(!pc) - return idx; - - pb->visited = 1; - - 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++; - if (peakIdx < idx) peakIdx = 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); - } - } - } + pCode *pc; + + /* check recursion */ + pc = setFirstItem(pb->function_entries); + if(!pc) + return idx; + + if (pb->visited) { + /* TODO: Recursion detection missing, should emit a warning as recursive code will fail. */ + return idx; + } + + pb->visited = 1; + + DFPRINTF((stderr," (%u) reassigning registers for function \"%s\"\n",level,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]; + set *regset; + // make sure, idx is not yet used in this routine... + do { + regset = pb->tregisters; + // do not touch s->curr ==> outer loop! + while (regset && ((regs *)regset->item)->rIdx != idx) { + regset = regset->next; + } + if (regset) idx++; + } while (regset); + r->rIdx = idx++; + if (peakIdx < idx) peakIdx = idx; + sprintf(s,"r0x%02X", r->rIdx); + DFPRINTF((stderr," (%u) reassigning register %p \"%s\" to \"%s\"\n",level,r,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); - } - } - + } + 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) { + /* This index increment from subroutines is not required, as all subroutines + * may share registers NOT used by this one (< idx). + * BUT if called functions A and B share a register, which gets assigned + * rIdx = idx + 4 while analyzing A, we must not assign idx + 4 again while + * analyzing B! + * As an alternative to this "solution" we could check above whether an + * to-be-assigned rIdx is already present in the register set of the + * current function. This would increase the reused registers and make this + * `idx =' irrelevant. + * UPDATE: Implemented above; not fast, but works. + * (Problem shown with regression test src/regression/sub2.c) + */ + /*idx = */register_reassign(pcn->pb,idx,level+1); + } } - - return idx; + } + + return idx; } /*------------------------------------------------------------------*/ /* ReuseReg were call tree permits */ /* */ -/* 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. */ +/* 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. */ /* */ -/* Note for this to work the fucntions need to be declared static. */ +/* Note for this to work the functions need to be declared static. */ /* */ /*------------------------------------------------------------------*/ void ReuseReg(void) { pBlock *pb; + if (!the_pFile) return; InitReuseReg(); for(pb = the_pFile->pbHead; pb; pb = pb->next) { /* Non static functions can be called from other modules so their registers must reassign */ - if (pb->function_entries&&(PCF(setFirstItem(pb->function_entries))->isPublic||!pb->visited)) - register_reassign(pb,peakIdx); + if (pb->function_entries && (PCF(setFirstItem(pb->function_entries))->isPublic || !pb->visited)) + register_reassign(pb,peakIdx,0); } } @@ -5529,31 +5391,31 @@ void buildCallTree(void ) 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 - with pBlock boundaries. - - The algorithm goes something like this: - We have two nested loops. The outer loop iterates - through all of the pBlocks/functions. The inner - loop iterates through all of the pCodes for - a given pBlock. When we begin iterating through - a pBlock, the variable pc_fstart, pCode of the start - of a function, is cleared. We then search for pCodes - of type PC_FUNCTION. When one is encountered, we - initialize pc_fstart to this and at the same time - associate a new pBranch object that signifies a - branch entry. If a return is found, then this signifies - a function exit point. We'll link the pCodes of these - returns to the matching pc_fstart. - - When we're done, a doubly linked list of pBranches - will exist. The head of this list is stored in - `the_pFile', which is the meta structure for all - of the pCode. Look at the printCallTree function - on how the pBranches are linked together. - + /* Now build the call tree. + First we examine all of the pCodes for functions. + Keep in mind that the function boundaries coincide + with pBlock boundaries. + + The algorithm goes something like this: + We have two nested loops. The outer loop iterates + through all of the pBlocks/functions. The inner + loop iterates through all of the pCodes for + a given pBlock. When we begin iterating through + a pBlock, the variable pc_fstart, pCode of the start + of a function, is cleared. We then search for pCodes + of type PC_FUNCTION. When one is encountered, we + initialize pc_fstart to this and at the same time + associate a new pBranch object that signifies a + branch entry. If a return is found, then this signifies + a function exit point. We'll link the pCodes of these + returns to the matching pc_fstart. + + When we're done, a doubly linked list of pBranches + will exist. The head of this list is stored in + `the_pFile', which is the meta structure for all + of the pCode. Look at the printCallTree function + on how the pBranches are linked together. + */ for(pb = the_pFile->pbHead; pb; pb = pb->next) { pCode *pc_fstart=NULL; @@ -5635,7 +5497,7 @@ void AnalyzepCode(char dbName) pBlockMergeLabels(pb); AnalyzepBlock(pb); } else { - DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName)); + DFPRINTF((stderr," skipping block analysis dbName=%c blockname=%c\n",dbName,getpBlock_dbName(pb))); } } @@ -5779,8 +5641,8 @@ set *register_usage(pBlock *pb) set *registersInCallPath = NULL; / * check recursion * / - - pc = setFirstItem(pb->function_entries); + + pc = setFirstItem(pb->function_entries); if(!pc) return registers; @@ -5789,53 +5651,53 @@ set *register_usage(pBlock *pb) if(pc->type != PC_FUNCTION) fprintf(stderr,"%s, first pc is not a function???\n",__FUNCTION__); - + pc = setFirstItem(pb->function_calls); for( ; pc; pc = setNextItem(pb->function_calls)) { - + if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) { char *dest = get_op_from_instruction(PCI(pc)); - + pcn = findFunction(dest); if(pcn) registersInCallPath = register_usage(pcn->pb); } else fprintf(stderr,"BUG? pCode isn't a POC_CALL %d\n",__LINE__); - + } - + #ifdef PCODE_DEBUG pBlockStats(stderr,pb); // debug #endif - + // Mark the registers in this block as used. - + MarkUsedRegisters(pb->tregisters); 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; - + + regs *r1,*r2, *newreg; + DFPRINTF((stderr,"comparing registers\n")); - + r1 = setFirstItem(registersInCallPath); while(r1) { if (r1->type != REG_STK) { r2 = setFirstItem(pb->tregisters); - + while(r2 && (r2->type != REG_STK)) { - + if(r2->rIdx == r1->rIdx) { newreg = pic14_findFreeReg(REG_GPR); - - + + if(!newreg) { DFPRINTF((stderr,"Bummer, no more registers.\n")); exit(1); } - + DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n", r1->rIdx, newreg->rIdx)); r2->rIdx = newreg->rIdx; @@ -5849,32 +5711,32 @@ set *register_usage(pBlock *pb) r2 = setNextItem(pb->tregisters); } } - + 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); if (newreg) newreg->isFree = 1; - r1 = setNextItem(registersInCallPath); + r1 = setNextItem(registersInCallPath); } - + }// else - // MarkUsedRegisters(pb->registers); - + // MarkUsedRegisters(pb->registers); + registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE); #ifdef PCODE_DEBUG if(registers) DFPRINTF((stderr,"returning regs\n")); else DFPRINTF((stderr,"not returning regs\n")); - + DFPRINTF((stderr,"pBlock after register optim.\n")); pBlockStats(stderr,pb); // debug #endif - + return registers; } */ @@ -6019,10 +5881,10 @@ void InlineFunction(pBlock *pb) 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. - + To in-line this call, we need to remove the CALL + and RETURN(s), and link the function pCode in with + the CALLee pCode. + */ pc_call = pc;