* The double parenthesis (()) are necessary
*
***********************************************************************/
-#define PCODE_DEBUG
+//#define PCODE_DEBUG
#ifdef PCODE_DEBUG
#define DFPRINTF(args) (fprintf args)
typedef enum
{
PC_COMMENT=0, /* pCode is a comment */
+ PC_INLINE, /* user's inline code */
PC_OPCODE, /* PORT dependent opcode */
PC_LABEL, /* assembly label */
PC_FLOW, /* flow analysis */
PC_FUNCTION, /* Function start or end */
- PC_WILD /* wildcard - an opcode place holder used
+ PC_WILD, /* wildcard - an opcode place holder used
* in the pCode peep hole optimizer */
+ PC_CSOURCE /* C-Source Line */
} PC_TYPE;
/************************************************/
/*************** Structures ********************/
/************************************************/
struct pCode;
+struct pCodeWildBlock;
/*************************************************
pBranch
typedef struct pCodeOpImmd
{
pCodeOp pcop;
- int offset;
+ 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 */
+
} pCodeOpImmd;
typedef struct pCodeOpLabel
} pCodeOpRegBit;
+typedef struct pCodeOpWild
+{
+ pCodeOp pcop;
+
+ struct pCodeWildBlock *pcwb;
+
+ int id; /* index into an array of char *'s that will match
+ * the wild card. The array is in *pcp. */
+ pCodeOp *subtype; /* Pointer to the Operand type into which this wild
+ * card will be expanded */
+ pCodeOp *matched; /* When a wild matches, we'll store a pointer to the
+ * opcode we matched */
+
+} pCodeOpWild;
+
+
/*************************************************
pCode
} pCodeComment;
+/*************************************************
+ pCodeComment
+**************************************************/
+
+typedef struct pCodeCSource
+{
+
+ pCode pc;
+
+ int line_number;
+ char *line;
+ char *file_name;
+
+} pCodeCSource;
+
+
/*************************************************
pCodeFlow
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;
+
} 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
pBranch *to; // pCodes that execute after
pBranch *label; // pCode instructions that have labels
- pCodeOp *pcop; /* Operand, if this instruction has one */
-
- pCodeFlow *pcflow; /* flow block to which this instruction belongs */
+ pCodeOp *pcop; /* Operand, if this instruction has one */
+ pCodeFlow *pcflow; /* flow block to which this instruction belongs */
+ pCodeCSource *cline; /* C Source from which this instruction was derived */
unsigned int num_ops; /* Number of operands (0,1,2 for mid range pics) */
unsigned int isModReg: 1; /* If destination is W or F, then 1==F */
unsigned int isBranch: 1; /* True if this is a branching instruction */
unsigned int isSkip: 1; /* True if this is a skip instruction */
+ PIC_OPCODE inverted_op; /* Opcode of instruction that's the opposite of this one */
unsigned int inCond; // Input conditions for this instruction
unsigned int outCond; // Output 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 */
+
} pCodeFunction;
* - this wild card will get expanded into that pCode
* that is stored at this index */
+ /* Conditions on wild pcode instruction */
+ int mustBeBitSkipInst:1;
+ int mustNotBeBitSkipInst:1;
+ int invertBitSkipInst:1;
pCodeOp *operand; // Optional operand
pCodeOp *label; // Optional label
+/*************************************************
+ pCodeWildBlock
+
+ The pCodeWildBlock object keeps track of the wild
+ variables, operands, and opcodes that exist in
+ a pBlock.
+**************************************************/
+typedef struct pCodeWildBlock {
+ pBlock *pb;
+ struct pCodePeep *pcp; // pointer back to ... I don't like this...
+
+ int nvars; // Number of wildcard registers in target.
+ char **vars; // array of pointers to them
+
+ int nops; // Number of wildcard operands in target.
+ pCodeOp **wildpCodeOps; // array of pointers to the pCodeOp's.
+
+ int nwildpCodes; // Number of wildcard pCodes in target/replace
+ pCode **wildpCodes; // array of pointers to the pCode's.
+
+} pCodeWildBlock;
+
/*************************************************
pCodePeep
pCode chain.
**************************************************/
typedef struct pCodePeep {
+ pCodeWildBlock target; // code we'd like to optimize
+ pCodeWildBlock replace; // and this is what we'll optimize it with.
- pBlock *target; // code we'd like to optimize
- pBlock *replace; // and this is what we'll optimize it with.
+ //pBlock *target;
+ //pBlock replace; // and this is what we'll optimize it with.
- int nvars; // Number of wildcard registers in target.
- char **vars; // array of pointers to them
- int nops; // Number of wildcard operands in target.
- pCodeOp **wildpCodeOps; // array of pointers to the pCodeOp's.
-
- int nwildpCodes; // Number of wildcard pCodes in target/replace
- pCode **wildpCodes; // array of pointers to the pCode's.
/* (Note: a wildcard register is a place holder. Any register
} pCodePeep;
-typedef struct pCodeOpWild
-{
- pCodeOp pcop;
- //PIC_OPTYPE subtype; Wild get's expanded to this by the optimizer
- pCodePeep *pcp; // pointer to the parent peep block
- int id; /* index into an array of char *'s that will match
- * the wild card. The array is in *pcp. */
- pCodeOp *subtype; /* Pointer to the Operand type into which this wild
- * card will be expanded */
- pCodeOp *matched; /* When a wild matches, we'll store a pointer to the
- * opcode we matched */
+/*************************************************
+
+ pCode peep command definitions
+
+ Here are some special commands that control the
+way the peep hole optimizer behaves
+
+**************************************************/
+
+enum peepCommandTypes{
+ NOTBITSKIP = 0,
+ BITSKIP,
+ INVERTBITSKIP,
+ _LAST_PEEP_COMMAND_
+};
+
+/*************************************************
+ peepCommand structure stores the peep commands.
+
+**************************************************/
+
+typedef struct peepCommand {
+ int id;
+ char *cmd;
+} peepCommand;
-} pCodeOpWild;
/*************************************************
pCode Macros
#define PCI(x) ((pCodeInstruction *)(x))
#define PCL(x) ((pCodeLabel *)(x))
#define PCF(x) ((pCodeFunction *)(x))
-#define PCFL(x) ((pCodeFlow *)(x))
+#define PCFL(x) ((pCodeFlow *)(x))
#define PCW(x) ((pCodeWild *)(x))
+#define PCCS(x) ((pCodeCSource *)(x))
#define PCOP(x) ((pCodeOp *)(x))
//#define PCOB(x) ((pCodeOpBit *)(x))
#define PBR(x) ((pBranch *)(x))
+#define PCWB(x) ((pCodeWildBlock *)(x))
+
/*-----------------------------------------------------------------*
* 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 *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
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 copypCode(FILE *of, char dbName); // Write all pBlocks with dbName to *of
void movepBlock2Head(char dbName); // move pBlocks around
void AnalyzepCode(char dbName);
-void OptimizepCode(char dbName);
+int OptimizepCode(char dbName);
void printCallTree(FILE *of);
void pCodePeepInit(void);
void pBlockConvert2ISR(pBlock *pb);
pCodeOp *newpCodeOpLabel(char *name, int key);
-pCodeOp *newpCodeOpImmd(char *name, int offset);
+pCodeOp *newpCodeOpImmd(char *name, int offset, int index, int code_space);
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);
+
extern void pcode_test(void);
/*-----------------------------------------------------------------*
projects / fw / sdcc / blobdiff