Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-------------------------------------------------------------------------*/
-#include <stdio.h>
-
-#include "common.h" // Include everything in the SDCC src directory
-#include "newalloc.h"
-
-
+#include "device.h"
+#include "gen.h"
#include "pcode.h"
#include "pcodeflow.h"
#include "ralloc.h"
-#include "device.h"
-
-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
/****************************************************************/
/****************************************************************/
-peepCommand peepCommands[] = {
-
- {NOTBITSKIP, "_NOTBITSKIP_"},
- {BITSKIP, "_BITSKIP_"},
- {INVERTBITSKIP, "_INVERTBITSKIP_"},
-
- {-1, NULL}
-};
-
-
-
// Eventually this will go into device dependent files:
pCodeOpReg pc_status = {{PO_STATUS, "STATUS"}, -1, NULL,0,NULL};
pCodeOpReg pc_indf = {{PO_INDF, "INDF"}, -1, NULL,0,NULL};
pCodeOpReg pc_ssave = {{PO_GPR_REGISTER, "SSAVE"}, -1, NULL,0,NULL};
pCodeOpReg pc_psave = {{PO_GPR_REGISTER, "PSAVE"}, -1, NULL,0,NULL};
+pFile *the_pFile = NULL;
+
+
+#define SET_BANK_BIT (1 << 16)
+#define CLR_BANK_BIT 0
+
+static peepCommand peepCommands[] = {
+
+ {NOTBITSKIP, "_NOTBITSKIP_"},
+ {BITSKIP, "_BITSKIP_"},
+ {INVERTBITSKIP, "_INVERTBITSKIP_"},
+
+ {-1, NULL}
+};
+
static int mnemonics_initialized = 0;
static hTab *pic14MnemonicsHash = NULL;
static hTab *pic14pCodePeepCommandsHash = NULL;
-
-pFile *the_pFile = NULL;
static pBlock *pb_dead_pcodes = NULL;
/* Hardcoded flags to change the behavior of the PIC port */
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;
+static int GpcFlowSeq = 1;
/* statistics (code size estimation) */
static unsigned int pcode_insns = 0;
static unsigned int pcode_doubles = 0;
+static unsigned peakIdx = 0; /* This keeps track of the peak register index for call tree register reuse */
-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 */
-
-extern void RemoveUnusedRegisters(void);
-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 */
/****************************************************************/
-void unlinkpCode(pCode *pc);
-#if 0
-static void genericAnalyze(pCode *pc);
-static void AnalyzeGOTO(pCode *pc);
-static void AnalyzeSKIP(pCode *pc);
-static void AnalyzeRETURN(pCode *pc);
-#endif
-
static void genericDestruct(pCode *pc);
static void genericPrint(FILE *of,pCode *pc);
+static void pBlockStats(FILE *of, pBlock *pb);
+static pCode *findFunction(char *fname);
static void pCodePrintLabel(FILE *of, pCode *pc);
static void pCodePrintFunction(FILE *of, pCode *pc);
static void pCodeOpPrint(FILE *of, pCodeOp *pcop);
static char *get_op_from_instruction( pCodeInstruction *pcc);
-char *get_op( pCodeOp *pcop,char *buff,size_t buf_size);
-int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd);
-int pCodePeepMatchRule(pCode *pc);
-void pBlockStats(FILE *of, pBlock *pb);
-pBlock *newpBlock(void);
-pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval);
-void pCodeRegMapLiveRanges(pBlock *pb);
-
-pBranch * pBranchAppend(pBranch *h, pBranch *n);
+static pBlock *newpBlock(void);
/****************************************************************/
/* PIC Instructions */
/****************************************************************/
-pCodeInstruction pciADDWF = {
+static pCodeInstruction pciADDWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ADDWF,
(PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
};
-pCodeInstruction pciADDFW = {
+static pCodeInstruction pciADDFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ADDFW,
(PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
};
-pCodeInstruction pciADDLW = {
+static pCodeInstruction pciADDLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ADDLW,
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
-pCodeInstruction pciANDLW = {
+static pCodeInstruction pciANDLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ANDLW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciANDWF = {
+static pCodeInstruction pciANDWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ANDWF,
(PCC_REGISTER | PCC_Z) // outCond
};
-pCodeInstruction pciANDFW = {
+static pCodeInstruction pciANDFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_ANDFW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciBCF = {
+static pCodeInstruction pciBCF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_BCF,
(PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
-pCodeInstruction pciBSF = {
+static pCodeInstruction pciBSF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_BSF,
(PCC_REGISTER | PCC_EXAMINE_PCOP) // outCond
};
-pCodeInstruction pciBTFSC = {
+static pCodeInstruction pciBTFSC = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_BTFSC,
PCC_NONE // outCond
};
-pCodeInstruction pciBTFSS = {
+static pCodeInstruction pciBTFSS = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_BTFSS,
PCC_NONE // outCond
};
-pCodeInstruction pciCALL = {
+static pCodeInstruction pciCALL = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_CALL,
(PCC_NONE | PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond, flags are destroyed by called function
};
-pCodeInstruction pciCOMF = {
+static pCodeInstruction pciCOMF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_COMF,
PCC_REGISTER | PCC_Z // outCond
};
-pCodeInstruction pciCOMFW = {
+static pCodeInstruction pciCOMFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_COMFW,
PCC_W | PCC_Z // outCond
};
-pCodeInstruction pciCLRF = {
+static pCodeInstruction pciCLRF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_CLRF,
PCC_REGISTER | PCC_Z // outCond
};
-pCodeInstruction pciCLRW = {
+static pCodeInstruction pciCLRW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_CLRW,
PCC_W | PCC_Z // outCond
};
-pCodeInstruction pciCLRWDT = {
+static pCodeInstruction pciCLRWDT = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_CLRWDT,
PCC_NONE // outCond
};
-pCodeInstruction pciDECF = {
+static pCodeInstruction pciDECF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_DECF,
PCC_REGISTER | PCC_Z // outCond
};
-pCodeInstruction pciDECFW = {
+static pCodeInstruction pciDECFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_DECFW,
PCC_W | PCC_Z // outCond
};
-pCodeInstruction pciDECFSZ = {
+static pCodeInstruction pciDECFSZ = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_DECFSZ,
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 = {
+static pCodeInstruction pciDECFSZW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_DECFSZW,
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 = {
+static pCodeInstruction pciGOTO = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeGOTO,
genericDestruct,
genericPrint},
POC_GOTO,
PCC_NONE // outCond
};
-pCodeInstruction pciINCF = {
+static pCodeInstruction pciINCF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_INCF,
PCC_REGISTER | PCC_Z // outCond
};
-pCodeInstruction pciINCFW = {
+static pCodeInstruction pciINCFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_INCFW,
PCC_W | PCC_Z // outCond
};
-pCodeInstruction pciINCFSZ = {
+static pCodeInstruction pciINCFSZ = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_INCFSZ,
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 = {
+static pCodeInstruction pciINCFSZW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeSKIP,
genericDestruct,
genericPrint},
POC_INCFSZW,
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 = {
+static pCodeInstruction pciIORWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_IORWF,
(PCC_REGISTER | PCC_Z) // outCond
};
-pCodeInstruction pciIORFW = {
+static pCodeInstruction pciIORFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_IORFW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciIORLW = {
+static pCodeInstruction pciIORLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_IORLW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciMOVF = {
+static pCodeInstruction pciMOVF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_MOVF,
PCC_Z // outCond
};
-pCodeInstruction pciMOVFW = {
+static pCodeInstruction pciMOVFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_MOVFW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciMOVWF = {
+static pCodeInstruction pciMOVWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_MOVWF,
PCC_REGISTER // outCond
};
-pCodeInstruction pciMOVLW = {
+static pCodeInstruction pciMOVLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
genericDestruct,
genericPrint},
PCC_W // outCond
};
-pCodeInstruction pciNOP = {
+static pCodeInstruction pciNOP = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
genericDestruct,
genericPrint},
PCC_NONE // outCond
};
-pCodeInstruction pciRETFIE = {
+static pCodeInstruction pciRETFIE = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
genericDestruct,
genericPrint},
POC_RETFIE,
(PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond (not true... affects the GIE bit too), STATUS bit are retored
};
-pCodeInstruction pciRETLW = {
+static pCodeInstruction pciRETLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
genericDestruct,
genericPrint},
POC_RETLW,
(PCC_W| PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETLW
};
-pCodeInstruction pciRETURN = {
+static pCodeInstruction pciRETURN = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // AnalyzeRETURN,
genericDestruct,
genericPrint},
POC_RETURN,
(PCC_NONE | PCC_C | PCC_DC | PCC_Z) // outCond, STATUS bits are irrelevant after RETURN
};
-pCodeInstruction pciRLF = {
+static pCodeInstruction pciRLF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_RLF,
(PCC_REGISTER | PCC_C ) // outCond
};
-pCodeInstruction pciRLFW = {
+static pCodeInstruction pciRLFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_RLFW,
(PCC_W | PCC_C) // outCond
};
-pCodeInstruction pciRRF = {
+static pCodeInstruction pciRRF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_RRF,
(PCC_REGISTER | PCC_C) // outCond
};
-pCodeInstruction pciRRFW = {
+static pCodeInstruction pciRRFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_RRFW,
(PCC_W | PCC_C) // outCond
};
-pCodeInstruction pciSUBWF = {
+static pCodeInstruction pciSUBWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_SUBWF,
(PCC_REGISTER | PCC_C | PCC_DC | PCC_Z) // outCond
};
-pCodeInstruction pciSUBFW = {
+static pCodeInstruction pciSUBFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_SUBFW,
(PCC_W | PCC_C | PCC_DC | PCC_Z) // outCond
};
-pCodeInstruction pciSUBLW = {
+static pCodeInstruction pciSUBLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_SUBLW,
(PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond
};
-pCodeInstruction pciSWAPF = {
+static pCodeInstruction pciSWAPF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_SWAPF,
(PCC_REGISTER) // outCond
};
-pCodeInstruction pciSWAPFW = {
+static pCodeInstruction pciSWAPFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_SWAPFW,
(PCC_W) // outCond
};
-pCodeInstruction pciTRIS = {
+static pCodeInstruction pciTRIS = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_TRIS,
PCC_REGISTER // outCond /* FIXME: what's TRIS doing */
};
-pCodeInstruction pciXORWF = {
+static pCodeInstruction pciXORWF = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_XORWF,
(PCC_REGISTER | PCC_Z) // outCond
};
-pCodeInstruction pciXORFW = {
+static pCodeInstruction pciXORFW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_XORFW,
(PCC_W | PCC_Z) // outCond
};
-pCodeInstruction pciXORLW = {
+static pCodeInstruction pciXORLW = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_XORLW,
};
-pCodeInstruction pciBANKSEL = {
+static pCodeInstruction pciBANKSEL = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_BANKSEL,
PCC_NONE // outCond
};
-pCodeInstruction pciPAGESEL = {
+static pCodeInstruction pciPAGESEL = {
{PC_OPCODE, NULL, NULL, 0, 0, NULL,
- // genericAnalyze,
genericDestruct,
genericPrint},
POC_PAGESEL,
/*-----------------------------------------------------------------*/
/* return a unique ID number to assist pCodes debuging */
/*-----------------------------------------------------------------*/
-unsigned PCodeID(void) {
+static unsigned PCodeID(void) {
static unsigned int pcodeId = 1; /* unique ID number to be assigned to all pCodes */
/*
static unsigned int stop;
return pcodeId++;
}
-#ifdef HAVE_VSNPRINTF
-// Alas, vsnprintf is not ANSI standard, and does not exist
-// on Solaris (and probably other non-Gnu flavored Unixes).
-
-/*-----------------------------------------------------------------*/
-/* SAFE_snprintf - like snprintf except the string pointer is */
-/* after the string has been printed to. This is */
-/* useful for printing to string as though if it */
-/* were a stream. */
-/*-----------------------------------------------------------------*/
-void SAFE_snprintf(char **str, size_t *size, const char *format, ...)
-{
- va_list val;
- int len;
-
- if(!str || !*str)
- return;
-
- va_start(val, format);
-
- vsnprintf(*str, *size, format, val);
-
- va_end (val);
-
- len = strlen(*str);
- if((size_t)len > *size) {
- fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
- fprintf(stderr,"len = %d is > str size %d\n",len,(int)*size);
- }
-
- *str += len;
- *size -= len;
-
-}
-
-#else // HAVE_VSNPRINTF
-
-// This version is *not* safe, despite the name.
-
-void SAFE_snprintf(char **str, size_t *size, const char *format, ...)
-{
- va_list val;
- int len;
- static char buffer[1024]; /* grossly conservative, but still not inherently safe */
-
- if(!str || !*str)
- return;
-
- va_start(val, format);
-
- vsprintf(buffer, format, val);
- va_end (val);
-
- len = strlen(buffer);
- if(len > *size) {
- fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__);
- fprintf(stderr,"len = %d is > str size %d\n",len,*size);
- }
-
- strcpy(*str, buffer);
- *str += len;
- *size -= len;
-
-}
-
-#endif // HAVE_VSNPRINTF
-
-
-extern void initStack(int base_address, int size);
-extern regs *allocProcessorRegister(int rIdx, char * name, short po_type, int alias);
-extern regs *allocInternalRegister(int rIdx, char * name, PIC_OPTYPE po_type, int alias);
-extern void 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;
- init_pic(port->processor);
- /* FIXME - some PIC ICs like 16C7X which do not have a shared bank
- * need a different approach.
- * The fixed address might not be needed anyway, possibly the
- * linker will assign udata_shr sections correctly... */
- shareBankAddress = pic14_getSharebankAddress();
+ 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 = pic14_getSharebankSize()-3;
- /* Putting the pseudo stack in shared memory so all modules use the same register when passing fn parameters */
- initStack(shareBankAddress, stkSize);
+ * 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_pcl.rIdx = IDX_PCL;
pc_pclath.rIdx = IDX_PCLATH;
- pc_wsave.r = allocInternalRegister(IDX_WSAVE,pc_wsave.pcop.name,pc_wsave.pcop.type, 0x180); /* Interrupt storage for working register - must be same address in all banks ie section SHAREBANK. */
- pc_ssave.r = allocInternalRegister(IDX_SSAVE,pc_ssave.pcop.name,pc_ssave.pcop.type, 0); /* Interrupt storage for status register. */
- pc_psave.r = allocInternalRegister(IDX_PSAVE,pc_psave.pcop.name,pc_psave.pcop.type, 0); /* Interrupt storage for pclath register. */
+ /* 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;
/* */
/*-----------------------------------------------------------------*/
-int mnem2key(unsigned char const *mnem)
+static int mnem2key(unsigned char const *mnem)
{
int key = 0;
}
-void pic14initMnemonics(void)
+static void pic14initMnemonics(void)
{
int i = 0;
int key;
mnemonics_initialized = 1;
}
-int getpCodePeepCommand(char *cmd);
-
int getpCode(char *mnem,unsigned dest)
{
return -1;
}
-char getpBlock_dbName(pBlock *pb)
+static char getpBlock_dbName(pBlock *pb)
{
if(!pb)
return 0;
return pb->dbName;
}
+
void pBlockConvert2ISR(pBlock *pb)
{
if(!pb)
}
}
}
+
/*-----------------------------------------------------------------*/
/* int RegCond(pCodeOp *pcop) - if pcop points to the STATUS reg- */
/* ister, RegCond will return the bit being referenced. */
pcw->pci.from = pcw->pci.to = pcw->pci.label = NULL;
pcw->pci.pc.pb = NULL;
- // pcw->pci.pc.analyze = genericAnalyze;
pcw->pci.pc.destruct = genericDestruct;
pcw->pci.pc.print = genericPrint;
}
-/*-----------------------------------------------------------------*/
-/* newPcodeInlineP - create a new pCode from a char string */
-/*-----------------------------------------------------------------*/
-
-
-pCode *newpCodeInlineP(char *cP)
-{
-
- pCodeComment *pcc ;
-
- pcc = Safe_calloc(1,sizeof(pCodeComment));
-
- pcc->pc.type = PC_INLINE;
- pcc->pc.prev = pcc->pc.next = NULL;
- pcc->pc.id = PCodeID();
- //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
- pcc->pc.pb = NULL;
-
- // pcc->pc.analyze = genericAnalyze;
- pcc->pc.destruct = genericDestruct;
- pcc->pc.print = genericPrint;
-
- if(cP)
- pcc->comment = Safe_strdup(cP);
- else
- pcc->comment = NULL;
-
- return ( (pCode *)pcc);
-
-}
-
/*-----------------------------------------------------------------*/
/* newPcodeCharP - create a new pCode from a char string */
/*-----------------------------------------------------------------*/
//pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL;
pcc->pc.pb = NULL;
- // pcc->pc.analyze = genericAnalyze;
pcc->pc.destruct = genericDestruct;
pcc->pc.print = genericPrint;
//pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL;
pcf->pc.pb = NULL;
- // pcf->pc.analyze = genericAnalyze;
pcf->pc.destruct = genericDestruct;
pcf->pc.print = pCodePrintFunction;
/*-----------------------------------------------------------------*/
/* newpCodeFlow */
/*-----------------------------------------------------------------*/
-void destructpCodeFlow(pCode *pc)
+static void destructpCodeFlow(pCode *pc)
{
if(!pc || !isPCFL(pc))
return;
}
-pCode *newpCodeFlow(void )
+static pCode *newpCodeFlow(void )
{
pCodeFlow *pcflow;
pcflow->pc.prev = pcflow->pc.next = NULL;
pcflow->pc.pb = NULL;
- // pcflow->pc.analyze = genericAnalyze;
pcflow->pc.destruct = destructpCodeFlow;
pcflow->pc.print = genericPrint;
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
+static pCodeFlowLink *newpCodeFlowLink(pCodeFlow *pcflow)
{
pCodeFlowLink *pcflowLink;
//pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL;
pcl->pc.pb = NULL;
- // pcl->pc.analyze = genericAnalyze;
pcl->pc.destruct = pCodeLabelDestruct;
pcl->pc.print = pCodePrintLabel;
/*-----------------------------------------------------------------*/
/* newpBlock - create and return a pointer to a new pBlock */
/*-----------------------------------------------------------------*/
-pBlock *newpBlock(void)
+static pBlock *newpBlock(void)
{
pBlock *PpB;
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);
}
* for.
*-----------------------------------------------------------------*/
-pCodeOp *newpCodeOpReg(int rIdx)
+static pCodeOp *newpCodeOpReg(int rIdx)
{
pCodeOp *pcop;
return pcop;
}
-pCodeOp *newpCodeOpStr(char *name)
+static pCodeOp *newpCodeOpStr(char *name)
{
pCodeOp *pcop;
return pcop;
}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void pCodeConstString(char *name, char *value)
-{
- pBlock *pb;
- unsigned i;
-
- // fprintf(stderr, " %s %s %s\n",__FUNCTION__,name,value);
-
- if(!name || !value)
- return;
-
- pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
-
- 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));
-
- do {
- addpCode2pBlock(pb,newpCode(POC_RETLW,newpCodeOpLit(*value)));
- }while (*value++);
-
-
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void pCodeReadCodeTable(void)
-{
- pBlock *pb;
-
- fprintf(stderr, " %s\n",__FUNCTION__);
-
- pb = newpCodeChain(NULL, 'P',newpCodeCharP("; Starting pCode block"));
-
- addpBlock(pb);
-
- addpCode2pBlock(pb,newpCodeCharP("; ReadCodeTable - built in function"));
- addpCode2pBlock(pb,newpCodeCharP("; Inputs: temp1,temp2 = code pointer"));
- addpCode2pBlock(pb,newpCodeCharP("; Outpus: W (from RETLW at temp2:temp1)"));
- addpCode2pBlock(pb,newpCodeLabel("ReadCodeTable:",-1));
-
- addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp2")));
- addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCLATH")));
- addpCode2pBlock(pb,newpCode(POC_MOVFW,newpCodeOpRegFromStr("temp1")));
- addpCode2pBlock(pb,newpCode(POC_MOVWF,newpCodeOpRegFromStr("PCL")));
-
-
-}
-
/*-----------------------------------------------------------------*/
/* addpCode2pBlock - place the pCode into the pBlock linked list */
/*-----------------------------------------------------------------*/
void addpCode2pBlock(pBlock *pb, pCode *pc)
{
- if(!pc)
+ if(!pb || !pc)
return;
if(!pb->pcHead) {
/*-----------------------------------------------------------------*/
/* removepBlock - remove a pBlock from the pFile */
/*-----------------------------------------------------------------*/
-void removepBlock(pBlock *pb)
+static void removepBlock(pBlock *pb)
{
pBlock *pbs;
}
}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void pBlockRegs(FILE *of, pBlock *pb)
-{
-
- regs *r;
-
- r = setFirstItem(pb->tregisters);
- while (r) {
- r = setNextItem(pb->tregisters);
- }
-}
-
-
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
char *get_op(pCodeOp *pcop,char *buffer, size_t size)
case PO_INDF:
case PO_FSR:
if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
+ SNPRINTF(buffer,size,"%s",PCOR(pcop)->r->name);
return buffer;
}
- //return PCOR(pcop)->r->name;
return pcop->name;
break;
case PO_GPR_TEMP:
r = pic14_regWithIdx(PCOR(pcop)->r->rIdx);
if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",r->name);
+ SNPRINTF(buffer,size,"%s",r->name);
return buffer;
}
return r->name;
-
+ break;
case PO_IMMEDIATE:
s = buffer;
if( PCOI(pcop)->offset >= 0 && PCOI(pcop)->offset<4) {
switch(PCOI(pcop)->offset) {
case 0:
- SAFE_snprintf(&s,&size,"low (%s+%d)",pcop->name, PCOI(pcop)->index);
+ SNPRINTF(s,size,"low (%s+%d)",pcop->name, PCOI(pcop)->index);
break;
case 1:
- SAFE_snprintf(&s,&size,"high (%s+%d)",pcop->name, PCOI(pcop)->index);
+ SNPRINTF(s,size,"high (%s+%d)",pcop->name, PCOI(pcop)->index);
+ break;
+ case 2:
+ 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)",
+ 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);
+ SNPRINTF(s,size,"LOW (%s+%d)",pcop->name,PCOI(pcop)->index);
} else {
if( !PCOI(pcop)->offset) { // && PCOI(pcc->pcop)->offset<4)
- SAFE_snprintf(&s,&size,"(%s + %d)",
+ SNPRINTF(s,size,"(%s + %d)",
pcop->name,
PCOI(pcop)->index);
} else {
switch(PCOI(pcop)->offset) {
case 0:
- SAFE_snprintf(&s,&size,"(%s + %d)",pcop->name, PCOI(pcop)->index);
+ SNPRINTF(s,size,"(%s + %d)",pcop->name, PCOI(pcop)->index);
break;
case 1:
- SAFE_snprintf(&s,&size,"high (%s + %d)",pcop->name, PCOI(pcop)->index);
+ SNPRINTF(s,size,"high (%s + %d)",pcop->name, PCOI(pcop)->index);
+ break;
+ case 2:
+ SNPRINTF(s,size,"0x%02x",PCOI(pcop)->_const ? GPTRTAG_CODE : GPTRTAG_DATA);
break;
default:
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);
+ SNPRINTF(s,size,"((%s + %d) >> %d)&0xff",pcop->name, PCOI(pcop)->index, 8*PCOI(pcop)->offset);
break;
}
}
}
-
return buffer;
+ break;
case PO_DIR:
s = buffer;
- //size = sizeof(buffer);
if( PCOR(pcop)->instance) {
- SAFE_snprintf(&s,&size,"(%s + %d)",
+ 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);
+ SNPRINTF(s,size,"%s",pcop->name);
return buffer;
+ break;
case PO_LABEL:
s = buffer;
if (pcop->name) {
if(PCOLAB(pcop)->offset == 1)
- SAFE_snprintf(&s,&size,"HIGH(%s)",pcop->name);
+ SNPRINTF(s,size,"HIGH(%s)",pcop->name);
else
- SAFE_snprintf(&s,&size,"%s",pcop->name);
+ SNPRINTF(s,size,"%s",pcop->name);
}
return buffer;
+ break;
case PO_GPR_BIT:
if(PCOR(pcop)->r) {
if(use_buffer) {
- SAFE_snprintf(&buffer,&size,"%s",PCOR(pcop)->r->name);
+ 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);
+ SNPRINTF(buffer,size,"%s",pcop->name);
return buffer;
}
return pcop->name;
/*-----------------------------------------------------------------*/
char *pCode2str(char *str, size_t size, pCode *pc)
{
- char *s = str;
+ char *s = str;
- switch(pc->type) {
+ switch(pc->type) {
- case PC_OPCODE:
+ 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;
+ SNPRINTF(s,size, "\t%s\t", PCI(pc)->mnemonic);
+ size -= strlen(s);
+ s += strlen(s);
+
+ 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) )
+ SNPRINTF(s,size,"(%s >> 3), (%s & 7)", name, name);
+ else
+ SNPRINTF(s,size,"%s,%d", name, (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit)&7);
+ } else if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+ SNPRINTF(s,size,"%s,%d", get_op_from_instruction(PCI(pc)),PCORB(PCI(pc)->pcop)->bit);
+ } else
+ SNPRINTF(s,size,"%s,0 ; ?bug", get_op_from_instruction(PCI(pc)));
+ } else {
+ if(PCI(pc)->pcop->type == PO_GPR_BIT) {
+ if( PCI(pc)->num_ops == 2)
+ SNPRINTF(s,size,"(%s >> 3),%c",get_op_from_instruction(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W'));
+ else
+ SNPRINTF(s,size,"(1 << (%s & 7))",get_op_from_instruction(PCI(pc)));
+ } else {
+ SNPRINTF(s,size,"%s",get_op_from_instruction(PCI(pc)));
+ size -= strlen(s);
+ s += strlen(s);
+ if( PCI(pc)->num_ops == 2)
+ 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_COMMENT:
+ /* assuming that comment ends with a \n */
+ 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_INLINE:
+ /* assuming that inline code ends with a \n */
+ 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);
+ case PC_LABEL:
+ SNPRINTF(s,size,";label=%s, key=%d\n",PCL(pc)->label,PCL(pc)->key);
+ break;
+ case PC_FUNCTION:
+ SNPRINTF(s,size,";modname=%s,function=%s: id=%d\n",PCF(pc)->modname,PCF(pc)->fname);
+ break;
+ case PC_WILD:
+ SNPRINTF(s,size,";\tWild opcode: id=%d\n",PCW(pc)->id);
+ break;
+ case PC_FLOW:
+ SNPRINTF(s,size,";\t--FLOW change\n");
+ break;
+ case PC_CSOURCE:
+ 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) {
+ 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 */
+ SNPRINTF(s,size,"%s\n", PCAD(pc)->arg);
+ }
+ break;
+
+ case PC_BAD:
+ SNPRINTF(s,size,";A bad pCode is being used\n");
}
- break;
- case PC_BAD:
- SAFE_snprintf(&s,&size,";A bad pCode is being used\n");
- }
-
- return str;
+ return str;
}
/*-----------------------------------------------------------------*/
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;
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;
fprintf(of,"; exit point [can't find entry point]\n");
}
}
+
/*-----------------------------------------------------------------*/
/* pCodePrintLabel - prints label */
/*-----------------------------------------------------------------*/
return h;
-}
+}
+
/*-----------------------------------------------------------------*/
/* pBranchLink - given two pcodes, this function will link them */
/* together through their pBranches */
}
-#if 0
/*-----------------------------------------------------------------*/
-/* pBranchFind - find the pBranch in a pBranch chain that contains */
-/* a pCode */
/*-----------------------------------------------------------------*/
-static pBranch *pBranchFind(pBranch *pb,pCode *pc)
+static int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
{
- while(pb) {
-
- if(pb->pc == pc)
- return pb;
-
- pb = pb->next;
- }
-
- return NULL;
+ 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;
}
/*-----------------------------------------------------------------*/
-/* pCodeUnlink - Unlink the given pCode from its pCode chain. */
/*-----------------------------------------------------------------*/
-static void pCodeUnlink(pCode *pc)
+static int checkLabel(pCode *pc)
{
- pBranch *pb1,*pb2;
- pCode *pc1;
+ pBranch *pbr;
- if(!pc->prev || !pc->next) {
- fprintf(stderr,"unlinking bad pCode in %s:%d\n",__FILE__,__LINE__);
- exit(1);
+ if(pc && isPCI(pc)) {
+ pbr = PCI(pc)->label;
+ while(pbr) {
+ if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
+ return TRUE;
+
+ pbr = pbr->next;
+ }
}
- /* first remove the pCode from the chain */
- pc->prev->next = pc->next;
- pc->next->prev = pc->prev;
-
- /* Now for the hard part... */
-
- /* Remove the branches */
+ return FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* findLabelinpBlock - Search the pCode for a particular label */
+/*-----------------------------------------------------------------*/
+static pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
+{
+ pCode *pc;
- pb1 = pc->from;
- while(pb1) {
- pc1 = pb1->pc; /* Get the pCode that branches to the
- * one we're unlinking */
-
- /* search for the link back to this pCode (the one we're
- * unlinking) */
- if(pb2 = pBranchFind(pc1->to,pc)) {
- pb2->pc = pc->to->pc; // make the replacement
-
- /* if the pCode we're unlinking contains multiple 'to'
- * branches (e.g. this a skip instruction) then we need
- * to copy these extra branches to the chain. */
- if(pc->to->next)
- pBranchAppend(pb2, pc->to->next);
- }
-
- pb1 = pb1->next;
- }
-
-
-}
-#endif
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-#if 0
-static void genericAnalyze(pCode *pc)
-{
- switch(pc->type) {
- case PC_WILD:
- case PC_COMMENT:
- return;
- case PC_LABEL:
- case PC_FUNCTION:
- case PC_OPCODE:
- {
- // Go through the pCodes that are in pCode chain and link
- // them together through the pBranches. Note, the pCodes
- // are linked together as a contiguous stream like the
- // assembly source code lines. The linking here mimics this
- // except that comments are not linked in.
- //
- pCode *npc = pc->next;
- while(npc) {
- if(npc->type == PC_OPCODE || npc->type == PC_LABEL) {
- pBranchLink(pc,npc);
- return;
- } else
- npc = npc->next;
- }
- /* reached the end of the pcode chain without finding
- * an instruction we could link to. */
- }
- break;
- case PC_FLOW:
- fprintf(stderr,"analyze PC_FLOW\n");
-
- return;
- case PC_BAD:
- fprintf(stderr,";A bad pCode is being used\n");
-
- }
-}
-#endif
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-int compareLabel(pCode *pc, pCodeOpLabel *pcop_label)
-{
- 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;
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-int checkLabel(pCode *pc)
-{
- pBranch *pbr;
-
- if(pc && isPCI(pc)) {
- pbr = PCI(pc)->label;
- while(pbr) {
- if(isPCL(pbr->pc) && (PCL(pbr->pc)->key >= 0))
- return TRUE;
-
- pbr = pbr->next;
- }
- }
-
- return FALSE;
-}
-
-/*-----------------------------------------------------------------*/
-/* findLabelinpBlock - Search the pCode for a particular label */
-/*-----------------------------------------------------------------*/
-pCode * findLabelinpBlock(pBlock *pb,pCodeOpLabel *pcop_label)
-{
- pCode *pc;
-
- if(!pb)
- return NULL;
+ if(!pb)
+ return NULL;
for(pc = pb->pcHead; pc; pc = pc->next)
if(compareLabel(pc,pcop_label))
return NULL;
}
-/*-----------------------------------------------------------------*/
-/* findLabel - Search the pCode for a particular label */
-/*-----------------------------------------------------------------*/
-pCode * findLabel(pCodeOpLabel *pcop_label)
-{
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return NULL;
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if( (pc = findLabelinpBlock(pb,pcop_label)) != NULL)
- return pc;
- }
-
- fprintf(stderr,"Couldn't find label %s\n", pcop_label->pcop.name);
- return NULL;
-}
-
/*-----------------------------------------------------------------*/
/* findNextpCode - given a pCode, find the next of type 'pct' */
/* in the linked list */
return NULL;
}
+#if 0
/*-----------------------------------------------------------------*/
/* findPrevpCode - given a pCode, find the previous of type 'pct' */
/* in the linked list */
/*-----------------------------------------------------------------*/
-pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
+static pCode * findPrevpCode(pCode *pc, PC_TYPE pct)
{
while(pc) {
return NULL;
}
+#endif
/*-----------------------------------------------------------------*/
/* findNextInstruction - given a pCode, find the next instruction */
return NULL;
}
-/*-----------------------------------------------------------------*/
-/* findFunctionEnd - given a pCode find the end of the function */
-/* that contains it */
-/*-----------------------------------------------------------------*/
-pCode * findFunctionEnd(pCode *pc)
-{
- while(pc) {
- if(pc->type == PC_FUNCTION && !(PCF(pc)->fname))
- return pc;
-
- pc = pc->next;
- }
-
- fprintf(stderr,"Couldn't find function end\n");
- return NULL;
-}
-
-#if 0
-/*-----------------------------------------------------------------*/
-/* AnalyzeLabel - if the pCode is a label, then merge it with the */
-/* instruction with which it is associated. */
-/*-----------------------------------------------------------------*/
-static void AnalyzeLabel(pCode *pc)
-{
-
- pCodeUnlink(pc);
-
-}
-#endif
-
-#if 0
-static void AnalyzeGOTO(pCode *pc)
-{
-
- pBranchLink(pc,findLabel( (pCodeOpLabel *) (PCI(pc)->pcop) ));
-
-}
-
-static void AnalyzeSKIP(pCode *pc)
-{
-
- pBranchLink(pc,findNextInstruction(pc->next));
- pBranchLink(pc,findNextInstruction(pc->next->next));
-
-}
-
-static void AnalyzeRETURN(pCode *pc)
-{
-
- // branch_link(pc,findFunctionEnd(pc->next));
-
-}
-
-#endif
-
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
regs * getRegFromInstruction(pCode *pc)
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void AnalyzepBlock(pBlock *pb)
+static void AnalyzepBlock(pBlock *pb)
{
pCode *pc;
/*-----------------------------------------------------------------*/
/* */
/*-----------------------------------------------------------------*/
-void InsertpFlow(pCode *pc, pCode **pflow)
+static void InsertpFlow(pCode *pc, pCode **pflow)
{
if(*pflow)
PCFL(*pflow)->end = pc;
* point the instruction flow changes.
*/
/*-----------------------------------------------------------------*/
-void BuildFlow(pBlock *pb)
+static void BuildFlow(pBlock *pb)
{
pCode *pc;
pCode *last_pci=NULL;
* unBuildFlow removes pCodeFlow objects from a pCode chain
*/
/*-----------------------------------------------------------------*/
-void unBuildFlow(pBlock *pb)
+static void unBuildFlow(pBlock *pb)
{
pCode *pc,*pcnext;
}
+#if 0
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void dumpCond(int cond)
+static void dumpCond(int cond)
{
static char *pcc_str[] = {
fprintf(stderr, " %s\n",pcc_str[i]);
}
+#endif
+#if 0
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void FlowStats(pCodeFlow *pcflow)
+static void FlowStats(pCodeFlow *pcflow)
{
pCode *pc;
dumpCond(pcflow->outCond);
}
+#endif
/*-----------------------------------------------------------------*
* int isBankInstruction(pCode *pc) - examine the pCode *pc to determine
*
*-----------------------------------------------------------------*/
/*
-#define SET_BANK_BIT (1 << 16)
-#define CLR_BANK_BIT 0
-
static int isBankInstruction(pCode *pc)
{
regs *reg;
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
+static void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to)
{
pCodeFlowLink *fromLink, *toLink;
#if 0
* with a skip, then we know that there are two possible flow segments
* to which control may be passed.
*-----------------------------------------------------------------*/
-void LinkFlow(pBlock *pb)
+static void LinkFlow(pBlock *pb)
{
pCode *pc=NULL;
pCode *pcflow;
//fprintf(stderr,"linkflow \n");
+ if (!pb) return;
+
for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
pcflow != NULL;
pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
}
}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-int isPCinFlow(pCode *pc, pCode *pcflow)
-{
-
- if(!pc || !pcflow)
- return 0;
-
- if(!isPCI(pc) || !PCI(pc)->pcflow || !isPCFL(pcflow) )
- return 0;
-
- if( PCI(pc)->pcflow->pc.seq == pcflow->seq)
- return 1;
-
- return 0;
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-/*
-static void BanksUsedFlow2(pCode *pcflow)
-{
- pCode *pc=NULL;
-
- int bank = -1;
- bool RegUsed = 0;
-
- regs *reg;
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "BanksUsed - pcflow is not a flow object ");
- return;
- }
-
- pc = findNextInstruction(pcflow->next);
-
- PCFL(pcflow)->lastBank = -1;
-
- while(isPCinFlow(pc,pcflow)) {
-
- int bank_selected = isBankInstruction(pc);
-
- //if(PCI(pc)->pcflow)
- //fprintf(stderr,"BanksUsedFlow2, looking at seq %d\n",PCI(pc)->pcflow->pc.seq);
-
- if(bank_selected > 0) {
- //fprintf(stderr,"BanksUsed - mucking with bank %d\n",bank_selected);
-
- // This instruction is modifying banking bits before accessing registers
- if(!RegUsed)
- PCFL(pcflow)->firstBank = -1;
-
- if(PCFL(pcflow)->lastBank == -1)
- PCFL(pcflow)->lastBank = 0;
-
- bank = (1 << (bank_selected & (PIC_RP0_BIT | PIC_RP1_BIT)));
- if(bank_selected & SET_BANK_BIT)
- PCFL(pcflow)->lastBank |= bank;
-
-
- } else {
- reg = getRegFromInstruction(pc);
-
- if(reg && !isREGinBank(reg, bank)) {
- int allbanks = REGallBanks(reg);
- if(bank == -1)
- PCFL(pcflow)->firstBank = allbanks;
-
- PCFL(pcflow)->lastBank = allbanks;
-
- bank = allbanks;
- }
- RegUsed = 1;
- }
-
- pc = findNextInstruction(pc->next);
- }
-
- // fprintf(stderr,"BanksUsedFlow2 flow seq=%3d, first bank = 0x%03x, Last bank 0x%03x\n",
- // pcflow->seq,PCFL(pcflow)->firstBank,PCFL(pcflow)->lastBank);
-}
-*/
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-/*
-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);
- }
-
-}
-*/
-void pCodeReplace (pCode *old, pCode *new)
+static 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);
+ //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;
old->destruct (old);
}
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static void addpCodeComment(pCode *pc, const char *fmt, ...)
+{
+ va_list ap;
+ char buffer[4096];
+ pCode *newpc;
+
+ va_start(ap, fmt);
+ if (options.verbose || debug_verbose) {
+ buffer[0] = ';';
+ buffer[1] = ' ';
+ vsprintf(&buffer[2], fmt, ap);
+
+ newpc = newpCodeCharP(&buffer[0]); // strdup's the string
+ pCodeInsertAfter(pc, newpc);
+ }
+ va_end(ap);
+}
+
/*-----------------------------------------------------------------*/
/* Inserts a new pCodeInstruction before an existing one */
/*-----------------------------------------------------------------*/
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);
}
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-static void insertBankSwitch(pCodeInstruction *pci, int Set_Clear, int RP_BankBit)
-{
- pCode *new_pc;
-
- new_pc = newpCode((Set_Clear?POC_BSF:POC_BCF),popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
-
- insertPCodeInstruction(pci, PCI(new_pc));
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-static void insertBankSel(pCodeInstruction *pci, const char *name)
+static int insertBankSel(pCodeInstruction *pci, const char *name)
{
pCode *new_pc;
pCodeOp *pcop;
- // This is a NOP for single-banked devices.
- if (pic14_getMaxRam() < 0x80) return;
+ // Never BANKSEL STATUS, this breaks all kinds of code (e.g., interrupt handlers).
+ if (!strcmp("STATUS", name) || !strcmp("_STATUS", name)) return 0;
pcop = popCopyReg(PCOR(pci->pcop));
pcop->type = PO_GPR_REGISTER; // Sometimes the type is set to legacy 8051 - so override it
new_pc = newpCode(POC_BANKSEL, pcop);
insertPCodeInstruction(pci, PCI(new_pc));
+ return 1;
}
-/*-----------------------------------------------------------------*/
-/* 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 = -1; /* If the previous register is the same one again then no need to change bank. */
-static int BankSelect(pCodeInstruction *pci, int cur_bank, regs *reg)
+/*
+ * isValidIdChar - check if c may be present in an identifier
+ */
+static int isValidIdChar (char c)
{
- int bank;
- int a = reg->alias>>7;
- if ((a&3) == 3) {
- return cur_bank; // This register is available in all banks
- } else if ((a&1)&&((cur_bank==0)||(cur_bank==1))) {
- return cur_bank; // This register is available in banks 0 & 1
- } else if (a&2) {
- if (reg->address&0x80) {
- if ((cur_bank==1)||(cur_bank==3)) {
- return cur_bank; // This register is available in banks 1 & 3
- }
- } else {
- if ((cur_bank==0)||(cur_bank==1)) {
- return cur_bank; // This register is available in banks 0 & 2
- }
- }
- }
-
-#if 1
- if (LastRegIdx == reg->rIdx) // If this is the same register as last time then it is in same bank
- return cur_bank;
- LastRegIdx = reg->rIdx;
-#endif
-
- if (reg->isFixed) {
- bank = REG_BANK(reg);
- } else if (reg->isExtern) {
- bank = 'E'; // Unfixed extern registers are allocated by the linker therefore its bank is unknown
- } else {
- bank = 'L'; // Unfixed local registers are allocated by the linker therefore its bank is unknown
- }
- if (bank == 'E' || bank == 'L') { // Reg is now extern and linker to assign bank
- insertBankSel(pci, reg->name); // Let linker choose the bank selection
- } else if ((cur_bank == -1)||(cur_bank == 'L')||(cur_bank == 'E')) { // Current bank unknown and new register bank is known then can set bank bits
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- if (pic14_getMaxRam()&0x100)
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- } else { // Current bank and new register banks known - can set bank bits
- switch((cur_bank^bank) & 3) {
- case 0:
- break;
- case 1:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- break;
- case 2:
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- case 3:
- insertBankSwitch(pci, bank&1, PIC_RP0_BIT);
- if (pic14_getMaxRam()&0x100)
- insertBankSwitch(pci, bank&2, PIC_RP1_BIT);
- break;
- }
- }
-
- return bank;
+ if (c >= 'a' && c <= 'z') return 1;
+ if (c >= 'A' && c <= 'Z') return 1;
+ if (c >= '0' && c <= '9') return 1;
+ if (c == '_') return 1;
+ return 0;
}
-/*-----------------------------------------------------------------*/
-/* Check for bank selection pcodes instructions and modify */
-/* cur_bank to match. */
-/*-----------------------------------------------------------------*/
-static int IsBankChange(pCode *pc, regs *reg, int *cur_bank) {
-
- if (isSTATUS_REG(reg)) {
-
- if (PCI(pc)->op == POC_BCF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x2;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to 0 else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0;
- else
- *cur_bank = *cur_bank&0x1;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- if (PCI(pc)->op == POC_BSF) {
- int old_bank = *cur_bank;
- if (PCORB(PCI(pc)->pcop)->bit == PIC_RP0_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x1;
- else
- *cur_bank = (*cur_bank&0x2) | 0x1;
- LastRegIdx = reg->rIdx;
- } else if (PCORB(PCI(pc)->pcop)->bit == PIC_RP1_BIT) {
- /* If current bank is unknown or linker assigned then set to bit else just change the bit */
- if (*cur_bank & ~(0x3))
- *cur_bank = 0x2;
- else
- *cur_bank = (*cur_bank&0x1) | 0x2;
- LastRegIdx = reg->rIdx;
- }
- return old_bank != *cur_bank;
- }
-
- } else if (PCI(pc)->op == POC_BANKSEL) {
- int old_bank = *cur_bank;
- regs *r = PCOR(PCI(pc)->pcop)->r;
- *cur_bank = (!r || r->isExtern) ? 'E' : 'L';
- LastRegIdx = reg->rIdx;
- return old_bank != *cur_bank;
- }
-
- return 0;
-}
+/*
+ * bankcompare - check if two operand string refer to the same register
+ * This functions handles NAME and (NAME + x) in both operands.
+ * Returns 1 on same register, 0 on different (or unknown) registers.
+ */
+static int bankCompare(const char *op1, const char *op2)
+{
+ int i;
-/*-----------------------------------------------------------------*/
-/* Set bank selection if necessary */
-/*-----------------------------------------------------------------*/
-static int DoBankSelect(pCode *pc, int cur_bank) {
- pCode *pcprev;
- regs *reg;
-
- if(!isPCI(pc))
- return cur_bank;
-
- if (isCALL(pc)) {
- pCode *pcf = findFunction(get_op_from_instruction(PCI(pc)));
- LastRegIdx = -1; /* do not know which register is touched in the called function... */
- if (pcf && isPCF(pcf)) {
- pCode *pcfr;
- int rbank = 'U'; // Undetermined
- FixRegisterBanking(pcf->pb,cur_bank); // Ensure this block has had its banks selection done
- // Check all the returns to work out what bank is selected
- for (pcfr=pcf->pb->pcHead; pcfr; pcfr=pcfr->next) {
- if (isPCI(pcfr)) {
- if ((PCI(pcfr)->op==POC_RETURN) || (PCI(pcfr)->op==POC_RETLW)) {
- if (rbank == 'U')
- rbank = PCI(pcfr)->pcflow->lastBank;
- else
- if (rbank != PCI(pcfr)->pcflow->lastBank)
- return -1; // Unknown bank - multiple returns with different banks
- }
- }
- }
- if (rbank == 'U')
- return -1; // Unknown bank
- return rbank;
- } else if (isPCOS(PCI(pc)->pcop) && PCOS(PCI(pc)->pcop)->isPublic) {
- /* Extern functions may use registers in different bank - must call banksel */
- return -1; /* Unknown bank */
- }
- /* play safe... */
- return -1;
- }
-
- if ((isPCI(pc)) && (PCI(pc)->op == POC_BANKSEL)) {
- return -1; /* New bank unknown - linkers choice. */
- }
-
- reg = getRegFromInstruction(pc);
- if (reg) {
- if (IsBankChange(pc,reg,&cur_bank))
- return cur_bank;
- if (!isPCI_LIT(pc)) {
-
- /* Examine the instruction before this one to make sure it is
- * not a skip type instruction */
- pcprev = findPrevpCode(pc->prev, PC_OPCODE);
-
- /* This approach does not honor the presence of labels at this instruction... */
- //if(!pcprev || (pcprev && !isPCI_SKIP(pcprev))) {
- cur_bank = BankSelect(PCI(pc),cur_bank,reg);
- //} else {
- // cur_bank = BankSelect(PCI(pcprev),cur_bank,reg);
- //}
- 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;
+ if (!op1 && !op2) return 0; // both unknown, might be different though!
+ if (!op1 || !op2) return 0;
+
+ // find start of operand name
+ while (op1[0] == '(' || op1[0] == ' ') op1++;
+ while (op2[0] == '(' || op2[0] == ' ') op2++;
+
+ // compare till first non-identifier character
+ for (i = 0; (op1[i] == op2[i]) && isValidIdChar(op1[i]); i++);
+ if (!isValidIdChar(op1[i]) && !isValidIdChar(op2[i])) return 1;
+
+ // play safe---assume different operands
+ return 0;
}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
/*
-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;
- pc = findNextInstruction(pc->next);
-
- }
-
- if(pcprev && cur_bank) {
- // Set bank state to unknown at the end of each flow block
- cur_bank = -1;
- }
-
+ * Interface to BANKSEL generation.
+ * This function should return != 0 iff str1 and str2 denote operands that
+ * are known to be allocated into the same bank. Consequently, there will
+ * be no BANKSEL emitted if str2 is accessed while str1 has been used to
+ * select the current bank just previously.
+ *
+ * If in doubt, return 0.
+ */
+static int
+pic14_operandsAllocatedInSameBank(const char *str1, const char *str2) {
+ // see glue.c(pic14printLocals)
+
+ if (getenv("SDCC_PIC14_SPLIT_LOCALS")) {
+ // no clustering applied, each register resides in its own bank
+ } else {
+ // check whether BOTH names are local registers
+ // XXX: This is some kind of shortcut, should be safe...
+ // In this model, all r0xXXXX are allocated into a single section
+ // per file, so no BANKSEL required if accessing a r0xXXXX after a
+ // (different) r0xXXXX. Works great for multi-byte operands.
+ if (str1 && str2 && str1[0] == 'r' && str2[0] == 'r') return (1);
+ } // if
+
+ // assume operands in different banks
+ return (0);
}
-*/
+
/*-----------------------------------------------------------------*/
-/*int compareBankFlow - compare the banking requirements between */
-/* flow objects. */
/*-----------------------------------------------------------------*/
-/*
-int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
+static int sameBank(regs *reg, regs *previous_reg, const char *new_bank, const char *cur_bank, unsigned max_mask)
{
-
- 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;
-
+ if (!cur_bank) return 0;
+
+ 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
+
+ // regard '(regname + X)' and '(regname + Y)' as equal
+ if (reg && reg->name && bankCompare(reg->name, cur_bank)) return 1;
+ if (new_bank && bankCompare(new_bank, cur_bank)) return 1;
+
+ // check allocation policy from glue.c
+ if (reg && reg->name && pic14_operandsAllocatedInSameBank(reg->name, cur_bank)) return 1;
+ if (new_bank && pic14_operandsAllocatedInSameBank(new_bank, cur_bank)) return 1;
+
+ // seems to be a different operand--might be a different bank
+ //printf ("BANKSEL from %s to %s/%s\n", cur_bank, reg->name, new_bank);
+ return 0;
}
-*/
+
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-/*
-void FixBankFlow(pBlock *pb)
+static void FixRegisterBanking(pBlock *pb)
{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
- pCode *pcflow_max_To=NULL;
- pCode *pcflow_max_From=NULL;
- int max_ToConflicts=0;
- int max_FromConflicts=0;
-
- /fprintf(stderr,"Fix Bank flow \n");
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
-
-
- / *
- First loop through all of the flow objects in this pcode block
- and fix the ones that have banking conflicts between the
- entry and exit.
- * /
-
- //fprintf(stderr, "FixBankFlow - Phase 1\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
-
- if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank &&
- PCFL(pcflow)->firstBank >= 0 &&
- PCFL(pcflow)->lastBank >= 0 ) {
-
- int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
- PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
-
- FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
- BanksUsedFlow2(pcflow);
-
- }
+ 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;
}
- //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 * /
-
- }
-
- nFlows = 0;
- nConflicts = 0;
-
- pcfl = setFirstItem(PCFL(pcflow)->to);
- while (pcfl) {
-
- pc = PCODE(pcfl->pcflow);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
- nFlows++;
-
- pcfl=setNextItem(PCFL(pcflow)->to);
- }
-
- if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
- //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
-
- FixRegisterBankingInFlow(PCFL(pcflow),-1);
- BanksUsedFlow2(pcflow);
- }
+ // 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;
}
-
- / *
- Loop through the flow objects again and find the ones with the
- maximum conflicts
- * /
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
- pcflow_max_To = pcflow;
-
- if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
- pcflow_max_From = pcflow;
+
+ // 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.");
+ new_bank = "UNKNOWN";
+ new_mask = 0; // unknown, assume worst case
}
- / *
- if(pcflow_max_To)
- fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_To)->pc.seq,
- PCFL(pcflow_max_To)->ToConflicts);
-
- if(pcflow_max_From)
- fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_From)->pc.seq,
- PCFL(pcflow_max_From)->FromConflicts);
- * /
-}
-*/
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void DumpFlow(pBlock *pb)
-{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
-
- fprintf(stderr,"Dump flow \n");
- pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
+ // 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;
- }
- 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);
- }
-
- }
-
- }
-
+ }
+
+ // 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;
+ }
+
+ 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
+
+ if (insertBankSel(pci, new_bank)) {
+ cur_mask = new_mask;
+ cur_bank = new_bank;
+ previous_reg = reg;
+ } // if
+ } // if
+ } // if
+ } // for
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-int OptimizepBlock(pBlock *pb)
+static int OptimizepBlock(pBlock *pb)
{
pCode *pc, *pcprev;
int matches =0;
/*-----------------------------------------------------------------*/
/* pBlockRemoveUnusedLabels - remove the pCode labels from the */
/*-----------------------------------------------------------------*/
-pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
+static pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
{
pCode *pc;
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-void exchangeLabels(pCodeLabel *pcl, pCode *pc)
+static void exchangeLabels(pCodeLabel *pcl, pCode *pc)
{
char *s=NULL;
/* pBlockRemoveUnusedLabels - remove the pCode labels from the */
/* pCode chain if they're not used. */
/*-----------------------------------------------------------------*/
-void pBlockRemoveUnusedLabels(pBlock *pb)
+static void pBlockRemoveUnusedLabels(pBlock *pb)
{
pCode *pc; pCodeLabel *pcl;
- if(!pb)
+ if(!pb || !pb->pcHead)
return;
for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
* refers to it */
if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
- //if( !findInstructionUsingLabel(pcl, pb->pcHead)) {
/* Couldn't find an instruction that refers to this label
* So, unlink the pCode label from it's pCode chain
* and destroy the label */
/* Now loop through the pBlock and merge the labels with the opcodes */
pc = pb->pcHead;
- // for(pc = pb->pcHead; pc; pc = pc->next) {
while(pc) {
pCode *pcn = pc->next;
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-int OptimizepCode(char dbName)
+static int OptimizepCode(char dbName)
{
#define MAX_PASSES 4
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)
+static void pBlockDestruct(pBlock *pb)
{
if(!pb)
/* name dbName and combine them */
/* into one block */
/*-----------------------------------------------------------------*/
-void mergepBlocks(char dbName)
+static void mergepBlocks(char dbName)
{
pBlock *pb, *pbmerged = NULL,*pbn;
/* register. */
/*-----------------------------------------------------------------*/
-void AnalyzeFlow(int level)
+static void AnalyzeFlow(int level)
{
- static int times_called=0;
-
- pBlock *pb;
-
- if(!the_pFile)
- return;
-
-
- /* if this is not the first time this function has been called,
- then clean up old flow information */
- if(times_called++) {
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- unBuildFlow(pb);
-
- RegsUnMapLiveRanges();
-
- }
-
- GpcFlowSeq = 1;
-
- /* Phase 2 - Flow Analysis - Register Banking
- *
- * In this phase, the individual flow blocks are examined
- * and register banking is fixed.
- */
-
- //for(pb = the_pFile->pbHead; pb; pb = pb->next)
- //FixRegisterBanking(pb);
-
- /* Phase 2 - Flow Analysis
- *
- * In this phase, the pCode is partition into pCodeFlow
- * blocks. The flow blocks mark the points where a continuous
- * stream of instructions changes flow (e.g. because of
- * a call or goto or whatever).
- */
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- BuildFlow(pb);
-
-
- /* Phase 2 - Flow Analysis - linking flow blocks
- *
- * In this phase, the individual flow blocks are examined
- * 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.
- */
-
- 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
- */
-
- // for(pb = the_pFile->pbHead; pb; pb = pb->next)
- // FixBankFlow(pb);
-
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- pCodeRegMapLiveRanges(pb);
-
- RemoveUnusedRegisters();
-
- // for(pb = the_pFile->pbHead; pb; pb = pb->next)
- pCodeRegOptimizeRegUsage(level);
-
- OptimizepCode('*');
-
- /*
- for(pb = the_pFile->pbHead; pb; pb = pb->next)
- DumpFlow(pb);
- */
- /* debug stuff */
- /*
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- pCode *pcflow;
- for( 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));
- }
- }
- */
+ static int times_called=0;
+
+ pBlock *pb;
+
+ if(!the_pFile)
+ return;
+
+
+ /* if this is not the first time this function has been called,
+ then clean up old flow information */
+ if(times_called++) {
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ unBuildFlow(pb);
+
+ RegsUnMapLiveRanges();
+
+ }
+
+ GpcFlowSeq = 1;
+
+ /* Phase 2 - Flow Analysis - Register Banking
+ *
+ * In this phase, the individual flow blocks are examined
+ * and register banking is fixed.
+ */
+
+ //for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ //FixRegisterBanking(pb);
+
+ /* Phase 2 - Flow Analysis
+ *
+ * In this phase, the pCode is partition into pCodeFlow
+ * blocks. The flow blocks mark the points where a continuous
+ * stream of instructions changes flow (e.g. because of
+ * a call or goto or whatever).
+ */
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ BuildFlow(pb);
+
+
+ /* Phase 2 - Flow Analysis - linking flow blocks
+ *
+ * In this phase, the individual flow blocks are examined
+ * 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.
+ */
+
+ 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
+ */
+
+// for(pb = the_pFile->pbHead; pb; pb = pb->next)
+// FixBankFlow(pb);
+
+
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegMapLiveRanges(pb);
+
+ RemoveUnusedRegisters();
+
+// for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ pCodeRegOptimizeRegUsage(level);
+
+ OptimizepCode('*');
+
+ /*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next)
+ DumpFlow(pb);
+ */
+ /* debug stuff */
+ /*
+ for(pb = the_pFile->pbHead; pb; pb = pb->next) {
+ pCode *pcflow;
+ for( 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));
+ }
+ }
+ */
}
/*-----------------------------------------------------------------*/
AnalyzeFlow(0);
AnalyzeFlow(1);
- // for(pb = the_pFile->pbHead; pb; pb = pb->next)
- // BanksUsedFlow(pb);
for(pb = the_pFile->pbHead; pb; pb = pb->next)
- FixRegisterBanking(pb,-1); // cur_bank is unknown
+ FixRegisterBanking(pb);
+
+ AnalyzeFlow(0);
+ AnalyzeFlow(1);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-DEFSETFUNC (resetrIdx)
+static DEFSETFUNC (resetrIdx)
{
regs *r = (regs *)item;
if (!r->isFixed) {
/*-----------------------------------------------------------------*/
/* InitRegReuse - Initialises variables for code analyzer */
/*-----------------------------------------------------------------*/
-
-void InitReuseReg(void)
+static void InitReuseReg(void)
{
/* Find end of statically allocated variables for start idx */
/* Start from begining of GPR. Note may not be 0x20 on some PICs */
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
-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;
}
/*------------------------------------------------------------------*/
void ReuseReg(void)
{
pBlock *pb;
- if (!the_pFile) return;
+ if (options.noOverlay || !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);
}
}
/* */
/*-----------------------------------------------------------------*/
-void buildCallTree(void )
+static void buildCallTree(void)
{
pBranch *pbr;
pBlock *pb;
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;
for(pc = pb->pcHead; pc; pc = pc->next) {
buildCallTree();
}
-/*-----------------------------------------------------------------*/
-/* ispCodeFunction - returns true if *pc is the pCode of a */
-/* function */
-/*-----------------------------------------------------------------*/
-bool ispCodeFunction(pCode *pc)
-{
-
- if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
- return 1;
-
- return 0;
-}
-
/*-----------------------------------------------------------------*/
/* findFunction - Search for a function by name (given the name) */
/* in the set of all functions that are in a pBlock */
/* (note - I expect this to change because I'm planning to limit */
/* pBlock's to just one function declaration */
/*-----------------------------------------------------------------*/
-pCode *findFunction(char *fname)
+static pCode *findFunction(char *fname)
{
pBlock *pb;
pCode *pc;
return NULL;
}
-void MarkUsedRegisters(set *regset)
-{
-
- regs *r1,*r2;
-
- for(r1=setFirstItem(regset); r1; r1=setNextItem(regset)) {
- r2 = pic14_regWithIdx(r1->rIdx);
- if (r2) {
- r2->isFree = 0;
- r2->wasUsed = 1;
- }
- }
-}
-
-void pBlockStats(FILE *of, pBlock *pb)
+static void pBlockStats(FILE *of, pBlock *pb)
{
pCode *pc;
}
}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
#if 0
-static void sequencepCode(void)
-{
- pBlock *pb;
- pCode *pc;
-
-
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
-
- pb->seq = GpCodeSequenceNumber+1;
-
- for( pc = pb->pcHead; pc; pc = pc->next)
- pc->seq = ++GpCodeSequenceNumber;
- }
-
-}
-#endif
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-/*
-set *register_usage(pBlock *pb)
-{
- pCode *pc,*pcn;
- set *registers=NULL;
- set *registersInCallPath = NULL;
-
- / * check recursion * /
-
- pc = setFirstItem(pb->function_entries);
-
- if(!pc)
- return registers;
-
- pb->visited = 1;
-
- 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;
-
- 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;
- if(newreg->name)
- r2->name = Safe_strdup(newreg->name);
- else
- r2->name = NULL;
- newreg->isFree = 0;
- newreg->wasUsed = 1;
- }
- 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);
- }
-
- }// else
- // 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;
-}
-*/
-
/*-----------------------------------------------------------------*/
/* printCallTree - writes the call tree to a file */
/* */
/*-----------------------------------------------------------------*/
-void pct2(FILE *of,pBlock *pb,int indent)
+static void pct2(FILE *of,pBlock *pb,int indent)
{
pCode *pc,*pcn;
int i;
}
+#endif
+#if 0
+/*-----------------------------------------------------------------*/
+/* ispCodeFunction - returns true if *pc is the pCode of a */
+/* function */
+/*-----------------------------------------------------------------*/
+static bool ispCodeFunction(pCode *pc)
+{
+
+ if(pc && pc->type == PC_FUNCTION && PCF(pc)->fname)
+ return 1;
+
+ return 0;
+}
/*-----------------------------------------------------------------*/
/* printCallTree - writes the call tree to a file */
/* */
/*-----------------------------------------------------------------*/
-void printCallTree(FILE *of)
+static void printCallTree(FILE *of)
{
pBranch *pbr;
pBlock *pb;
fprintf(of,"block dbname: %c\n", getpBlock_dbName(pb));
}
}
-
+#endif
/*-----------------------------------------------------------------*/
/* */
/*-----------------------------------------------------------------*/
-void InlineFunction(pBlock *pb)
+static void InlineFunction(pBlock *pb)
{
pCode *pc;
pCode *pc_call;
unBuildFlow(pb);
}
+