X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic%2Fpcode.c;h=98113546925ab81ebc03b6726a50958fa15eb767;hb=e33c24b4e792f1136531ed4108dcfc7e67871d65;hp=1e80a0547f7a97661377ea9bff35706aa0efed33;hpb=770fc9071007c38b9862dabce12704e4c7ac22b1;p=fw%2Fsdcc diff --git a/src/pic/pcode.c b/src/pic/pcode.c index 1e80a054..98113546 100644 --- a/src/pic/pcode.c +++ b/src/pic/pcode.c @@ -25,47 +25,31 @@ #include "pcode.h" +#include "pcodeflow.h" #include "ralloc.h" +#include "device.h" + +#if defined(__BORLANDC__) || defined(_MSC_VER) +#define STRCASECMP stricmp +#else +#define STRCASECMP strcasecmp +#endif + + // Eventually this will go into device dependent files: -pCodeOpReg pc_status = {{PO_STATUS, "STATUS"}, -1, NULL,NULL}; -pCodeOpReg pc_indf = {{PO_INDF, "INDF"}, -1, NULL,NULL}; -pCodeOpReg pc_fsr = {{PO_FSR, "FSR"}, -1, NULL,NULL}; +pCodeOpReg pc_status = {{PO_STATUS, "STATUS"}, -1, NULL,0,NULL}; +pCodeOpReg pc_indf = {{PO_INDF, "INDF"}, -1, NULL,0,NULL}; +pCodeOpReg pc_fsr = {{PO_FSR, "FSR"}, -1, NULL,0,NULL}; +pCodeOpReg pc_intcon = {{PO_INTCON, ""}, -1, NULL,0,NULL}; +pCodeOpReg pc_pcl = {{PO_PCL, "PCL"}, -1, NULL,0,NULL}; +pCodeOpReg pc_pclath = {{PO_PCLATH, "PCLATH"}, -1, NULL,0,NULL}; + +pCodeOpReg pc_kzero = {{PO_GPR_REGISTER, "KZ"}, -1, NULL,0,NULL}; +pCodeOpReg pc_wsave = {{PO_GPR_REGISTER, "WSAVE"}, -1, NULL,0,NULL}; +pCodeOpReg pc_ssave = {{PO_GPR_REGISTER, "SSAVE"}, -1, NULL,0,NULL}; static int mnemonics_initialized = 0; -#if 0 -//static char *PIC_mnemonics[] = { -static char *scpADDLW = "ADDLW"; -static char *scpADDWF = "ADDWF"; -static char *scpANDLW = "ANDLW"; -static char *scpANDWF = "ANDWF"; -static char *scpBCF = "BCF"; -static char *scpBSF = "BSF"; -static char *scpBTFSC = "BTFSC"; -static char *scpBTFSS = "BTFSS"; -static char *scpCALL = "CALL"; -static char *scpCOMF = "COMF"; -static char *scpCLRF = "CLRF"; -static char *scpCLRW = "CLRW"; -static char *scpDECF = "DECF"; -static char *scpDECFSZ = "DECFSZ"; -static char *scpGOTO = "GOTO"; -static char *scpINCF = "INCF"; -static char *scpINCFSZ = "INCFSZ"; -static char *scpIORLW = "IORLW"; -static char *scpIORWF = "IORWF"; -static char *scpMOVF = "MOVF"; -static char *scpMOVLW = "MOVLW"; -static char *scpMOVWF = "MOVWF"; -static char *scpNEGF = "NEGF"; -static char *scpRETLW = "RETLW"; -static char *scpRETURN = "RETURN"; -static char *scpSUBLW = "SUBLW"; -static char *scpSUBWF = "SUBWF"; -static char *scpTRIS = "TRIS"; -static char *scpXORLW = "XORLW"; -static char *scpXORWF = "XORWF"; -#endif static hTab *pic14MnemonicsHash = NULL; @@ -74,16 +58,27 @@ static hTab *pic14MnemonicsHash = NULL; static pFile *the_pFile = NULL; static int peepOptimizing = 1; static int GpCodeSequenceNumber = 1; +static int GpcFlowSeq = 1; + +#define isPCI(x) ((PCODE(x)->type == PC_OPCODE)) +#define isPCI_BRANCH(x) ((PCODE(x)->type == PC_OPCODE) && PCI(x)->isBranch) +#define isPCI_SKIP(x) ((PCODE(x)->type == PC_OPCODE) && PCI(x)->isSkip) +#define isPCFL(x) ((PCODE(x)->type == PC_FLOW)) +#define isPCF(x) ((PCODE(x)->type == PC_FUNCTION)) +#define isCALL(x) ((isPCI(x)) && (PCI(x)->op == POC_CALL)) +#define isSTATUS_REG(r) ((r)->pc_type == PO_STATUS) /****************************************************************/ /* Forward declarations */ /****************************************************************/ static void unlinkPC(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); @@ -94,569 +89,917 @@ static void pCodeOpPrint(FILE *of, pCodeOp *pcop); static char *get_op( pCodeInstruction *pcc); int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd); int pCodePeepMatchRule(pCode *pc); - +void pBlockStats(FILE *of, pBlock *pb); +extern void pCodeInsertAfter(pCode *pc1, pCode *pc2); pCodeInstruction pciADDWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ADDWF, "ADDWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_REGISTER | PCC_Z) // outCond }; pCodeInstruction pciADDFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ADDWF, "ADDWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciADDLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ADDLW, "ADDLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond }; pCodeInstruction pciANDLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ANDLW, "ANDLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciANDWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ANDWF, "ANDWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_REGISTER | PCC_Z) // outCond }; pCodeInstruction pciANDFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_ANDWF, "ANDWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciBCF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_BCF, "BCF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops - 0,1, // dest, bit instruction - PCC_NONE, // inCond - PCC_EXAMINE_PCOP // outCond + 1,1, // dest, bit instruction + 0,0, // branch, skip + PCC_REGISTER, // inCond + PCC_REGISTER // outCond }; pCodeInstruction pciBSF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_BSF, "BSF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops - 0,1, // dest, bit instruction - PCC_NONE, // inCond - PCC_EXAMINE_PCOP // outCond + 1,1, // dest, bit instruction + 0,0, // branch, skip + PCC_REGISTER, // inCond + PCC_REGISTER // outCond }; pCodeInstruction pciBTFSC = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_BTFSC, "BTFSC", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,1, // dest, bit instruction - PCC_EXAMINE_PCOP, // inCond + 1,1, // branch, skip + PCC_REGISTER, // inCond PCC_NONE // outCond }; pCodeInstruction pciBTFSS = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_BTFSS, "BTFSS", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,1, // dest, bit instruction - PCC_EXAMINE_PCOP, // inCond + 1,1, // branch, skip + PCC_REGISTER, // inCond PCC_NONE // outCond }; pCodeInstruction pciCALL = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_CALL, "CALL", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 1,0, // branch, skip PCC_NONE, // inCond PCC_NONE // outCond }; -//fixme - need a COMFW instruction. pCodeInstruction pciCOMF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_COMF, "COMF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 1,0, // dest, bit instruction + 0,0, // branch, skip + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciCOMFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_COMFW, + "COMF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction - PCC_NONE, // inCond - PCC_NONE // outCond + 0,0, // branch, skip + PCC_REGISTER, // inCond + PCC_W // outCond }; pCodeInstruction pciCLRF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_CLRF, "CLRF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_REGISTER // outCond }; pCodeInstruction pciCLRW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_CLRW, "CLRW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 0, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond PCC_W // outCond }; pCodeInstruction pciDECF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_DECF, "DECF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_REGISTER // outCond }; pCodeInstruction pciDECFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_DECFW, "DECF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_W // outCond }; pCodeInstruction pciDECFSZ = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_DECFSZ, "DECFSZ", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 1,1, // branch, skip PCC_REGISTER, // inCond PCC_REGISTER // outCond }; pCodeInstruction pciDECFSZW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_DECFSZW, "DECFSZ", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 1,1, // branch, skip PCC_REGISTER, // inCond PCC_W // outCond }; pCodeInstruction pciGOTO = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeGOTO, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeGOTO, genericDestruct, genericPrint}, POC_GOTO, "GOTO", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 1,0, // branch, skip PCC_NONE, // inCond PCC_NONE // outCond }; pCodeInstruction pciINCF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_INCF, "INCF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_REGISTER // outCond }; pCodeInstruction pciINCFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_INCFW, "INCF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_W // outCond }; pCodeInstruction pciINCFSZ = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_INCFSZ, "INCFSZ", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 1,1, // branch, skip PCC_REGISTER, // inCond PCC_REGISTER // outCond }; pCodeInstruction pciINCFSZW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeSKIP, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeSKIP, genericDestruct, genericPrint}, POC_INCFSZW, "INCFSZ", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 1,1, // branch, skip PCC_REGISTER, // inCond PCC_W // outCond }; pCodeInstruction pciIORWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_IORWF, "IORWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_REGISTER | PCC_Z) // outCond }; pCodeInstruction pciIORFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_IORWF, "IORWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciIORLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_IORLW, "IORLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciMOVF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_MOVF, "MOVF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond PCC_Z // outCond }; pCodeInstruction pciMOVFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_MOVFW, "MOVF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_REGISTER, // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciMOVWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_MOVWF, "MOVWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond - 0 // outCond + PCC_REGISTER // outCond }; pCodeInstruction pciMOVLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_MOVLW, "MOVLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_NONE, // inCond PCC_W // outCond }; -pCodeInstruction pciNEGF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, +pCodeInstruction pciNOP = { + {PC_OPCODE, NULL, NULL, 0, NULL, genericDestruct, genericPrint}, - POC_NEGF, - "NEGF", + POC_NOP, + "NOP", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand - 1, // num ops + NULL, // flow block + 0, // num ops 0,0, // dest, bit instruction - PCC_REGISTER, // inCond + 0,0, // branch, skip + PCC_NONE, // inCond PCC_NONE // outCond }; +pCodeInstruction pciRETFIE = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeRETURN, + genericDestruct, + genericPrint}, + POC_RETFIE, + "RETFIE", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 0, // num ops + 0,0, // dest, bit instruction + 1,0, // branch, skip + PCC_NONE, // inCond + PCC_NONE // outCond (not true... affects the GIE bit too) +}; pCodeInstruction pciRETLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeRETURN, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeRETURN, genericDestruct, genericPrint}, POC_RETLW, "RETLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 1,0, // branch, skip PCC_NONE, // inCond PCC_W // outCond }; pCodeInstruction pciRETURN = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - AnalyzeRETURN, + {PC_OPCODE, NULL, NULL, 0, NULL, + // AnalyzeRETURN, genericDestruct, genericPrint}, - POC_RETLW, + POC_RETURN, "RETURN", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 0, // num ops 0,0, // dest, bit instruction + 1,0, // branch, skip PCC_NONE, // inCond - PCC_W // outCond + PCC_NONE // outCond +}; + +pCodeInstruction pciRLF = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_RLF, + "RLF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 1,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_C | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond +}; + +pCodeInstruction pciRLFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_RLFW, + "RLF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 0,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_C | PCC_REGISTER), // inCond + (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond +}; + +pCodeInstruction pciRRF = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_RRF, + "RRF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 1,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_C | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z | PCC_C | PCC_DC) // outCond }; +pCodeInstruction pciRRFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_RRFW, + "RRF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 0,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_C | PCC_REGISTER), // inCond + (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond +}; pCodeInstruction pciSUBWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_SUBWF, "SUBWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_REGISTER | PCC_Z) // outCond }; pCodeInstruction pciSUBFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_SUBWF, "SUBWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciSUBLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_SUBLW, "SUBLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond }; +pCodeInstruction pciSWAPF = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_SWAPF, + "SWAPF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 1,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_REGISTER), // inCond + (PCC_REGISTER) // outCond +}; + +pCodeInstruction pciSWAPFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, + genericDestruct, + genericPrint}, + POC_SWAPFW, + "SWAPF", + NULL, // from branch + NULL, // to branch + NULL, // label + NULL, // operand + NULL, // flow block + 2, // num ops + 0,0, // dest, bit instruction + 0,0, // branch, skip + (PCC_REGISTER), // inCond + (PCC_W) // outCond +}; + pCodeInstruction pciTRIS = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_TRIS, "TRIS", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_NONE, // inCond - PCC_NONE + PCC_REGISTER // outCond }; - pCodeInstruction pciXORWF = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_XORWF, "XORWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 1,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_REGISTER | PCC_Z) // outCond }; pCodeInstruction pciXORFW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_XORWF, "XORWF", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 2, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip (PCC_W | PCC_REGISTER), // inCond (PCC_W | PCC_Z) // outCond }; pCodeInstruction pciXORLW = { - {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, - genericAnalyze, + {PC_OPCODE, NULL, NULL, 0, NULL, + // genericAnalyze, genericDestruct, genericPrint}, POC_XORLW, "XORLW", + NULL, // from branch + NULL, // to branch + NULL, // label NULL, // operand + NULL, // flow block 1, // num ops 0,0, // dest, bit instruction + 0,0, // branch, skip PCC_W, // inCond (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond }; @@ -665,28 +1008,107 @@ pCodeInstruction pciXORLW = { #define MAX_PIC14MNEMONICS 100 pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS]; -char *Safe_strdup(char *str) +/* This definition needs to be part of configure.in */ +// #define USE_VSNPRINTF + +#ifdef USE_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, ...) { - char *copy; + va_list val; + int len; - if(!str) - return NULL; + if(!str || !*str) + return; - copy = strdup(str); - if(!copy) { - fprintf(stderr, "out of memory %s,%d\n",__FUNCTION__,__LINE__); - exit(1); + va_start(val, format); + + vsnprintf(*str, *size, format, val); + + va_end (val); + + len = strlen(*str); + if(len > *size) { + fprintf(stderr,"WARNING, it looks like %s has overflowed\n",__FUNCTION__); } - return copy; - + *str += len; + *size -= len; + +} + +#else // USE_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__); + } + + strcpy(*str, buffer); + *str += len; + *size -= len; + } +#endif // USE_VSNPRINTF + + +extern void initStack(int base_address, int size); +extern regs *allocProcessorRegister(int rIdx, char * name, short po_type, int alias); +extern regs *allocInternalRegister(int rIdx, char * name, short po_type, int alias); +extern void init_pic(void); + void pCodeInitRegisters(void) { - pc_fsr.rIdx = 4; - pc_fsr.r = pic14_regWithIdx(4); + initStack(0x38, 8); + init_pic(); + + pc_status.r = allocProcessorRegister(IDX_STATUS,"STATUS", PO_STATUS, 0x80); + pc_pcl.r = allocProcessorRegister(IDX_PCL,"PCL", PO_PCL, 0x80); + pc_pclath.r = allocProcessorRegister(IDX_PCLATH,"PCLATH", PO_PCLATH, 0x80); + pc_fsr.r = allocProcessorRegister(IDX_FSR,"FSR", PO_FSR, 0x80); + pc_indf.r = allocProcessorRegister(IDX_INDF,"INDF", PO_INDF, 0x80); + pc_intcon.r = allocProcessorRegister(IDX_INTCON,"INTCON", PO_INTCON, 0x80); + + pc_status.rIdx = IDX_STATUS; + pc_fsr.rIdx = IDX_FSR; + pc_indf.rIdx = IDX_INDF; + pc_intcon.rIdx = IDX_INTCON; + pc_pcl.rIdx = IDX_PCL; + pc_pclath.rIdx = IDX_PCLATH; + + pc_kzero.r = allocInternalRegister(IDX_KZ,"KZ",PO_GPR_REGISTER,0); + pc_ssave.r = allocInternalRegister(IDX_SSAVE,"SSAVE", PO_GPR_REGISTER, 0x80); + pc_wsave.r = allocInternalRegister(IDX_WSAVE,"WSAVE", PO_GPR_REGISTER, 0); + + pc_kzero.rIdx = IDX_KZ; + pc_wsave.rIdx = IDX_WSAVE; + pc_ssave.rIdx = IDX_SSAVE; } @@ -696,7 +1118,7 @@ void pCodeInitRegisters(void) /* */ /*-----------------------------------------------------------------*/ -int mnem2key(char *mnem) +int mnem2key(char const *mnem) { int key = 0; @@ -705,7 +1127,7 @@ int mnem2key(char *mnem) while(*mnem) { - key += *mnem++ +1; + key += toupper(*mnem++) +1; } @@ -735,6 +1157,7 @@ void pic14initMnemonics(void) pic14Mnemonics[POC_BTFSS] = &pciBTFSS; pic14Mnemonics[POC_CALL] = &pciCALL; pic14Mnemonics[POC_COMF] = &pciCOMF; + pic14Mnemonics[POC_COMFW] = &pciCOMFW; pic14Mnemonics[POC_CLRF] = &pciCLRF; pic14Mnemonics[POC_CLRW] = &pciCLRW; pic14Mnemonics[POC_DECF] = &pciDECF; @@ -753,12 +1176,19 @@ void pic14initMnemonics(void) pic14Mnemonics[POC_MOVFW] = &pciMOVFW; pic14Mnemonics[POC_MOVLW] = &pciMOVLW; pic14Mnemonics[POC_MOVWF] = &pciMOVWF; - pic14Mnemonics[POC_NEGF] = &pciNEGF; + pic14Mnemonics[POC_NOP] = &pciNOP; + pic14Mnemonics[POC_RETFIE] = &pciRETFIE; pic14Mnemonics[POC_RETLW] = &pciRETLW; pic14Mnemonics[POC_RETURN] = &pciRETURN; + pic14Mnemonics[POC_RLF] = &pciRLF; + pic14Mnemonics[POC_RLFW] = &pciRLFW; + pic14Mnemonics[POC_RRF] = &pciRRF; + pic14Mnemonics[POC_RRFW] = &pciRRFW; pic14Mnemonics[POC_SUBLW] = &pciSUBLW; pic14Mnemonics[POC_SUBWF] = &pciSUBWF; pic14Mnemonics[POC_SUBFW] = &pciSUBFW; + pic14Mnemonics[POC_SWAPF] = &pciSWAPF; + pic14Mnemonics[POC_SWAPFW] = &pciSWAPFW; pic14Mnemonics[POC_TRIS] = &pciTRIS; pic14Mnemonics[POC_XORLW] = &pciXORLW; pic14Mnemonics[POC_XORWF] = &pciXORWF; @@ -767,49 +1197,40 @@ void pic14initMnemonics(void) for(i=0; imnemonic), pic14Mnemonics[i]); -/* - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpADDLW), scpADDLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpADDWF),scpADDWF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpANDLW),scpANDLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpANDWF),scpANDWF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBCF),scpBCF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBSF),scpBSF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBTFSC),scpBTFSC); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpBTFSS),scpBTFSS); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCALL),scpCALL); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCOMF),scpCOMF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCLRF),scpCLRF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpCLRW),scpCLRW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpDECF),scpDECF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpDECFSZ),scpDECFSZ); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpGOTO),scpGOTO); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpINCF),scpINCF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpINCFSZ),scpINCFSZ); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpIORLW),scpIORLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpIORWF),scpIORWF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVF),scpMOVF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVLW),scpMOVLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpMOVWF),scpMOVWF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpNEGF),scpNEGF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpRETLW),scpRETLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpRETURN),scpRETURN); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpSUBLW),scpSUBLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpSUBWF),scpSUBWF); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpTRIS),scpTRIS); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpXORLW),scpXORLW); - hTabAddItem(&pic14MnemonicsHash, mnem2key(scpXORWF),scpXORWF); -*/ - pci = hTabFirstItem(pic14MnemonicsHash, &key); while(pci) { - fprintf( stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic); + DFPRINTF((stderr, "element %d key %d, mnem %s\n",i++,key,pci->mnemonic)); pci = hTabNextItem(pic14MnemonicsHash, &key); } mnemonics_initialized = 1; } +int getpCode(char *mnem,unsigned dest) +{ + + pCodeInstruction *pci; + int key = mnem2key(mnem); + + if(!mnemonics_initialized) + pic14initMnemonics(); + + pci = hTabFirstItemWK(pic14MnemonicsHash, key); + + while(pci) { + + if(STRCASECMP(pci->mnemonic, mnem) == 0) { + if((pci->num_ops <= 1) || (pci->isModReg == dest)) + return(pci->op); + } + + pci = hTabNextItemWK (pic14MnemonicsHash); + + } + + return -1; +} char getpBlock_dbName(pBlock *pb) { @@ -821,6 +1242,17 @@ char getpBlock_dbName(pBlock *pb) return pb->dbName; } +void pBlockConvert2ISR(pBlock *pb) +{ + if(!pb) + return; + + if(pb->cmemmap) + pb->cmemmap = NULL; + + pb->dbName = 'I'; +} + /*-----------------------------------------------------------------*/ /* movepBlock2Head - given the dbname of a pBlock, move all */ /* instances to the front of the doubly linked */ @@ -873,15 +1305,17 @@ void copypCode(FILE *of, char dbName) return; for(pb = the_pFile->pbHead; pb; pb = pb->next) { - if(getpBlock_dbName(pb) == dbName) + if(getpBlock_dbName(pb) == dbName) { + pBlockStats(of,pb); printpBlock(of,pb); + } } } void pcode_test(void) { - printf("pcode is alive!\n"); + DFPRINTF((stderr,"pcode is alive!\n")); //initMnemonics(); @@ -914,14 +1348,21 @@ void pcode_test(void) } } } +/*-----------------------------------------------------------------*/ +/* int RegCond(pCodeOp *pcop) - if pcop points to the STATUS reg- */ +/* ister, RegCond will return the bit being referenced. */ +/* */ +/* fixme - why not just OR in the pcop bit field */ +/*-----------------------------------------------------------------*/ + static int RegCond(pCodeOp *pcop) { if(!pcop) return 0; - if(pcop->type == PO_BIT && !strcmp(pcop->name, pc_status.pcop.name)) { - switch(PCOB(pcop)->bit) { + if(pcop->type == PO_GPR_BIT && !strcmp(pcop->name, pc_status.pcop.name)) { + switch(PCORB(pcop)->bit) { case PIC_C_BIT: return PCC_C; case PIC_DC_BIT: @@ -965,7 +1406,7 @@ pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) pci = Safe_calloc(1, sizeof(pCodeInstruction)); - if((op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) { + if((op>=0) && (op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) { memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction)); pci->pcop = pcop; @@ -975,6 +1416,7 @@ pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) if(pci->outCond == PCC_EXAMINE_PCOP) pci->outCond = RegCond(pcop); + pci->pc.prev = pci->pc.next = NULL; return (pCode *)pci; } @@ -995,6 +1437,10 @@ pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) /* line (of assembly code) is declared matched. Note that the */ /* operand may be wild too. */ /* */ +/* Note, a wild instruction is specified just like a wild var: */ +/* %4 ; A wild instruction, */ +/* See the peeph.def file for additional examples */ +/* */ /*-----------------------------------------------------------------*/ pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label) @@ -1004,16 +1450,16 @@ pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_la pcw = Safe_calloc(1,sizeof(pCodeWild)); - pcw->pc.type = PC_WILD; - pcw->pc.prev = pcw->pc.next = NULL; - pcw->pc.from = pcw->pc.to = pcw->pc.label = NULL; - pcw->pc.pb = NULL; + pcw->pci.pc.type = PC_WILD; + pcw->pci.pc.prev = pcw->pci.pc.next = NULL; + pcw->pci.from = pcw->pci.to = pcw->pci.label = NULL; + pcw->pci.pc.pb = NULL; - pcw->pc.analyze = genericAnalyze; - pcw->pc.destruct = genericDestruct; - pcw->pc.print = genericPrint; + // pcw->pci.pc.analyze = genericAnalyze; + pcw->pci.pc.destruct = genericDestruct; + pcw->pci.pc.print = genericPrint; - pcw->id = pCodeID; + pcw->id = pCodeID; // this is the 'n' in %n pcw->operand = optional_operand; pcw->label = optional_label; @@ -1034,21 +1480,24 @@ pCode *newpCodeCharP(char *cP) pcc->pc.type = PC_COMMENT; pcc->pc.prev = pcc->pc.next = NULL; - pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL; + //pcc->pc.from = pcc->pc.to = pcc->pc.label = NULL; pcc->pc.pb = NULL; - pcc->pc.analyze = genericAnalyze; + // pcc->pc.analyze = genericAnalyze; pcc->pc.destruct = genericDestruct; pcc->pc.print = genericPrint; - pcc->comment = Safe_strdup(cP); + if(cP) + pcc->comment = Safe_strdup(cP); + else + pcc->comment = NULL; return ( (pCode *)pcc); } /*-----------------------------------------------------------------*/ -/* newpCodeGLabel - create a new global label */ +/* newpCodeFunction - */ /*-----------------------------------------------------------------*/ @@ -1056,25 +1505,28 @@ pCode *newpCodeFunction(char *mod,char *f) { pCodeFunction *pcf; - _ALLOC(pcf,sizeof(pCodeFunction)); + pcf = Safe_calloc(1,sizeof(pCodeFunction)); + //_ALLOC(pcf,sizeof(pCodeFunction)); pcf->pc.type = PC_FUNCTION; pcf->pc.prev = pcf->pc.next = NULL; - pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL; + //pcf->pc.from = pcf->pc.to = pcf->pc.label = NULL; pcf->pc.pb = NULL; - pcf->pc.analyze = genericAnalyze; + // pcf->pc.analyze = genericAnalyze; pcf->pc.destruct = genericDestruct; pcf->pc.print = pCodePrintFunction; if(mod) { - _ALLOC_ATOMIC(pcf->modname,strlen(mod)+1); + //_ALLOC_ATOMIC(pcf->modname,strlen(mod)+1); + pcf->modname = Safe_calloc(1,strlen(mod)+1); strcpy(pcf->modname,mod); } else pcf->modname = NULL; if(f) { - _ALLOC_ATOMIC(pcf->fname,strlen(f)+1); + //_ALLOC_ATOMIC(pcf->fname,strlen(f)+1); + pcf->fname = Safe_calloc(1,strlen(f)+1); strcpy(pcf->fname,f); } else pcf->fname = NULL; @@ -1083,8 +1535,59 @@ pCode *newpCodeFunction(char *mod,char *f) } +/*-----------------------------------------------------------------*/ +/* newpCodeFlow */ +/*-----------------------------------------------------------------*/ + + +pCode *newpCodeFlow(void ) +{ + pCodeFlow *pcflow; + + //_ALLOC(pcflow,sizeof(pCodeFlow)); + pcflow = Safe_calloc(1,sizeof(pCodeFlow)); + + pcflow->pc.type = PC_FLOW; + pcflow->pc.prev = pcflow->pc.next = NULL; + //pcflow->pc.from = pcflow->pc.to = pcflow->pc.label = NULL; + pcflow->pc.pb = NULL; + + // pcflow->pc.analyze = genericAnalyze; + pcflow->pc.destruct = genericDestruct; + pcflow->pc.print = genericPrint; + + pcflow->pc.seq = GpcFlowSeq++; + + pcflow->nuses = 7; + pcflow->uses = Safe_calloc(pcflow->nuses, sizeof(set *)); + + pcflow->from = pcflow->to = NULL; + + pcflow->inCond = PCC_NONE; + pcflow->outCond = PCC_NONE; + + pcflow->end = NULL; + return ( (pCode *)pcflow); + +} + +/*-----------------------------------------------------------------*/ +/* pCodeLabelDestruct - free memory used by a label. */ +/*-----------------------------------------------------------------*/ +static void pCodeLabelDestruct(pCode *pc) +{ + + if(!pc) + return; + + if((pc->type == PC_LABEL) && PCL(pc)->label) + free(PCL(pc)->label); -pCode *newpCodeLabel(int key) + free(pc); + +} + +pCode *newpCodeLabel(char *name, int key) { char *s = buffer; @@ -1094,33 +1597,30 @@ pCode *newpCodeLabel(int key) pcl->pc.type = PC_LABEL; pcl->pc.prev = pcl->pc.next = NULL; - pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL; + //pcl->pc.from = pcl->pc.to = pcl->pc.label = NULL; pcl->pc.pb = NULL; - pcl->pc.analyze = genericAnalyze; - pcl->pc.destruct = genericDestruct; + // pcl->pc.analyze = genericAnalyze; + pcl->pc.destruct = pCodeLabelDestruct; pcl->pc.print = pCodePrintLabel; pcl->key = key; + pcl->label = NULL; if(key>0) { sprintf(s,"_%05d_DS_",key); - pcl->label = Safe_strdup(s); } else - pcl->label = NULL; + s = name; - return ( (pCode *)pcl); + if(s) + pcl->label = Safe_strdup(s); -} -pCode *newpCodeLabelStr(char *str) -{ - pCode *pc = newpCodeLabel(-1); - PCL(pc)->label = Safe_strdup(str); + return ( (pCode *)pcl); - return pc; } + /*-----------------------------------------------------------------*/ /* newpBlock - create and return a pointer to a new pBlock */ /*-----------------------------------------------------------------*/ @@ -1129,11 +1629,11 @@ pBlock *newpBlock(void) pBlock *PpB; - _ALLOC(PpB,sizeof(pBlock)); + PpB = Safe_calloc(1,sizeof(pBlock) ); PpB->next = PpB->prev = NULL; PpB->function_entries = PpB->function_exits = PpB->function_calls = NULL; - PpB->registers = NULL; + PpB->tregisters = NULL; PpB->visited = 0; return PpB; @@ -1161,20 +1661,6 @@ pBlock *newpCodeChain(memmap *cm,char c, pCode *pc) return pB; } -/*-----------------------------------------------------------------*/ -/*-----------------------------------------------------------------*/ - -pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type) -{ - pCodeOp *pcop; - - pcop = Safe_calloc(1,sizeof(pCodeOp) ); - pcop->type = type; - pcop->name = Safe_strdup(name); - - return pcop; -} - /*-----------------------------------------------------------------*/ /* newpCodeOpLabel - Create a new label given the key */ /* Note, a negative key means that the label is part of wild card */ @@ -1182,41 +1668,77 @@ pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type) /* optimizations). */ /*-----------------------------------------------------------------*/ -pCodeOp *newpCodeOpLabel(int key) +pCodeOp *newpCodeOpLabel(char *name, int key) { - char *s = buffer; + char *s=NULL; + static int label_key=-1; + pCodeOp *pcop; pcop = Safe_calloc(1,sizeof(pCodeOpLabel) ); pcop->type = PO_LABEL; - if(key>0) { - sprintf(s,"_%05d_DS_",key); + pcop->name = NULL; + + if(key>0) + sprintf(s=buffer,"_%05d_DS_",key); + else + s = name, key = label_key--; + + if(s) pcop->name = Safe_strdup(s); - } else - pcop->name = NULL; ((pCodeOpLabel *)pcop)->key = key; return pcop; } +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ pCodeOp *newpCodeOpLit(int lit) { char *s = buffer; pCodeOp *pcop; - _ALLOC(pcop,sizeof(pCodeOpLit) ); + pcop = Safe_calloc(1,sizeof(pCodeOpLit) ); pcop->type = PO_LITERAL; - sprintf(s,"0x%02x",lit); - _ALLOC_ATOMIC(pcop->name,strlen(s)+1); - strcpy(pcop->name,s); + + pcop->name = NULL; + if(lit>=0) { + sprintf(s,"0x%02x",lit); + if(s) + pcop->name = Safe_strdup(s); + } + ((pCodeOpLit *)pcop)->lit = lit; return pcop; } +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +pCodeOp *newpCodeOpImmd(char *name, int offset) +{ + pCodeOp *pcop; + + + pcop = Safe_calloc(1,sizeof(pCodeOpImmd) ); + pcop->type = PO_IMMEDIATE; + if(name) { + pcop->name = Safe_strdup(name); + } else { + pcop->name = NULL; + } + + + PCOI(pcop)->offset = offset; + + return pcop; +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ pCodeOp *newpCodeOpWild(int id, pCodePeep *pcp, pCodeOp *subtype) { char *s = buffer; @@ -1241,53 +1763,175 @@ pCodeOp *newpCodeOpWild(int id, pCodePeep *pcp, pCodeOp *subtype) return pcop; } -pCodeOp *newpCodeOpBit(char *s, int bit) +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +pCodeOp *newpCodeOpBit(char *s, int bit, int inBitSpace) { pCodeOp *pcop; - _ALLOC(pcop,sizeof(pCodeOpBit) ); - pcop->type = PO_BIT; - pcop->name = Safe_strdup(s); - PCOB(pcop)->bit = bit; - if(bit>=0) - PCOB(pcop)->inBitSpace = 1; + pcop = Safe_calloc(1,sizeof(pCodeOpRegBit) ); + pcop->type = PO_GPR_BIT; + if(s) + pcop->name = Safe_strdup(s); else - PCOB(pcop)->inBitSpace = 0; + pcop->name = NULL; + + PCORB(pcop)->bit = bit; + PCORB(pcop)->inBitSpace = inBitSpace; return pcop; } -/*-----------------------------------------------------------------*/ -/* addpCode2pBlock - place the pCode into the pBlock linked list */ -/*-----------------------------------------------------------------*/ -void addpCode2pBlock(pBlock *pb, pCode *pc) +pCodeOp *newpCodeOpReg(int rIdx) { + pCodeOp *pcop; - pb->pcTail->next = pc; - pc->prev = pb->pcTail; - pc->next = NULL; - pc->pb = pb; - pb->pcTail = pc; -} + pcop = Safe_calloc(1,sizeof(pCodeOpReg) ); -/*-----------------------------------------------------------------*/ -/* addpBlock - place a pBlock into the pFile */ -/*-----------------------------------------------------------------*/ -void addpBlock(pBlock *pb) + pcop->name = NULL; + PCOR(pcop)->rIdx = rIdx; + PCOR(pcop)->r = pic14_regWithIdx(rIdx); + pcop->type = PCOR(pcop)->r->pc_type; + + return pcop; +} +pCodeOp *newpCodeOpRegFromStr(char *name) { + pCodeOp *pcop; - if(!the_pFile) { - /* First time called, we'll pass through here. */ - _ALLOC(the_pFile,sizeof(the_pFile)); - the_pFile->pbHead = the_pFile->pbTail = pb; - the_pFile->functions = NULL; - return; - } + pcop = Safe_calloc(1,sizeof(pCodeOpReg) ); + PCOR(pcop)->r = allocRegByName(name); + PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx; + pcop->type = PCOR(pcop)->r->pc_type; + pcop->name = PCOR(pcop)->r->name; - the_pFile->pbTail->next = pb; - pb->prev = the_pFile->pbTail; - pb->next = NULL; - the_pFile->pbTail = pb; + return pcop; +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ + +pCodeOp *newpCodeOp(char *name, PIC_OPTYPE type) +{ + pCodeOp *pcop; + + switch(type) { + case PO_BIT: + case PO_GPR_BIT: + pcop = newpCodeOpBit(name, -1,0); + break; + + case PO_LITERAL: + pcop = newpCodeOpLit(-1); + break; + + case PO_LABEL: + pcop = newpCodeOpLabel(NULL,-1); + break; + + default: + pcop = Safe_calloc(1,sizeof(pCodeOp) ); + pcop->type = type; + if(name) + pcop->name = Safe_strdup(name); + else + pcop->name = NULL; + } + + return pcop; +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void pCodeConstString(char *name, char *value) +{ + pBlock *pb; + + // 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); + + 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(!pb->pcHead) { + /* If this is the first pcode to be added to a block that + * was initialized with a NULL pcode, then go ahead and + * make this pcode the head and tail */ + pb->pcHead = pb->pcTail = pc; + } else { + pb->pcTail->next = pc; + pc->prev = pb->pcTail; + //pc->next = NULL; + pc->pb = pb; + pb->pcTail = pc; + } +} + +/*-----------------------------------------------------------------*/ +/* addpBlock - place a pBlock into the pFile */ +/*-----------------------------------------------------------------*/ +void addpBlock(pBlock *pb) +{ + // fprintf(stderr," Adding pBlock: dbName =%c\n",getpBlock_dbName(pb)); + + if(!the_pFile) { + /* First time called, we'll pass through here. */ + //_ALLOC(the_pFile,sizeof(pFile)); + the_pFile = Safe_calloc(1,sizeof(pFile)); + the_pFile->pbHead = the_pFile->pbTail = pb; + the_pFile->functions = NULL; + return; + } + + the_pFile->pbTail->next = pb; + pb->prev = the_pFile->pbTail; + pb->next = NULL; + the_pFile->pbTail = pb; } /*-----------------------------------------------------------------*/ @@ -1335,30 +1979,38 @@ void printpBlock(FILE *of, pBlock *pb) static void unlinkPC(pCode *pc) { - if(pc && pc->prev && pc->next) { - pc->prev->next = pc->next; - pc->next->prev = pc->prev; + + if(pc) { + if(pc->prev) + pc->prev->next = pc->next; + if(pc->next) + pc->next->prev = pc->prev; + + pc->prev = pc->next = NULL; } } static void genericDestruct(pCode *pc) { + fprintf(stderr,"warning, calling default pCode destructor\n"); + unlinkPC(pc); - fprintf(stderr,"warning, calling default pCode destructor\n"); free(pc); + } +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ void pBlockRegs(FILE *of, pBlock *pb) { regs *r; - r = setFirstItem(pb->registers); + r = setFirstItem(pb->tregisters); while (r) { - fprintf(of," %s\n",r->name); - r = setNextItem(pb->registers); + r = setNextItem(pb->tregisters); } } @@ -1366,19 +2018,42 @@ void pBlockRegs(FILE *of, pBlock *pb) static char *get_op( pCodeInstruction *pcc) { regs *r; + static char buffer[50]; + char *s; + int size; if(pcc && pcc->pcop) { switch(pcc->pcop->type) { - + case PO_INDF: case PO_FSR: + //fprintf(stderr,"get_op getting register name rIdx=%d\n",PCOR(pcc->pcop)->rIdx); + //r = pic14_regWithIdx(PCOR(pcc->pcop)->rIdx); + //return r->name; + return PCOR(pcc->pcop)->r->name; + break; case PO_GPR_TEMP: r = pic14_regWithIdx(PCOR(pcc->pcop)->r->rIdx); - fprintf(stderr,"getop: getting %s\nfrom:\n",r->name); //pcc->pcop->name); + //fprintf(stderr,"getop: getting %s\nfrom:\n",r->name); //pcc->pcop->name); pBlockRegs(stderr,pcc->pc.pb); return r->name; + // case PO_GPR_BIT: + // return PCOR(pcc->pcop)->r)->name; + case PO_IMMEDIATE: + s = buffer; + size = sizeof(buffer); + if( PCOI(pcc->pcop)->offset && PCOI(pcc->pcop)->offset<4) { + SAFE_snprintf(&s,&size,"((%s >> %d)&0xff)", + pcc->pcop->name, + 8 * PCOI(pcc->pcop)->offset ); + } else + SAFE_snprintf(&s,&size,"LOW(%s)",pcc->pcop->name); + + + return buffer; + default: if (pcc->pcop->name) return pcc->pcop->name; @@ -1397,6 +2072,74 @@ static void pCodeOpPrint(FILE *of, pCodeOp *pcop) fprintf(of,"pcodeopprint\n"); } +char *pCode2str(char *str, int size, pCode *pc) +{ + char *s = str; + + switch(pc->type) { + + case PC_OPCODE: + + SAFE_snprintf(&s,&size, "\t%s\t", PCI(pc)->mnemonic); + + if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) { + + if(PCI(pc)->isBitInst) { + if(PCI(pc)->pcop->type == PO_GPR_BIT) { + if( (((pCodeOpRegBit *)(PCI(pc)->pcop))->inBitSpace) ) + SAFE_snprintf(&s,&size,"(%s >> 3), (%s & 7)", + PCI(pc)->pcop->name , + PCI(pc)->pcop->name ); + else + SAFE_snprintf(&s,&size,"%s,%d", get_op(PCI(pc)), + (((pCodeOpRegBit *)(PCI(pc)->pcop))->bit )); + } else if(PCI(pc)->pcop->type == PO_GPR_BIT) { + SAFE_snprintf(&s,&size,"%s,%d", get_op(PCI(pc)),PCORB(PCI(pc)->pcop)->bit); + }else + SAFE_snprintf(&s,&size,"%s,0 ; ?bug", get_op(PCI(pc))); + //PCI(pc)->pcop->t.bit ); + } else { + + if(PCI(pc)->pcop->type == PO_GPR_BIT) { + if( PCI(pc)->num_ops == 2) + SAFE_snprintf(&s,&size,"(%s >> 3),%c",get_op(PCI(pc)),((PCI(pc)->isModReg) ? 'F':'W')); + else + SAFE_snprintf(&s,&size,"(1 << (%s & 7))",get_op(PCI(pc))); + + }else { + SAFE_snprintf(&s,&size,"%s",get_op(PCI(pc))); + + if( PCI(pc)->num_ops == 2) + SAFE_snprintf(&s,&size,",%c", ( (PCI(pc)->isModReg) ? 'F':'W')); + } + } + + } + break; + + case PC_COMMENT: + /* assuming that comment ends with a \n */ + SAFE_snprintf(&s,&size,";%s", ((pCodeComment *)pc)->comment); + break; + + case PC_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; + } + + return str; + +} + /*-----------------------------------------------------------------*/ /* genericPrint - the contents of a pCode to a file */ /*-----------------------------------------------------------------*/ @@ -1414,51 +2157,28 @@ static void genericPrint(FILE *of, pCode *pc) case PC_OPCODE: // If the opcode has a label, print that first { - pBranch *pbl = pc->label; - while(pbl) { + pBranch *pbl = PCI(pc)->label; + while(pbl && pbl->pc) { if(pbl->pc->type == PC_LABEL) pCodePrintLabel(of, pbl->pc); pbl = pbl->next; } } - fprintf(of, "\t%s\t", PCI(pc)->mnemonic); - if( (PCI(pc)->num_ops >= 1) && (PCI(pc)->pcop)) { - if(PCI(pc)->bit_inst) { - if(PCI(pc)->pcop->type == PO_BIT) { - if( (((pCodeOpBit *)(PCI(pc)->pcop))->inBitSpace) ) - fprintf(of,"(%s >> 3), (%s & 7)", - PCI(pc)->pcop->name , - PCI(pc)->pcop->name ); - else - fprintf(of,"%s,%d", get_op(PCI(pc)), (((pCodeOpBit *)(PCI(pc)->pcop))->bit )); - } else - fprintf(of,"%s,0 ; ?bug", get_op(PCI(pc))); - //PCI(pc)->pcop->t.bit ); - } else { - - if(PCI(pc)->pcop->type == PO_BIT) { - if( PCI(pc)->num_ops == 2) - fprintf(of,"(%s >> 3),%c",get_op(PCI(pc)),((PCI(pc)->dest) ? 'F':'W')); - else - fprintf(of,"(1 << (%s & 7))",get_op(PCI(pc))); + { + char str[256]; + + pCode2str(str, 256, pc); -/* - if( PCI(pc)->num_ops == 2) - fprintf(of,"(%s >> 3),%c",PCI(pc)->pcop->name,((PCI(pc)->dest) ? 'F':'W')); - else - fprintf(of,"(1 << (%s & 7))",PCI(pc)->pcop->name); -*/ - }else { - fprintf(of,"%s",get_op(PCI(pc))); + fprintf(of,"%s",str); - if( PCI(pc)->num_ops == 2) - fprintf(of,",%c", ( (PCI(pc)->dest) ? 'F':'W')); - } - } + /* Debug */ + fprintf(of, "\t;key=%03x",pc->seq); + if(PCI(pc)->pcflow) + fprintf(of,",flow seq=%03x",PCI(pc)->pcflow->pc.seq); } - +#if 0 { pBranch *dpb = pc->to; // debug while(dpb) { @@ -1472,25 +2192,35 @@ static void genericPrint(FILE *of, pCode *pc) 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; } - fprintf(of,"\n"); } - +#endif + fprintf(of,"\n"); break; case PC_WILD: fprintf(of,";\tWild opcode: id=%d\n",PCW(pc)->id); + if(PCW(pc)->pci.label) + pCodePrintLabel(of, PCW(pc)->pci.label->pc); + if(PCW(pc)->operand) { fprintf(of,";\toperand "); pCodeOpPrint(of,PCW(pc)->operand ); } break; + case PC_FLOW: + fprintf(of,";Start of new flow, seq=%d\n",pc->seq); + break; + case PC_LABEL: default: fprintf(of,"unknown pCode type %d\n",pc->type); @@ -1512,7 +2242,7 @@ static void pCodePrintFunction(FILE *of, pCode *pc) fprintf(of,"F_%s",((pCodeFunction *)pc)->modname); if(PCF(pc)->fname) { - pBranch *exits = pc->to; + pBranch *exits = PCF(pc)->to; int i=0; fprintf(of,"%s\t;Function start\n",PCF(pc)->fname); while(exits) { @@ -1523,10 +2253,10 @@ static void pCodePrintFunction(FILE *of, pCode *pc) fprintf(of,"; %d exit point%c\n",i, ((i==1) ? ' ':'s')); }else { - if(pc->from && - pc->from->pc->type == PC_FUNCTION && - PCF(pc->from->pc)->fname) - fprintf(of,"; exit point of %s\n",PCF(pc->from->pc)->fname); + if((PCF(pc)->from && + PCF(pc)->from->pc->type == PC_FUNCTION && + PCF(PCF(pc)->from->pc)->fname) ) + fprintf(of,"; exit point of %s\n",PCF(PCF(pc)->from->pc)->fname); else fprintf(of,"; exit point [can't find entry point]\n"); } @@ -1546,11 +2276,74 @@ static void pCodePrintLabel(FILE *of, pCode *pc) else if (PCL(pc)->key >=0) fprintf(of,"_%05d_DS_:\n",PCL(pc)->key); else - fprintf(of,";wild card label\n"); + fprintf(of,";wild card label: id=%d\n",-PCL(pc)->key); } /*-----------------------------------------------------------------*/ +/* unlinkpCodeFromBranch - Search for a label in a pBranch and */ +/* remove it if it is found. */ +/*-----------------------------------------------------------------*/ +static void unlinkpCodeFromBranch(pCode *pcl , pCode *pc) +{ + pBranch *b, *bprev; + + + bprev = NULL; + + if(pcl->type == PC_OPCODE) + b = PCI(pcl)->label; + else { + fprintf(stderr, "LINE %d. can't unlink from non opcode\n",__LINE__); + exit(1); + + } + + while(b) { + if(b->pc == pc) { + + /* Found a label */ + if(bprev) { + bprev->next = b->next; /* Not first pCode in chain */ + free(b); + } else { + pc->destruct(pc); + PCI(pcl)->label = b->next; /* First pCode in chain */ + free(b); + } + return; /* A label can't occur more than once */ + } + bprev = b; + b = b->next; + } + +#if 0 + + original stuff: + + bprev = NULL; + b = pcl->label; + while(b) { + if(b->pc == pc) { + + /* Found a label */ + if(bprev) { + bprev->next = b->next; /* Not first pCode in chain */ + free(b); + } else { + pc->destruct(pc); + pcl->label = b->next; /* First pCode in chain */ + free(b); + } + return; /* A label can't occur more than once */ + } + bprev = b; + b = b->next; + } +#endif +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ static pBranch * pBranchAppend(pBranch *h, pBranch *n) { pBranch *b; @@ -1571,22 +2364,24 @@ static pBranch * pBranchAppend(pBranch *h, pBranch *n) /* pBranchLink - given two pcodes, this function will link them */ /* together through their pBranches */ /*-----------------------------------------------------------------*/ -static void pBranchLink(pCode *f, pCode *t) +static void pBranchLink(pCodeFunction *f, pCodeFunction *t) { pBranch *b; // Declare a new branch object for the 'from' pCode. - _ALLOC(b,sizeof(pBranch)); - b->pc = t; // The link to the 'to' pCode. + //_ALLOC(b,sizeof(pBranch)); + b = Safe_calloc(1,sizeof(pBranch)); + b->pc = PCODE(t); // The link to the 'to' pCode. b->next = NULL; f->to = pBranchAppend(f->to,b); // Now do the same for the 'to' pCode. - _ALLOC(b,sizeof(pBranch)); - b->pc = f; + //_ALLOC(b,sizeof(pBranch)); + b = Safe_calloc(1,sizeof(pBranch)); + b->pc = PCODE(f); b->next = NULL; t->from = pBranchAppend(t->from,b); @@ -1657,6 +2452,7 @@ static void pCodeUnlink(pCode *pc) #endif /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ +#if 0 static void genericAnalyze(pCode *pc) { switch(pc->type) { @@ -1681,9 +2477,40 @@ static void genericAnalyze(pCode *pc) } 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; } } +#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) { + 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; +} /*-----------------------------------------------------------------*/ /* findLabel - Search the pCode for a particular label */ @@ -1692,35 +2519,54 @@ pCode * findLabel(pCodeOpLabel *pcop_label) { pBlock *pb; pCode *pc; - pBranch *pbr; if(!the_pFile) return NULL; for(pb = the_pFile->pbHead; pb; pb = pb->next) { - for(pc = pb->pcHead; pc; pc = pc->next) { - if(pc->type == PC_LABEL) { - if( ((pCodeLabel *)pc)->key == pcop_label->key) - return pc; - } - if(pc->type == PC_OPCODE) { - pbr = pc->label; - while(pbr) { - if(pbr->pc->type == PC_LABEL) { - if( ((pCodeLabel *)(pbr->pc))->key == pcop_label->key) - return pc; - } - pbr = pbr->next; - } - } - - } + for(pc = pb->pcHead; pc; pc = pc->next) + if(compareLabel(pc,pcop_label)) + return pc; + } fprintf(stderr,"Couldn't find label %s", pcop_label->pcop.name); return NULL; } +/*-----------------------------------------------------------------*/ +/* findNextpCode - given a pCode, find the next of type 'pct' */ +/* in the linked list */ +/*-----------------------------------------------------------------*/ +pCode * findNextpCode(pCode *pc, PC_TYPE pct) +{ + + while(pc) { + if(pc->type == pct) + return pc; + + pc = pc->next; + } + + return NULL; +} + +/*-----------------------------------------------------------------*/ +/* findPrevpCode - given a pCode, find the previous of type 'pct' */ +/* in the linked list */ +/*-----------------------------------------------------------------*/ +pCode * findPrevpCode(pCode *pc, PC_TYPE pct) +{ + + while(pc) { + if(pc->type == pct) + return pc; + + pc = pc->prev; + } + + return NULL; +} /*-----------------------------------------------------------------*/ /* findNextInstruction - given a pCode, find the next instruction */ /* in the linked list */ @@ -1729,13 +2575,13 @@ pCode * findNextInstruction(pCode *pc) { while(pc) { - if(pc->type == PC_OPCODE) + if((pc->type == PC_OPCODE) || (pc->type == PC_WILD)) return pc; pc = pc->next; } - fprintf(stderr,"Couldn't find instruction\n"); + //fprintf(stderr,"Couldn't find instruction\n"); return NULL; } @@ -1770,6 +2616,7 @@ static void AnalyzeLabel(pCode *pc) } #endif +#if 0 static void AnalyzeGOTO(pCode *pc) { @@ -1780,74 +2627,463 @@ static void AnalyzeGOTO(pCode *pc) static void AnalyzeSKIP(pCode *pc) { - pBranchLink(pc,findNextInstruction(pc->next)); - pBranchLink(pc,findNextInstruction(pc->next->next)); + 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) +{ + if(!pc || + !isPCI(pc) || + !PCI(pc)->pcop || + PCI(pc)->num_ops == 0 ) + return NULL; + + switch(PCI(pc)->pcop->type) { + case PO_INDF: + case PO_FSR: + return pic14_regWithIdx(PCOR(PCI(pc)->pcop)->rIdx); + + case PO_BIT: + case PO_GPR_TEMP: + fprintf(stderr, "getRegFromInstruction - bit or temp\n"); + return PCOR(PCI(pc)->pcop)->r; + + case PO_IMMEDIATE: + fprintf(stderr, "getRegFromInstruction - immediate\n"); + return NULL; // PCOR(PCI(pc)->pcop)->r; + + case PO_GPR_BIT: + return PCOR(PCI(pc)->pcop)->r; + + case PO_DIR: + fprintf(stderr, "getRegFromInstruction - dir\n"); + //return NULL; PCOR(PCI(pc)->pcop)->r; + return PCOR(PCI(pc)->pcop)->r; + case PO_LITERAL: + fprintf(stderr, "getRegFromInstruction - literal\n"); + break; + + default: + fprintf(stderr, "getRegFromInstruction - unknown reg type %d\n",PCI(pc)->pcop->type); + genericPrint(stderr, pc); + break; + } + + return NULL; + +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ + +void AnalyzepBlock(pBlock *pb) +{ + pCode *pc; + + if(!pb) + return; + + /* Find all of the registers used in this pBlock + * by looking at each instruction and examining it's + * operands + */ + for(pc = pb->pcHead; pc; pc = pc->next) { + + /* Is this an instruction with operands? */ + if(pc->type == PC_OPCODE && PCI(pc)->pcop) { + + if(PCI(pc)->pcop->type == PO_GPR_TEMP) { + + /* Loop through all of the registers declared so far in + this block and see if we find this one there */ + + regs *r = setFirstItem(pb->tregisters); + + while(r) { + if(r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) { + PCOR(PCI(pc)->pcop)->r = r; + break; + } + r = setNextItem(pb->tregisters); + } + + if(!r) { + /* register wasn't found */ + r = Safe_calloc(1, sizeof(regs)); + memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs)); + addSet(&pb->tregisters, r); + PCOR(PCI(pc)->pcop)->r = r; + //fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx); + }/* else + fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx); + */ + } + if(PCI(pc)->pcop->type == PO_GPR_REGISTER) { + if(PCOR(PCI(pc)->pcop)->r) { + pic14_allocWithIdx (PCOR(PCI(pc)->pcop)->r->rIdx); + DFPRINTF((stderr,"found register in pblock: reg 0x%x\n",PCOR(PCI(pc)->pcop)->r->rIdx)); + } else { + if(PCI(pc)->pcop->name) + fprintf(stderr,"ERROR: %s is a NULL register\n",PCI(pc)->pcop->name ); + else + fprintf(stderr,"ERROR: NULL register\n"); + } + } + } + + + } +} + +/*-----------------------------------------------------------------*/ +/* */ +/*-----------------------------------------------------------------*/ +#define PCI_HAS_LABEL(x) ((x) && (PCI(x)->label != NULL)) + +void InsertpFlow(pCode *pc, pCode **pflow) +{ + PCFL(*pflow)->end = pc; + + if(!pc || !pc->next) + return; + + *pflow = newpCodeFlow(); + pCodeInsertAfter(pc, *pflow); +} + +/*-----------------------------------------------------------------*/ +/* BuildFlow(pBlock *pb) - examine the code in a pBlock and build */ +/* the flow blocks. */ +/* + * BuildFlow inserts pCodeFlow objects into the pCode chain at each + * point the instruction flow changes. + */ +/*-----------------------------------------------------------------*/ +void BuildFlow(pBlock *pb) +{ + pCode *pc; + pCode *last_pci=NULL; + pCode *pflow; + int seq = 0; + + if(!pb) + return; + + //fprintf (stderr,"build flow start seq %d ",GpcFlowSeq); + /* Insert a pCodeFlow object at the beginning of a pBlock */ + + pflow = newpCodeFlow(); /* Create a new Flow object */ + pflow->next = pb->pcHead; /* Make the current head the next object */ + pb->pcHead->prev = pflow; /* let the current head point back to the flow object */ + pb->pcHead = pflow; /* Make the Flow object the head */ + pflow->pb = pb; + + for( pc = findNextInstruction(pb->pcHead); + (pc=findNextInstruction(pc)) != NULL; ) { + + pc->seq = seq++; + PCI(pc)->pcflow = PCFL(pflow); + + if(PCI(pc)->isSkip || PCI(pc)->isBranch) { + + /* The instruction immediately following this one + * marks the beginning of a new flow segment */ + + InsertpFlow(pc, &pflow); + seq = 0; + + } else if (PCI_HAS_LABEL(pc)) { + + /* This instruction marks the beginning of a + * new flow segment */ + + pc->seq = 0; + seq = 1; + InsertpFlow(pc->prev, &pflow); + + PCI(pc)->pcflow = PCFL(pflow); + + } + last_pci = pc; + pc = pc->next; + } + + //fprintf (stderr,",end seq %d",GpcFlowSeq); + PCFL(pflow)->end = pb->pcTail; +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void dumpCond(int cond) +{ + + static char *pcc_str[] = { + //"PCC_NONE", + "PCC_REGISTER", + "PCC_C", + "PCC_Z", + "PCC_DC", + "PCC_W", + "PCC_EXAMINE_PCOP", + "PCC_REG_BANK0", + "PCC_REG_BANK1", + "PCC_REG_BANK2", + "PCC_REG_BANK3" + }; + + int ncond = sizeof(pcc_str) / sizeof(char *); + int i,j; + + fprintf(stderr, "0x%04X\n",cond); + + for(i=0,j=1; ipc.seq); + + pc = findNextpCode(PCODE(pcflow), PC_OPCODE); + if(!pc) { + // fprintf(stderr, " FillFlow - empty flow (seq=%d)\n", pcflow->pc.seq); + return; + } + + cur_bank = -1; + + do { + //regs *reg; + + int inCond = PCI(pc)->inCond; + int outCond = PCI(pc)->outCond; +#if 0 + if( (reg = getRegFromInstruction(pc)) != NULL) { + if(isSTATUS_REG(reg)) { + + //fprintf(stderr, " FillFlow - Status register\n"); + + /* Check to see if the register banks are changing */ + if(PCI(pc)->isModReg) { + + pCodeOp *pcop = PCI(pc)->pcop; + switch(PCI(pc)->op) { + case POC_BSF: + if(PCORB(pcop)->bit == PIC_RP0_BIT) + fprintf(stderr, " FillFlow - Set RP0\n"); + //outCond |= PCC_REG_BANK1; + if(PCORB(pcop)->bit == PIC_RP1_BIT) + fprintf(stderr, " FillFlow - Set RP1\n"); + //outCond |= PCC_REG_BANK3; + break; + + case POC_BCF: + if(PCORB(pcop)->bit == PIC_RP0_BIT) + fprintf(stderr, " FillFlow - Clr RP0\n"); + //outCond |= PCC_REG_BANK1; + if(PCORB(pcop)->bit == PIC_RP1_BIT) + fprintf(stderr, " FillFlow - Clr RP1\n"); + //outCond |= PCC_REG_BANK3; + break; + + default: + fprintf(stderr, " FillFlow - Status register is getting Modified by:\n"); + genericPrint(stderr, pc); + } + } + + } else + inCond |= PCC_REG_BANK0 << (REG_BANK(reg) & 3); + } +#endif + + pcflow->inCond |= (inCond & ~pcflow->outCond); + pcflow->outCond |= outCond; + + + + + pc = findNextpCode(pc->next, PC_OPCODE); + } while (pc && (pc != pcflow->end)); + +#if 0 + if(!pc) + fprintf(stderr, " FillFlow - Bad end of flow\n"); + + + fprintf(stderr, " FillFlow inCond: "); + dumpCond(pcflow->inCond); + fprintf(stderr, " FillFlow outCond: "); + dumpCond(pcflow->outCond); +#endif +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void LinkFlow_pCode(pCodeInstruction *from, pCodeInstruction *to) +{ + + if(!from || !to || !to->pcflow || !from->pcflow) + return; + + addSet(&(from->pcflow->to), to->pcflow); + addSet(&(to->pcflow->from), from->pcflow); + +} + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void LinkFlow(pBlock *pb) +{ + pCode *pc=NULL; + pCode *pcflow; + pCode *pct; + + + for( pcflow = findNextpCode(pb->pcHead, PC_FLOW); + (pcflow = findNextpCode(pcflow, PC_FLOW)) != NULL; + pcflow = pcflow->next) { + + if(!isPCFL(pcflow)) + fprintf(stderr, "LinkFlow - pcflow is not a flow object "); + + //FillFlow(PCFL(pcflow)); + + pc = PCFL(pcflow)->end; + + //fprintf(stderr, "LinkFlow - flow block (seq=%d) ", pcflow->seq); + if(isPCI_SKIP(pc)) { + //fprintf(stderr, "ends with skip\n"); + pct=findNextInstruction(pc->next); + LinkFlow_pCode(PCI(pc),PCI(pct)); + pct=findNextInstruction(pct->next); + LinkFlow_pCode(PCI(pc),PCI(pct)); + continue; + } + + if(isPCI_BRANCH(pc)) { + //fprintf(stderr, "ends with branch\n"); + + continue; + } +#if 0 + if(pc) { + fprintf(stderr, "has an unrecognized ending:\n"); + pc->print(stderr,pc); + } + else + fprintf(stderr, "has no end pcode\n"); +#endif + + } +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +int OptimizepBlock(pBlock *pb) +{ + pCode *pc; + int matches =0; + + if(!pb || !peepOptimizing) + return 0; + + DFPRINTF((stderr," Optimizing pBlock: %c\n",getpBlock_dbName(pb))); + for(pc = pb->pcHead; pc; pc = pc->next) + matches += pCodePeepMatchRule(pc); + if(matches) + DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches)); + return matches; } -static void AnalyzeRETURN(pCode *pc) +/*-----------------------------------------------------------------*/ +/* pBlockRemoveUnusedLabels - remove the pCode labels from the */ +/*-----------------------------------------------------------------*/ +pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs) { + pCode *pc; - // branch_link(pc,findFunctionEnd(pc->next)); + for(pc = pcs; pc; pc = pc->next) { -} + if((pc->type == PC_OPCODE) && + (PCI(pc)->pcop) && + (PCI(pc)->pcop->type == PO_LABEL) && + (PCOLAB(PCI(pc)->pcop)->key == pcl->key)) + return pc; + } + + return NULL; +} -void AnalyzepBlock(pBlock *pb) +/*-----------------------------------------------------------------*/ +/* pBlockRemoveUnusedLabels - remove the pCode labels from the */ +/* pCode chain if they're not used. */ +/*-----------------------------------------------------------------*/ +void pBlockRemoveUnusedLabels(pBlock *pb) { - pCode *pc; + pCode *pc; pCodeLabel *pcl; if(!pb) return; - /* Find all of the registers used in this pBlock */ for(pc = pb->pcHead; pc; pc = pc->next) { - if(pc->type == PC_OPCODE) { - if(PCI(pc)->pcop && PCI(pc)->pcop->type == PO_GPR_TEMP) { - /* Loop through all of the registers declared so far in - this block and see if we find this new there */ + if(pc->type == PC_LABEL) + pcl = PCL(pc); + else if ((pc->type == PC_OPCODE) && PCI(pc)->label) + pcl = PCL(PCI(pc)->label->pc); + else continue; - regs *r = setFirstItem(pb->registers); + /* This pCode is a label, so search the pBlock to see if anyone + * refers to it */ - while(r) { - if(r->rIdx == PCOR(PCI(pc)->pcop)->r->rIdx) { - PCOR(PCI(pc)->pcop)->r = r; - break; - } - r = setNextItem(pb->registers); - } + if( (pcl->key>0) && (!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 */ - if(!r) { - /* register wasn't found */ - r = Safe_calloc(1, sizeof(regs)); - memcpy(r,PCOR(PCI(pc)->pcop)->r, sizeof(regs)); - addSet(&pb->registers, r); - PCOR(PCI(pc)->pcop)->r = r; - fprintf(stderr,"added register to pblock: reg %d\n",r->rIdx); - } else - fprintf(stderr,"found register in pblock: reg %d\n",r->rIdx); + DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d\n", pcl->key)); + + if(pc->type == PC_LABEL) { + unlinkPC(pc); + pCodeLabelDestruct(pc); + } else { + unlinkpCodeFromBranch(pc, PCODE(pcl)); + /*if(pc->label->next == NULL && pc->label->pc == NULL) { + free(pc->label); + }*/ } + } } -} - -int OptimizepBlock(pBlock *pb) -{ - pCode *pc; - int matches =0; - - if(!pb || !peepOptimizing) - return 0; - - fprintf(stderr," Optimizing pBlock\n"); - for(pc = pb->pcHead; pc; pc = pc->next) - matches += pCodePeepMatchRule(pc); +} - return matches; -} /*-----------------------------------------------------------------*/ /* pBlockMergeLabels - remove the pCode labels from the pCode */ /* chain and put them into pBranches that are */ @@ -1862,32 +3098,42 @@ void pBlockMergeLabels(pBlock *pb) if(!pb) return; + /* First, Try to remove any unused labels */ + //pBlockRemoveUnusedLabels(pb); + + /* Now loop through the pBlock and merge the labels with the opcodes */ + for(pc = pb->pcHead; pc; pc = pc->next) { if(pc->type == PC_LABEL) { + //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key); if( !(pcnext = findNextInstruction(pc)) ) return; // Couldn't find an instruction associated with this label // Unlink the pCode label from it's pCode chain - if(pc->prev) - pc->prev->next = pc->next; - if(pc->next) - pc->next->prev = pc->prev; + unlinkPC(pc); + //fprintf(stderr,"Merged label key = %d\n",PCL(pc)->key); // And link it into the instruction's pBranch labels. (Note, since // it's possible to have multiple labels associated with one instruction // we must provide a means to accomodate the additional labels. Thus // the labels are placed into the singly-linked list "label" as // opposed to being a single member of the pCodeInstruction.) - _ALLOC(pbr,sizeof(pBranch)); + //_ALLOC(pbr,sizeof(pBranch)); + pbr = Safe_calloc(1,sizeof(pBranch)); pbr->pc = pc; pbr->next = NULL; - pcnext->label = pBranchAppend(pcnext->label,pbr); + PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr); + if(pcnext->prev) + pc = pcnext->prev; + else + pc = pcnext; } } + pBlockRemoveUnusedLabels(pb); } @@ -1904,7 +3150,7 @@ void OptimizepCode(char dbName) if(!the_pFile) return; - fprintf(stderr," Optimizing pCode\n"); + DFPRINTF((stderr," Optimizing pCode\n")); do { for(pb = the_pFile->pbHead; pb; pb = pb->next) { @@ -1917,36 +3163,246 @@ void OptimizepCode(char dbName) } /*-----------------------------------------------------------------*/ -/* AnalyzepCode - parse the pCode that has been generated and form */ -/* all of the logical connections. */ -/* */ -/* Essentially what's done here is that the pCode flow is */ -/* determined. */ +/* popCopy - copy a pcode operator */ /*-----------------------------------------------------------------*/ +pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval) +{ + pCodeOp *pcop; -void AnalyzepCode(char dbName) + pcop = newpCodeOpBit(pc->name, bitval, 0); + + if( !( (pcop->type == PO_LABEL) || + (pcop->type == PO_LITERAL) || + (pcop->type == PO_STR) )) + PCOR(pcop)->r = PCOR(pc)->r; /* This is dangerous... */ + + return pcop; +} + + + +#if 0 +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +int InstructionRegBank(pCode *pc) +{ + regs *reg; + + if( (reg = getRegFromInstruction(pc)) == NULL) + return -1; + + return REG_BANK(reg); + +} +#endif + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +void FixRegisterBanking(pBlock *pb) +{ + pCode *pc=NULL; + pCode *pcprev=NULL; + pCode *new_pc; + + int cur_bank; + regs *reg; + return; + if(!pb) + return; + + pc = findNextpCode(pb->pcHead, PC_FLOW); + if(!pc) + return; + /* loop through all of the flow blocks with in one pblock */ + + // fprintf(stderr,"Register banking\n"); + cur_bank = 0; + do { + /* at this point, pc should point to a PC_FLOW object */ + + + /* for each flow block, determine the register banking + requirements */ + + do { + if(isPCI(pc)) { + genericPrint(stderr, pc); + + reg = getRegFromInstruction(pc); + //#if 0 + if(reg) { + fprintf(stderr, " %s ",reg->name); + fprintf(stderr, "addr = 0x%03x, bank = %d\n",reg->address,REG_BANK(reg)); + + } + //#endif + if(reg && REG_BANK(reg)!=cur_bank) { + /* Examine the instruction before this one to make sure it is + * not a skip type instruction */ + pcprev = findPrevpCode(pc->prev, PC_OPCODE); + if(pcprev && !isPCI_SKIP(pcprev)) { + int b = cur_bank ^ REG_BANK(reg); + + //fprintf(stderr, "Cool! can switch banks\n"); + cur_bank = REG_BANK(reg); + if(b & 1) { + new_pc = newpCode(((cur_bank&1) ? POC_BSF : POC_BCF), + popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT)); + pCodeInsertAfter(pc->prev, new_pc); + if(PCI(pc)->label) { + PCI(new_pc)->label = PCI(pc)->label; + PCI(pc)->label = NULL; + } + /* + new_pc = newpCode(((cur_bank&1) ? POC_BCF : POC_BSF), + popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT)); + pCodeInsertAfter(pc, new_pc); + */ + + } + + } else + fprintf(stderr, "Bummer can't switch banks\n"); + } + } + + pcprev = pc; + pc = pc->next; + } while(pc && !(isPCFL(pc))); + + if(pcprev && cur_bank) { + /* Brute force - make sure that we point to bank 0 at the + * end of each flow block */ + new_pc = newpCode(POC_BCF, + popCopyGPR2Bit(PCOP(&pc_status),PIC_RP0_BIT)); + pCodeInsertAfter(pcprev, new_pc); + cur_bank = 0; + } + + }while (pc); + +} + +void pBlockDestruct(pBlock *pb) +{ + + if(!pb) + return; + + + free(pb); + +} + +/*-----------------------------------------------------------------*/ +/* void mergepBlocks(char dbName) - Search for all pBlocks with the*/ +/* name dbName and combine them */ +/* into one block */ +/*-----------------------------------------------------------------*/ +void mergepBlocks(char dbName) +{ + + pBlock *pb, *pbmerged = NULL,*pbn; + + pb = the_pFile->pbHead; + + //fprintf(stderr," merging blocks named %c\n",dbName); + while(pb) { + + pbn = pb->next; + //fprintf(stderr,"looking at %c\n",getpBlock_dbName(pb)); + if( getpBlock_dbName(pb) == dbName) { + + //fprintf(stderr," merged block %c\n",dbName); + + if(!pbmerged) { + pbmerged = pb; + } else { + addpCode2pBlock(pbmerged, pb->pcHead); + /* addpCode2pBlock doesn't handle the tail: */ + pbmerged->pcTail = pb->pcTail; + + pb->prev->next = pbn; + if(pbn) + pbn->prev = pb->prev; + + + pBlockDestruct(pb); + } + //printpBlock(stderr, pbmerged); + } + pb = pbn; + } + +} + +/*-----------------------------------------------------------------*/ +/* AnalyzeBanking - Called after the memory addresses have been */ +/* assigned to the registers. */ +/* */ +/*-----------------------------------------------------------------*/ +void AnalyzeBanking(void) { + pBlock *pb; - pCode *pc; - pBranch *pbr; if(!the_pFile) return; - fprintf(stderr," Analyzing pCode"); - /* First, merge the labels with the instructions */ + /* 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); + + for(pb = the_pFile->pbHead; pb; pb = pb->next) + FixRegisterBanking(pb); + + /* debug stuff */ for(pb = the_pFile->pbHead; pb; pb = pb->next) { - if('*' == dbName || getpBlock_dbName(pb) == dbName) { - pBlockMergeLabels(pb); - AnalyzepBlock(pb); + 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) { - if('*' == dbName || getpBlock_dbName(pb) == dbName) - OptimizepBlock(pb); - } + +} + +/*-----------------------------------------------------------------*/ +/* buildCallTree - look at the flow and extract all of the calls */ +/* */ +/*-----------------------------------------------------------------*/ +set *register_usage(pBlock *pb); + +void buildCallTree(void ) +{ + pBranch *pbr; + pBlock *pb; + pCode *pc; + + if(!the_pFile) + return; + + /* Now build the call tree. First we examine all of the pCodes for functions. @@ -1975,36 +3431,109 @@ void AnalyzepCode(char dbName) */ for(pb = the_pFile->pbHead; pb; pb = pb->next) { - if('*' == dbName || getpBlock_dbName(pb) == dbName) { - pCode *pc_fstart=NULL; - for(pc = pb->pcHead; pc; pc = pc->next) { - if(pc->type == PC_FUNCTION) { - if (PCF(pc)->fname) { - // I'm not liking this.... - // Found the beginning of a function. - _ALLOC(pbr,sizeof(pBranch)); - pbr->pc = pc_fstart = pc; - pbr->next = NULL; - - the_pFile->functions = pBranchAppend(the_pFile->functions,pbr); - - // Here's a better way of doing the same: - addSet(&pb->function_entries, pc); - - } else { - // Found an exit point in a function, e.g. return - // (Note, there may be more than one return per function) - if(pc_fstart) - pBranchLink(pc_fstart, pc); - - addSet(&pb->function_exits, pc); + pCode *pc_fstart=NULL; + for(pc = pb->pcHead; pc; pc = pc->next) { + if(isPCF(pc)) { //pc->type == PC_FUNCTION) { + if (PCF(pc)->fname) { + + if(STRCASECMP(PCF(pc)->fname, "_main") == 0) { + fprintf(stderr," found main \n"); + pb->cmemmap = NULL; /* FIXME do we need to free ? */ + pb->dbName = 'M'; } - } else if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) { - addSet(&pb->function_calls,pc); + + //_ALLOC(pbr,sizeof(pBranch)); + pbr = Safe_calloc(1,sizeof(pBranch)); + pbr->pc = pc_fstart = pc; + pbr->next = NULL; + + the_pFile->functions = pBranchAppend(the_pFile->functions,pbr); + + // Here's a better way of doing the same: + addSet(&pb->function_entries, pc); + + } else { + // Found an exit point in a function, e.g. return + // (Note, there may be more than one return per function) + if(pc_fstart) + pBranchLink(PCF(pc_fstart), PCF(pc)); + + addSet(&pb->function_exits, pc); } + } else if(isCALL(pc)) {// if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) { + addSet(&pb->function_calls,pc); } } } + + /* Re-allocate the registers so that there are no collisions + * between local variables when one function call another */ + + pic14_deallocateAllRegs(); + + for(pb = the_pFile->pbHead; pb; pb = pb->next) { + if(!pb->visited) + register_usage(pb); + } + +} + +/*-----------------------------------------------------------------*/ +/* AnalyzepCode - parse the pCode that has been generated and form */ +/* all of the logical connections. */ +/* */ +/* Essentially what's done here is that the pCode flow is */ +/* determined. */ +/*-----------------------------------------------------------------*/ + +void AnalyzepCode(char dbName) +{ + pBlock *pb; + int i,changes; + + if(!the_pFile) + return; + + mergepBlocks('D'); + + + /* Phase 1 - Register allocation and peep hole optimization + * + * The first part of the analysis is to determine the registers + * that are used in the pCode. Once that is done, the peep rules + * are applied to the code. We continue to loop until no more + * peep rule optimizations are found (or until we exceed the + * MAX_PASSES threshold). + * + * When done, the required registers will be determined. + * + */ + i = 0; + do { + + DFPRINTF((stderr," Analyzing pCode: PASS #%d\n",i+1)); + + /* First, merge the labels with the instructions */ + for(pb = the_pFile->pbHead; pb; pb = pb->next) { + if('*' == dbName || getpBlock_dbName(pb) == dbName) { + + DFPRINTF((stderr," analyze and merging block %c\n",dbName)); + //fprintf(stderr," analyze and merging block %c\n",getpBlock_dbName(pb)); + pBlockMergeLabels(pb); + AnalyzepBlock(pb); + } + } + + changes = 0; + + for(pb = the_pFile->pbHead; pb; pb = pb->next) { + if('*' == dbName || getpBlock_dbName(pb) == dbName) + changes += OptimizepBlock(pb); + } + + } while(changes && (i++ < MAX_PASSES)); + + buildCallTree(); } /*-----------------------------------------------------------------*/ @@ -2069,46 +3598,48 @@ void pBlockStats(FILE *of, pBlock *pb) pCode *pc; regs *r; - fprintf(of,"***\n pBlock Stats\n***\n"); + fprintf(of,";***\n; pBlock Stats: dbName = %c\n;***\n",getpBlock_dbName(pb)); // for now just print the first element of each set pc = setFirstItem(pb->function_entries); if(pc) { - fprintf(of,"entry\n"); + fprintf(of,";entry: "); pc->print(of,pc); } pc = setFirstItem(pb->function_exits); if(pc) { - fprintf(of,"has an exit\n"); - pc->print(of,pc); + fprintf(of,";has an exit\n"); + //pc->print(of,pc); } pc = setFirstItem(pb->function_calls); if(pc) { - fprintf(of,"functions called\n"); + fprintf(of,";functions called:\n"); while(pc) { - pc->print(of,pc); + if(pc->type == PC_OPCODE && PCI(pc)->op == POC_CALL) { + fprintf(of,"; %s\n",get_op(PCI(pc))); + } pc = setNextItem(pb->function_calls); } } - r = setFirstItem(pb->registers); + r = setFirstItem(pb->tregisters); if(r) { - int n = elementsInSet(pb->registers); + int n = elementsInSet(pb->tregisters); - fprintf(of,"%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' ')); + fprintf(of,";%d compiler assigned register%c:\n",n, ( (n!=1) ? 's' : ' ')); while (r) { - fprintf(of," %s\n",r->name); - r = setNextItem(pb->registers); + fprintf(of,"; %s\n",r->name); + r = setNextItem(pb->tregisters); } } } /*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/ -void sequencepCode(void) +static void sequencepCode(void) { pBlock *pb; pCode *pc; @@ -2158,8 +3689,13 @@ set *register_usage(pBlock *pb) } - +#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 */ @@ -2167,33 +3703,36 @@ set *register_usage(pBlock *pb) regs *r1,*r2, *newreg; - fprintf(stderr,"comparing registers\n"); + DFPRINTF((stderr,"comparing registers\n")); r1 = setFirstItem(registersInCallPath); while(r1) { - r2 = setFirstItem(pb->registers); + r2 = setFirstItem(pb->tregisters); - while(r2) { + while(r2 && (r1->type != REG_STK)) { if(r2->rIdx == r1->rIdx) { - newreg = pic14_findFreeReg(); + newreg = pic14_findFreeReg(REG_GPR); if(!newreg) { - fprintf(stderr,"Bummer, no more registers.\n"); + DFPRINTF((stderr,"Bummer, no more registers.\n")); exit(1); } - fprintf(stderr,"Cool found register collision nIdx=%d moving to %d\n", - r1->rIdx, newreg->rIdx); + DFPRINTF((stderr,"Cool found register collision nIdx=%d moving to %d\n", + r1->rIdx, newreg->rIdx)); r2->rIdx = newreg->rIdx; //if(r2->name) free(r2->name); - r2->name = Safe_strdup(newreg->name); + if(newreg->name) + r2->name = Safe_strdup(newreg->name); + else + r2->name = NULL; newreg->isFree = 0; newreg->wasUsed = 1; } - r2 = setNextItem(pb->registers); + r2 = setNextItem(pb->tregisters); } r1 = setNextItem(registersInCallPath); @@ -2202,24 +3741,26 @@ set *register_usage(pBlock *pb) /* Collisions have been resolved. Now free the registers in the call path */ r1 = setFirstItem(registersInCallPath); while(r1) { - newreg = pic14_regWithIdx(r1->rIdx); - newreg->isFree = 1; + if(r1->type != REG_STK) { + newreg = pic14_regWithIdx(r1->rIdx); + newreg->isFree = 1; + } r1 = setNextItem(registersInCallPath); } - } else - MarkUsedRegisters(pb->registers); - - registers = unionSets(pb->registers, registersInCallPath, THROW_NONE); + }// else + // MarkUsedRegisters(pb->registers); + registers = unionSets(pb->tregisters, registersInCallPath, THROW_NONE); +#ifdef PCODE_DEBUG if(registers) - fprintf(stderr,"returning regs\n"); + DFPRINTF((stderr,"returning regs\n")); else - fprintf(stderr,"not returning regs\n"); + DFPRINTF((stderr,"not returning regs\n")); - fprintf(stderr,"pBlock after register optim.\n"); + DFPRINTF((stderr,"pBlock after register optim.\n")); pBlockStats(stderr,pb); // debug - +#endif return registers; } @@ -2305,7 +3846,10 @@ void pct2(FILE *of,pBlock *pb,int indent) r1->rIdx, newreg->rIdx); r2->rIdx = newreg->rIdx; //if(r2->name) free(r2->name); - r2->name = Safe_strdup(newreg->name); + if(newreg->name) + r2->name = Safe_strdup(newreg->name); + else + r2->name = NULL; newreg->isFree = 0; newreg->wasUsed = 1; } @@ -2361,7 +3905,7 @@ void printCallTree(FILE *of) fprintf(of, "\npBlock statistics\n"); for(pb = the_pFile->pbHead; pb; pb = pb->next ) - pBlockStats(stderr,pb); + pBlockStats(of,pb); @@ -2389,13 +3933,14 @@ void printCallTree(FILE *of) /* Re-allocate the registers so that there are no collisions * between local variables when one function call another */ - +#if 0 pic14_deallocateAllRegs(); for(pb = the_pFile->pbHead; pb; pb = pb->next) { if(!pb->visited) register_usage(pb); } +#endif fprintf(of,"\n**************\n\na better call tree\n"); for(pb = the_pFile->pbHead; pb; pb = pb->next) {