PO_GPR_REGISTER, // A general purpose register
PO_GPR_BIT, // A bit of a general purpose register
PO_GPR_TEMP, // A general purpose temporary register
+ PO_GPR_POINTER, // A general purpose pointer
PO_SFR_REGISTER, // A special function register (e.g. PORTA)
PO_PCL, // Program counter Low register
PO_PCLATH, // Program counter Latch high register
POC_COMFW,
POC_CLRF,
POC_CLRW,
+ POC_CLRWDT,
POC_DECF,
POC_DECFW,
POC_DECFSZ,
POC_TRIS,
POC_XORLW,
POC_XORWF,
- POC_XORFW
+ POC_XORFW,
+ POC_BANKSEL,
+ POC_PAGESEL,
+
+ MAX_PIC14MNEMONICS
} PIC_OPCODE;
PC_FUNCTION, /* Function start or end */
PC_WILD, /* wildcard - an opcode place holder used
* in the pCode peep hole optimizer */
- PC_CSOURCE /* C-Source Line */
+ PC_CSOURCE, /* C-Source Line */
+ PC_BAD /* Mark the pCode object as being bad */
} PC_TYPE;
/************************************************/
/*************** Structures ********************/
/************************************************/
+/* These are here as forward references - the
+ * full definition of these are below */
struct pCode;
struct pCodeWildBlock;
+struct pCodeRegLives;
/*************************************************
pBranch
typedef struct pCodeOpImmd
{
pCodeOp pcop;
- int offset; /* low,med, or high byte of immediat value */
- int index; /* add this to the immediate value */
- unsigned _const:1; /* is in code space */
+ int offset; /* low,med, or high byte of immediate value */
+ int index; /* add this to the immediate value */
+ unsigned _const:1; /* is in code space */
+ unsigned _function:1; /* is a (pointer to a) function */
+
+ int rIdx; /* If this immd points to a register */
+ struct regs *r; /* then this is the reg. */
} pCodeOpImmd;
{
pCodeOp pcop;
int key;
+ int offset; /* low or high byte of label */
} pCodeOpLabel;
typedef struct pCodeOpReg
} pCodeOpRegBit;
+typedef struct pCodeOpRegPtr
+{
+ pCodeOpReg pcor; // The Register containing this bit
+
+ // PIC_OPTYPE subtype; // The type of this register.
+ // unsigned int inBitSpace: 1; /* True if in bit space, else
+
+} pCodeOpRegPtr;
+
+typedef struct pCodeOpStr /* Only used here for the name of fn being called or jumped to */
+{
+ pCodeOp pcop;
+ unsigned isPublic: 1; /* True if not static ie extern */
+} pCodeOpStr;
+
typedef struct pCodeOpWild
{
pCodeOp pcop;
struct pCode *prev; // The pCode objects are linked together
struct pCode *next; // in doubly linked lists.
+ unsigned id; // unique ID number for all pCodes to assist in debugging
int seq; // sequence number
struct pBlock *pb; // The pBlock that contains this pCode.
causes a branch, a Flow object will be inserted into
the pCode chain to mark the beginning of the next
contiguous chunk.
+
**************************************************/
typedef struct pCodeFlow
pCode *end; /* Last pCode in this flow. Note that
the first pCode is pc.next */
- set **uses; /* map the pCode instruction inCond and outCond conditions
+ /* set **uses; * map the pCode instruction inCond and outCond conditions
* in this array of set's. The reason we allocate an
* array of pointers instead of declaring each type of
* usage is because there are port dependent usage definitions */
- int nuses; /* number of uses sets */
+ //int nuses; /* number of uses sets */
set *from; /* flow blocks that can send control to this flow block */
set *to; /* flow blocks to which this one can send control */
+ struct pCodeFlow *ancestor; /* The most immediate "single" pCodeFlow object that
+ * executes prior to this one. In many cases, this
+ * will be just the previous */
int inCond; /* Input conditions - stuff assumed defined at entry */
int outCond; /* Output conditions - stuff modified by flow block */
+ int firstBank; /* The first and last bank flags are the first and last */
+ int lastBank; /* register banks used within one flow object */
+
+ int FromConflicts;
+ int ToConflicts;
+
+ set *registers;/* Registers used in this flow */
+
} pCodeFlow;
+/*************************************************
+ pCodeFlowLink
+
+ The Flow Link object is used to record information
+ about how consecutive excutive Flow objects are related.
+ The pCodeFlow objects demarcate the pCodeInstructions
+ into contiguous chunks. The FlowLink records conflicts
+ in the discontinuities. For example, if one Flow object
+ references a register in bank 0 and the next Flow object
+ references a register in bank 1, then there is a discontinuity
+ in the banking registers.
+
+*/
+typedef struct pCodeFlowLink
+{
+ pCodeFlow *pcflow; /* pointer to linked pCodeFlow object */
+
+ int bank_conflict; /* records bank conflicts */
+
+} pCodeFlowLink;
+
/*************************************************
pCodeInstruction
unsigned int isBitInst: 1; /* e.g. BCF */
unsigned int isBranch: 1; /* True if this is a branching instruction */
unsigned int isSkip: 1; /* True if this is a skip instruction */
+ unsigned int isLit: 1; /* True if this instruction has an literal operand */
PIC_OPCODE inverted_op; /* Opcode of instruction that's the opposite of this one */
unsigned int inCond; // Input conditions for this instruction
pBranch *to; // pCodes that execute after
pBranch *label; // pCode instructions that have labels
- int ncalled; /* Number of times function is called */
+ int ncalled; /* Number of times function is called */
+ unsigned isPublic:1; /* True if the fn is not static and can be called from another module (ie a another c or asm file) */
} pCodeFunction;
set *function_calls;
set *tregisters;
+ set *FlowTree;
unsigned visited:1; /* set true if traversed in call tree */
unsigned seq; /* sequence number of this pBlock */
char *cmd;
} peepCommand;
-
/*************************************************
pCode Macros
#define PCL(x) ((pCodeLabel *)(x))
#define PCF(x) ((pCodeFunction *)(x))
#define PCFL(x) ((pCodeFlow *)(x))
+#define PCFLINK(x)((pCodeFlowLink *)(x))
#define PCW(x) ((pCodeWild *)(x))
#define PCCS(x) ((pCodeCSource *)(x))
#define PCOLAB(x) ((pCodeOpLabel *)(x))
#define PCOR(x) ((pCodeOpReg *)(x))
#define PCORB(x) ((pCodeOpRegBit *)(x))
+#define PCOS(x) ((pCodeOpStr *)(x))
#define PCOW(x) ((pCodeOpWild *)(x))
#define PBR(x) ((pBranch *)(x))
#define PCWB(x) ((pCodeWildBlock *)(x))
+#define isPCOLAB(x) ((PCOP(x)->type) == PO_LABEL)
+#define isPCOS(x) ((PCOP(x)->type) == PO_STR)
+
+
+/*
+ macros for checking pCode types
+*/
+#define isPCI(x) ((PCODE(x)->type == PC_OPCODE))
+#define isPCFL(x) ((PCODE(x)->type == PC_FLOW))
+#define isPCF(x) ((PCODE(x)->type == PC_FUNCTION))
+#define isPCL(x) ((PCODE(x)->type == PC_LABEL))
+#define isPCW(x) ((PCODE(x)->type == PC_WILD))
+#define isPCCS(x) ((PCODE(x)->type == PC_CSOURCE))
+
+/*
+ macros for checking pCodeInstruction types
+*/
+#define isCALL(x) (isPCI(x) && (PCI(x)->op == POC_CALL))
+#define isPCI_BRANCH(x) (isPCI(x) && PCI(x)->isBranch)
+#define isPCI_SKIP(x) (isPCI(x) && PCI(x)->isSkip)
+#define isPCI_LIT(x) (isPCI(x) && PCI(x)->isLit)
+#define isPCI_BITSKIP(x)(isPCI_SKIP(x) && PCI(x)->isBitInst)
+
+
+#define isSTATUS_REG(r) ((r)->pc_type == PO_STATUS)
+
/*-----------------------------------------------------------------*
* pCode functions.
*-----------------------------------------------------------------*/
pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop); // Create a new pCode given an operand
pCode *newpCodeCharP(char *cP); // Create a new pCode given a char *
pCode *newpCodeInlineP(char *cP); // Create a new pCode given a char *
-pCode *newpCodeFunction(char *g, char *f); // Create a new function
+pCode *newpCodeFunction(char *g, char *f,int); // Create a new function
pCode *newpCodeLabel(char *name,int key); // Create a new label given a key
pCode *newpCodeCSource(int ln, char *f, char *l); // Create a new symbol line
+pCode *findNextInstruction(pCode *pci);
+pCode *findNextpCode(pCode *pc, PC_TYPE pct);
+pCode *pCodeInstructionCopy(pCodeInstruction *pci,int invert);
+
pBlock *newpCodeChain(memmap *cm,char c, pCode *pc); // Create a new pBlock
void printpBlock(FILE *of, pBlock *pb); // Write a pBlock to a file
void printpCode(FILE *of, pCode *pc); // Write a pCode to a file
void printCallTree(FILE *of);
void pCodePeepInit(void);
void pBlockConvert2ISR(pBlock *pb);
+void pCodeInsertAfter(pCode *pc1, pCode *pc2);
+void pCodeInsertBefore(pCode *pc1, pCode *pc2);
+void pCodeDeleteChain(pCode *f,pCode *t);
pCodeOp *newpCodeOpLabel(char *name, int key);
-pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space);
+pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space,int is_func);
pCodeOp *newpCodeOpLit(int lit);
pCodeOp *newpCodeOpBit(char *name, int bit,int inBitSpace);
pCodeOp *newpCodeOpRegFromStr(char *name);
pCodeOp *newpCodeOp(char *name, PIC_OPTYPE p);
pCodeOp *pCodeOpCopy(pCodeOp *pcop);
+pCodeOp *popCopyReg(pCodeOpReg *pc);
+
+int isPCinFlow(pCode *pc, pCode *pcflow);
+struct regs * getRegFromInstruction(pCode *pc);
extern void pcode_test(void);
extern pCodeOpReg pc_fsr;
extern pCodeOpReg pc_pcl;
extern pCodeOpReg pc_pclath;
-extern pCodeOpReg pc_kzero;
-extern pCodeOpReg pc_wsave; /* wsave and ssave are used to save W and the Status */
+extern pCodeOpReg pc_wsave; /* wsave, ssave and psave are used to save W, the Status and PCLATH*/
extern pCodeOpReg pc_ssave; /* registers during an interrupt */
+extern pCodeOpReg pc_psave; /* registers during an interrupt */
#endif // __PCODE_H__
projects / fw / sdcc / blobdiff