From: sdattalo Date: Sun, 29 Apr 2001 15:35:13 +0000 (+0000) Subject: Parse peephole snippets to generate pCode X-Git-Url: https://git.gag.com/?a=commitdiff_plain;h=770fc9071007c38b9862dabce12704e4c7ac22b1;p=fw%2Fsdcc Parse peephole snippets to generate pCode git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@762 4a8a32a2-be11-0410-ad9d-d568d2c75423 --- diff --git a/src/pic/pcode.c b/src/pic/pcode.c index c41045ae..1e80a054 100644 --- a/src/pic/pcode.c +++ b/src/pic/pcode.c @@ -31,6 +31,9 @@ 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}; +static int mnemonics_initialized = 0; + +#if 0 //static char *PIC_mnemonics[] = { static char *scpADDLW = "ADDLW"; static char *scpADDWF = "ADDWF"; @@ -62,6 +65,10 @@ static char *scpSUBWF = "SUBWF"; static char *scpTRIS = "TRIS"; static char *scpXORLW = "XORLW"; static char *scpXORWF = "XORWF"; +#endif + +static hTab *pic14MnemonicsHash = NULL; + static pFile *the_pFile = NULL; @@ -89,6 +96,575 @@ int pCodePeepMatchLine(pCodePeep *peepBlock, pCode *pcs, pCode *pcd); int pCodePeepMatchRule(pCode *pc); +pCodeInstruction pciADDWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ADDWF, + "ADDWF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z) // outCond +}; + +pCodeInstruction pciADDFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ADDWF, + "ADDWF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciADDLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ADDLW, + "ADDLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond +}; + +pCodeInstruction pciANDLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ANDLW, + "ANDLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciANDWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ANDWF, + "ANDWF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z) // outCond +}; + +pCodeInstruction pciANDFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_ANDWF, + "ANDWF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciBCF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_BCF, + "BCF", + NULL, // operand + 2, // num ops + 0,1, // dest, bit instruction + PCC_NONE, // inCond + PCC_EXAMINE_PCOP // outCond +}; + +pCodeInstruction pciBSF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_BSF, + "BSF", + NULL, // operand + 2, // num ops + 0,1, // dest, bit instruction + PCC_NONE, // inCond + PCC_EXAMINE_PCOP // outCond +}; + +pCodeInstruction pciBTFSC = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_BTFSC, + "BTFSC", + NULL, // operand + 2, // num ops + 0,1, // dest, bit instruction + PCC_EXAMINE_PCOP, // inCond + PCC_NONE // outCond +}; + +pCodeInstruction pciBTFSS = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_BTFSS, + "BTFSS", + NULL, // operand + 2, // num ops + 0,1, // dest, bit instruction + PCC_EXAMINE_PCOP, // inCond + PCC_NONE // outCond +}; + +pCodeInstruction pciCALL = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_CALL, + "CALL", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_NONE // outCond +}; + +//fixme - need a COMFW instruction. +pCodeInstruction pciCOMF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_COMF, + "COMF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_NONE // outCond +}; + +pCodeInstruction pciCLRF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_CLRF, + "CLRF", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciCLRW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_CLRW, + "CLRW", + NULL, // operand + 0, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciDECF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_DECF, + "DECF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciDECFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_DECFW, + "DECF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciDECFSZ = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_DECFSZ, + "DECFSZ", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciDECFSZW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_DECFSZW, + "DECFSZ", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciGOTO = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeGOTO, + genericDestruct, + genericPrint}, + POC_GOTO, + "GOTO", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_NONE // outCond +}; + + +pCodeInstruction pciINCF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_INCF, + "INCF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciINCFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_INCFW, + "INCF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciINCFSZ = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_INCFSZ, + "INCFSZ", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_REGISTER // outCond +}; + +pCodeInstruction pciINCFSZW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeSKIP, + genericDestruct, + genericPrint}, + POC_INCFSZW, + "INCFSZ", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciIORWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_IORWF, + "IORWF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z) // outCond +}; + +pCodeInstruction pciIORFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_IORWF, + "IORWF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciIORLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_IORLW, + "IORLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciMOVF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_MOVF, + "MOVF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_Z // outCond +}; + +pCodeInstruction pciMOVFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_MOVFW, + "MOVF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciMOVWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_MOVWF, + "MOVWF", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + 0 // outCond +}; + +pCodeInstruction pciMOVLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_MOVLW, + "MOVLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciNEGF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_NEGF, + "NEGF", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_REGISTER, // inCond + PCC_NONE // outCond +}; + + +pCodeInstruction pciRETLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeRETURN, + genericDestruct, + genericPrint}, + POC_RETLW, + "RETLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_W // outCond +}; + +pCodeInstruction pciRETURN = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + AnalyzeRETURN, + genericDestruct, + genericPrint}, + POC_RETLW, + "RETURN", + NULL, // operand + 0, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_W // outCond +}; + + +pCodeInstruction pciSUBWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_SUBWF, + "SUBWF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z) // outCond +}; + +pCodeInstruction pciSUBFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_SUBWF, + "SUBWF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciSUBLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_SUBLW, + "SUBLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond +}; + +pCodeInstruction pciTRIS = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_TRIS, + "TRIS", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_NONE, // inCond + PCC_NONE +}; + + +pCodeInstruction pciXORWF = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_XORWF, + "XORWF", + NULL, // operand + 2, // num ops + 1,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_REGISTER | PCC_Z) // outCond +}; + +pCodeInstruction pciXORFW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_XORWF, + "XORWF", + NULL, // operand + 2, // num ops + 0,0, // dest, bit instruction + (PCC_W | PCC_REGISTER), // inCond + (PCC_W | PCC_Z) // outCond +}; + +pCodeInstruction pciXORLW = { + {PC_OPCODE, NULL, NULL, 0, NULL, NULL, NULL, NULL, + genericAnalyze, + genericDestruct, + genericPrint}, + POC_XORLW, + "XORLW", + NULL, // operand + 1, // num ops + 0,0, // dest, bit instruction + PCC_W, // inCond + (PCC_W | PCC_Z | PCC_C | PCC_DC) // outCond +}; + + +#define MAX_PIC14MNEMONICS 100 +pCodeInstruction *pic14Mnemonics[MAX_PIC14MNEMONICS]; + char *Safe_strdup(char *str) { char *copy; @@ -114,6 +690,127 @@ void pCodeInitRegisters(void) } +/*-----------------------------------------------------------------*/ +/* mnem2key - convert a pic mnemonic into a hash key */ +/* (BTW - this spreads the mnemonics quite well) */ +/* */ +/*-----------------------------------------------------------------*/ + +int mnem2key(char *mnem) +{ + int key = 0; + + if(!mnem) + return 0; + + while(*mnem) { + + key += *mnem++ +1; + + } + + return (key & 0x1f); + +} + +void pic14initMnemonics(void) +{ + int i = 0; + int key; + // char *str; + pCodeInstruction *pci; + + if(mnemonics_initialized) + return; + + pic14Mnemonics[POC_ADDLW] = &pciADDLW; + pic14Mnemonics[POC_ADDWF] = &pciADDWF; + pic14Mnemonics[POC_ADDFW] = &pciADDFW; + pic14Mnemonics[POC_ANDLW] = &pciANDLW; + pic14Mnemonics[POC_ANDWF] = &pciANDWF; + pic14Mnemonics[POC_ANDFW] = &pciANDFW; + pic14Mnemonics[POC_BCF] = &pciBCF; + pic14Mnemonics[POC_BSF] = &pciBSF; + pic14Mnemonics[POC_BTFSC] = &pciBTFSC; + pic14Mnemonics[POC_BTFSS] = &pciBTFSS; + pic14Mnemonics[POC_CALL] = &pciCALL; + pic14Mnemonics[POC_COMF] = &pciCOMF; + pic14Mnemonics[POC_CLRF] = &pciCLRF; + pic14Mnemonics[POC_CLRW] = &pciCLRW; + pic14Mnemonics[POC_DECF] = &pciDECF; + pic14Mnemonics[POC_DECFW] = &pciDECFW; + pic14Mnemonics[POC_DECFSZ] = &pciDECFSZ; + pic14Mnemonics[POC_DECFSZW] = &pciDECFSZW; + pic14Mnemonics[POC_GOTO] = &pciGOTO; + pic14Mnemonics[POC_INCF] = &pciINCF; + pic14Mnemonics[POC_INCFW] = &pciINCFW; + pic14Mnemonics[POC_INCFSZ] = &pciINCFSZ; + pic14Mnemonics[POC_INCFSZW] = &pciINCFSZW; + pic14Mnemonics[POC_IORLW] = &pciIORLW; + pic14Mnemonics[POC_IORWF] = &pciIORWF; + pic14Mnemonics[POC_IORFW] = &pciIORFW; + pic14Mnemonics[POC_MOVF] = &pciMOVF; + pic14Mnemonics[POC_MOVFW] = &pciMOVFW; + pic14Mnemonics[POC_MOVLW] = &pciMOVLW; + pic14Mnemonics[POC_MOVWF] = &pciMOVWF; + pic14Mnemonics[POC_NEGF] = &pciNEGF; + pic14Mnemonics[POC_RETLW] = &pciRETLW; + pic14Mnemonics[POC_RETURN] = &pciRETURN; + pic14Mnemonics[POC_SUBLW] = &pciSUBLW; + pic14Mnemonics[POC_SUBWF] = &pciSUBWF; + pic14Mnemonics[POC_SUBFW] = &pciSUBFW; + pic14Mnemonics[POC_TRIS] = &pciTRIS; + pic14Mnemonics[POC_XORLW] = &pciXORLW; + pic14Mnemonics[POC_XORWF] = &pciXORWF; + pic14Mnemonics[POC_XORFW] = &pciXORFW; + + 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); + pci = hTabNextItem(pic14MnemonicsHash, &key); + } + + mnemonics_initialized = 1; +} + + char getpBlock_dbName(pBlock *pb) { if(!pb) @@ -186,6 +883,8 @@ void pcode_test(void) printf("pcode is alive!\n"); + //initMnemonics(); + if(the_pFile) { pBlock *pb; @@ -260,198 +959,29 @@ static int RegCond(pCodeOp *pcop) pCode *newpCode (PIC_OPCODE op, pCodeOp *pcop) { pCodeInstruction *pci ; - + if(!mnemonics_initialized) + pic14initMnemonics(); + pci = Safe_calloc(1, sizeof(pCodeInstruction)); - pci->pc.analyze = genericAnalyze; // pointers to the generic functions, it - pci->pc.destruct = genericDestruct; // doesn't hurt to think about C++ virtual - pci->pc.print = genericPrint; // functions here. - pci->pc.type = PC_OPCODE; // - pci->op = op; // the "opcode" for the instruction. - pci->pc.prev = pci->pc.next = NULL; // The pCode gets linked in later - pci->pcop = pcop; // The operand of the instruction - pci->dest = 0; // e.g. W or F - pci->bit_inst = 0; // e.g. btfxx instructions - pci->num_ops = 2; // Most instructions have two ops... - pci->inCond = pci->outCond = PCC_NONE; /* input/output conditions. This is used during - * optimization to ascertain instruction dependencies. - * For example, if an instruction affects the Z bit, - * then the output condition for this instruction - * is "z bit is affected". The "conditions" are bit - * constants defined in pcode.h. */ - pci->pc.from = pci->pc.to = NULL; // Flow linkages are defined later - pci->pc.label = NULL; // Labels get merged into instructions here. - pci->pc.pb = NULL; // The pBlock to which this instruction belongs - - if(pcop && pcop->name) - printf("newpCode operand name %s\n",pcop->name); - - // The most pic dependent portion of the pCode logic: - switch(op) { - - case POC_ANDLW: - pci->inCond = PCC_W; - pci->outCond = PCC_W | PCC_Z; - pci->mnemonic = scpANDLW; - pci->num_ops = 1; - break; - case POC_ANDWF: - pci->dest = 1; - pci->inCond = PCC_W | PCC_REGISTER; - pci->outCond = PCC_REGISTER | PCC_Z; - pci->mnemonic = scpANDWF; - break; - case POC_ANDFW: - pci->inCond = PCC_W | PCC_REGISTER; - pci->outCond = PCC_W | PCC_Z; - pci->mnemonic = scpANDWF; - break; + if((op < MAX_PIC14MNEMONICS) && pic14Mnemonics[op]) { + memcpy(pci, pic14Mnemonics[op], sizeof(pCodeInstruction)); + pci->pcop = pcop; - case POC_ADDLW: - pci->inCond = PCC_W; - pci->outCond = PCC_W | PCC_Z | PCC_C | PCC_DC; - pci->mnemonic = scpADDLW; - pci->num_ops = 1; - break; - case POC_ADDWF: - pci->dest = 1; - pci->inCond = PCC_W | PCC_REGISTER; - pci->outCond = PCC_REGISTER | PCC_Z | PCC_C | PCC_DC; - pci->mnemonic = scpADDWF; - break; - case POC_ADDFW: - pci->inCond = PCC_W | PCC_REGISTER; - pci->outCond = PCC_W | PCC_Z | PCC_C | PCC_DC; - pci->mnemonic = scpADDWF; - break; + if(pci->inCond == PCC_EXAMINE_PCOP) + pci->inCond = RegCond(pcop); - case POC_BCF: - pci->bit_inst = 1; - pci->mnemonic = scpBCF; - pci->outCond = RegCond(pcop); - break; - case POC_BSF: - pci->bit_inst = 1; - pci->mnemonic = scpBSF; - pci->outCond = RegCond(pcop); - break; - case POC_BTFSC: - pci->bit_inst = 1; - pci->mnemonic = scpBTFSC; - pci->pc.analyze = AnalyzeSKIP; - pci->inCond = RegCond(pcop); - break; - case POC_BTFSS: - pci->bit_inst = 1; - pci->mnemonic = scpBTFSS; - pci->pc.analyze = AnalyzeSKIP; - pci->inCond = RegCond(pcop); - break; - case POC_CALL: - pci->num_ops = 1; - pci->mnemonic = scpCALL; - break; - case POC_COMF: - pci->mnemonic = scpCOMF; - break; - case POC_CLRF: - pci->num_ops = 1; - pci->mnemonic = scpCLRF; - break; - case POC_CLRW: - pci->num_ops = 0; - pci->mnemonic = scpCLRW; - break; - case POC_DECF: - pci->dest = 1; - case POC_DECFW: - pci->mnemonic = scpDECF; - break; - case POC_DECFSZ: - pci->dest = 1; - case POC_DECFSZW: - pci->mnemonic = scpDECFSZ; - pci->pc.analyze = AnalyzeSKIP; - break; - case POC_GOTO: - pci->num_ops = 1; - pci->mnemonic = scpGOTO; - pci->pc.analyze = AnalyzeGOTO; - break; - case POC_INCF: - pci->dest = 1; - case POC_INCFW: - pci->mnemonic = scpINCF; - break; - case POC_INCFSZ: - pci->dest = 1; - case POC_INCFSZW: - pci->mnemonic = scpINCFSZ; - pci->pc.analyze = AnalyzeSKIP; - break; - case POC_IORLW: - pci->num_ops = 1; - pci->mnemonic = scpIORLW; - break; - case POC_IORWF: - pci->dest = 1; - case POC_IORFW: - pci->mnemonic = scpIORWF; - break; - case POC_MOVF: - pci->dest = 1; - case POC_MOVFW: - pci->mnemonic = scpMOVF; - break; - case POC_MOVLW: - pci->num_ops = 1; - pci->mnemonic = scpMOVLW; - break; - case POC_MOVWF: - pci->num_ops = 1; - pci->mnemonic = scpMOVWF; - break; - case POC_NEGF: - pci->mnemonic = scpNEGF; - break; - case POC_RETLW: - pci->num_ops = 1; - pci->mnemonic = scpRETLW; - pci->pc.analyze = AnalyzeRETURN; - break; - case POC_RETURN: - pci->num_ops = 0; - pci->mnemonic = scpRETURN; - pci->pc.analyze = AnalyzeRETURN; - break; - case POC_SUBLW: - pci->mnemonic = scpSUBLW; - pci->num_ops = 1; - break; - case POC_SUBWF: - pci->dest = 1; - case POC_SUBFW: - pci->mnemonic = scpSUBWF; - break; - case POC_TRIS: - pci->mnemonic = scpTRIS; - break; - case POC_XORLW: - pci->num_ops = 1; - pci->mnemonic = scpXORLW; - break; - case POC_XORWF: - pci->dest = 1; - case POC_XORFW: - pci->mnemonic = scpXORWF; - break; + if(pci->outCond == PCC_EXAMINE_PCOP) + pci->outCond = RegCond(pcop); - default: - pci->pc.print = genericPrint; + return (pCode *)pci; } - - return (pCode *)pci; + + fprintf(stderr, "pCode mnemonic error %s,%d\n",__FUNCTION__,__LINE__); + exit(1); + + return NULL; } /*-----------------------------------------------------------------*/ diff --git a/src/pic/pcode.h b/src/pic/pcode.h index cdd4a1a6..5efd207e 100644 --- a/src/pic/pcode.h +++ b/src/pic/pcode.h @@ -147,6 +147,7 @@ typedef enum #define PCC_Z (1<<2) #define PCC_DC (1<<3) #define PCC_W (1<<4) +#define PCC_EXAMINE_PCOP (1<<5) /*********************************************************************** * @@ -361,7 +362,7 @@ typedef struct pCodeInstruction PIC_OPCODE op; // The opcode of the instruction. - char *mnemonic; // Pointer to mnemonic string + char const * const mnemonic; // Pointer to mnemonic string pCodeOp *pcop; // Operand diff --git a/src/pic/pcodepeep.c b/src/pic/pcodepeep.c index 8b3e0575..fc609c77 100644 --- a/src/pic/pcodepeep.c +++ b/src/pic/pcodepeep.c @@ -19,6 +19,7 @@ -------------------------------------------------------------------------*/ #include +#include #include "common.h" // Include everything in the SDCC src directory #include "newalloc.h" @@ -41,7 +42,9 @@ char *Safe_strdup(char *str); * defined in peep.def. */ -extern peepRule *rootRules; +//extern peepRule *rootRules; + + /****************************************************************/ @@ -62,6 +65,514 @@ typedef struct pCodePeepSnippets static pCodePeepSnippets *peepSnippets=NULL; +typedef struct pCodeToken +{ + int tt; // token type; + union { + char c; // character + int n; // number + char *s; // string + } tok; + +} pCodeToken; + +pCodeToken tokArr[50]; +unsigned tokIdx=0; + + +typedef enum { + PCT_SPACE, + PCT_PERCENT, + PCT_COLON, + PCT_COMMA, + PCT_COMMENT, + PCT_STRING, + PCT_NUMBER + +} pCodeTokens; + + +typedef struct parsedPattern { + struct pcPattern *pcp; + pCodeToken *pct; +} parsedPattern; + +#define MAX_PARSEDPATARR 50 +parsedPattern parsedPatArr[MAX_PARSEDPATARR]; +unsigned int parsedPatIdx=0; + + +typedef enum { + PCP_LABEL, + PCP_STR, + PCP_WILDVAR, + PCP_WILDSTR, + PCP_COMMA +} pCodePatterns; + +static char pcpat_label[] = {PCT_PERCENT, PCT_NUMBER, PCT_COLON, 0}; +static char pcpat_string[] = {PCT_STRING, 0}; +static char pcpat_wildString[] = {PCT_PERCENT, PCT_STRING, 0}; +static char pcpat_wildVar[] = {PCT_PERCENT, PCT_NUMBER, 0}; +static char pcpat_comma[] = {PCT_COMMA, 0}; + + +typedef struct pcPattern { + int pt; // Pattern type + char *tokens; // list of tokens that describe the pattern + void * (*f) (void *); +} pcPattern; + +pcPattern pcpArr[] = { + {PCP_LABEL, pcpat_label, NULL}, + {PCP_WILDSTR, pcpat_wildString, NULL}, + {PCP_STR, pcpat_string, NULL}, + {PCP_WILDVAR, pcpat_wildVar, NULL}, + {PCP_COMMA, pcpat_comma, NULL} +}; + +#define PCPATTERNS (sizeof(pcpArr)/sizeof(pcPattern)) + +// Assembly Line Token +typedef enum { + ALT_LABEL, + ALT_MNEM0, + ALT_MNEM1, + ALT_MNEM2 +} altPatterns; + +static char alt_label[] = { PCP_LABEL, 0}; +static char alt_mnem0[] = { PCP_STR, 0}; +static char alt_mnem1[] = { PCP_STR, PCP_STR, 0}; +static char alt_mnem2[] = { PCP_STR, PCP_STR, PCP_COMMA, PCP_STR, 0}; + +static void * cvt_altpat_label(void *pp); + +pcPattern altArr[] = { + {ALT_LABEL, alt_label, cvt_altpat_label}, + {ALT_MNEM2, alt_mnem2, NULL}, + +}; +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static void * cvt_altpat_label(void *pp) +{ + fprintf(stderr,"altpat_label\n"); + return NULL; +} + +#if 0 +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static pCode * cvt_pcpat_wildMnem(parsedPattern *pp) +{ + fprintf(stderr,"pcpat_wildMnem\n"); + return NULL; +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static pCode * cvt_pcpat_Mnem(parsedPattern *pp) +{ + fprintf(stderr,"pcpat_Mnem\n"); + return NULL; +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static pCode * cvt_pcpat_wildVar(parsedPattern *pp) +{ + fprintf(stderr,"pcpat_wildVar\n"); + return NULL; +} +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ +static pCode * cvt_pcpat_var(parsedPattern *pp) +{ + fprintf(stderr,"pcpat_var\n"); + return NULL; +} +#endif + + + + + +/*-----------------------------------------------------------------*/ +/*-----------------------------------------------------------------*/ + + +static void parseLineNode(char *ln) +{ + + tokIdx = 0; + + if(!ln || !*ln) + return; + + while(*ln) { + + if(isspace(*ln)) { + tokArr[tokIdx++].tt = PCT_SPACE; + while (isspace (*ln)) + ln++; + continue; + } + + if(isdigit(*ln)) { + + tokArr[tokIdx].tt = PCT_NUMBER; + tokArr[tokIdx++].tok.n = strtol(ln, &ln, 10); + + continue; + + } + + switch(*ln) { + case '%': + tokArr[tokIdx++].tt = PCT_PERCENT; + break; + case ':': + tokArr[tokIdx++].tt = PCT_COLON; + break; + case ';': + tokArr[tokIdx].tok.s = Safe_strdup(ln); + tokArr[tokIdx++].tt = PCT_COMMENT; + return; + case ',': + tokArr[tokIdx++].tt = PCT_COMMA; + break; + + + default: + if(isalpha(*ln)) { + char buffer[50]; + int i=0; + + while( (isalpha(*ln) || isdigit(*ln)) && i<49) + buffer[i++] = *ln++; + + ln--; + buffer[i] = 0; + + tokArr[tokIdx].tok.s = Safe_strdup(buffer); + //fprintf(stderr," string %s",tokArr[tokIdx].tok.s); + + tokArr[tokIdx++].tt = PCT_STRING; + + } + } + ln++; + } +} + + + + +void dump1Token(pCodeTokens tt) +{ + + switch(tt) { + case PCT_SPACE: + fprintf(stderr, " space "); + break; + case PCT_PERCENT: + fprintf(stderr, " pct "); + fputc('%', stderr); + break; + case PCT_COLON: + fprintf(stderr, " col "); + fputc(':',stderr); + break; + case PCT_COMMA: + fprintf(stderr, " com "); + fputc(',',stderr); + break; + case PCT_COMMENT: + case PCT_STRING: + fprintf(stderr, " str "); + //fprintf(stderr,"%s",tokArr[i].tok.s); + break; + case PCT_NUMBER: + fprintf(stderr, " num "); + //fprintf(stderr,"%d",tokArr[i].tok.n); + + + } +} + + +int pcComparePattern(pCodeToken *pct, char *pat, int max_tokens) +{ + int i=0; + + if(!pct || !pat || !*pat) + return 0; + + //fprintf(stderr,"comparing against:\n"); + + while(i < max_tokens) { + + if(*pat == 0){ + //fprintf(stderr,"matched\n"); + return (i+1); + } + + //dump1Token(*pat); fprintf(stderr,"\n"); + + if(pct->tt != *pat) + return 0; + + + pct++; + pat++; + } + + return 0; + +} + +int advTokIdx(int *v, int amt) +{ + + if(*v + amt > tokIdx) + return 1; + + *v += amt; + return 0; + +} + +void dumpTokens(void) +{ + int i; + + if(!tokIdx) + return; + + for(i=0; i<=tokIdx; i++) + dump1Token(tokArr[i].tt); + + + fputc('\n',stderr); + + { + int lparsedPatIdx=0; + int lpcpIdx; + int ltokIdx =0; + int matching = 0; + int j; + + pCodeOp *pcl = NULL; // Storage for a label + pCodeOp *pco1 = NULL; // 1st operand + pCodeOp *pco2 = NULL; // 2nd operand + pCode *pc = NULL; // Mnemonic + + typedef enum { + PS_START, + PS_HAVE_LABEL, + PS_HAVE_MNEM, + PS_HAVE_1OPERAND, + PS_HAVE_COMMA, + PS_HAVE_2OPERANDS + } ParseStates; + + ParseStates state = PS_START; + + do { + + lpcpIdx=0; + matching = 0; + //fprintf(stderr,"ltokIdx = %d\n",ltokIdx); + + if( ((tokArr[ltokIdx].tt == PCT_SPACE) )//|| (tokArr[ltokIdx].tt == PCT_COMMA)) + && (advTokIdx(<okIdx, 1)) ) // eat space + break; + + do { + j = pcComparePattern(&tokArr[ltokIdx], pcpArr[lpcpIdx].tokens, tokIdx +1); + if( j ) { + //fprintf(stderr,"found token pattern match\n"); + switch(pcpArr[lpcpIdx].pt) { + case PCP_LABEL: + if(state == PS_START){ + fprintf(stderr," label\n"); + state = PS_HAVE_LABEL; + } else + fprintf(stderr," bad state (%d) for label\n",state); + break; + + case PCP_STR: + switch(state) { + case PS_START: + case PS_HAVE_LABEL: + fprintf(stderr," mnem\n"); + state = PS_HAVE_MNEM; + break; + case PS_HAVE_MNEM: + fprintf(stderr," 1st operand\n"); + pco1 = newpCodeOp(NULL,PO_GPR_REGISTER); + state = PS_HAVE_1OPERAND; + break; + case PS_HAVE_1OPERAND: + fprintf(stderr," error expecting comma\n"); + break; + case PS_HAVE_COMMA: + fprintf(stderr," 2 operands\n"); + break; + } + break; + + case PCP_WILDVAR: + switch(state) { + case PS_START: + case PS_HAVE_LABEL: + fprintf(stderr," wild mnem\n"); + state = PS_HAVE_MNEM; + break; + case PS_HAVE_MNEM: + fprintf(stderr," 1st operand is wild\n"); + state = PS_HAVE_1OPERAND; + break; + case PS_HAVE_1OPERAND: + fprintf(stderr," error expecting comma\n"); + break; + case PS_HAVE_COMMA: + fprintf(stderr," 2nd operand is wild\n"); + break; + } + break; + + case PCP_WILDSTR: + break; + case PCP_COMMA: + if(state == PS_HAVE_1OPERAND){ + fprintf(stderr," got a comma\n"); + state = PS_HAVE_COMMA; + } else + fprintf(stderr," unexpected comma\n"); + } + + matching = 1; + parsedPatArr[lparsedPatIdx].pcp = &pcpArr[lpcpIdx]; + parsedPatArr[lparsedPatIdx].pct = &tokArr[ltokIdx]; + lparsedPatIdx++; + + //dump1Token(tokArr[ltokIdx].tt); + + if(advTokIdx(<okIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) { + fprintf(stderr," reached end \n"); + matching = 0; + //return; + } + } + + + } while ((++lpcpIdx < PCPATTERNS) && !matching); + + } while (matching); + + fprintf(stderr,"\nConverting parsed line to pCode:\n\n"); + + j = 0; + do { + if(parsedPatArr[j].pcp && parsedPatArr[j].pcp->f ) + parsedPatArr[j].pcp->f(&parsedPatArr[j]); + j++; + } + while(jnext) { + fprintf(stderr,"\nRule:\n\n"); + for(ln = pr->match; ln; ln = ln->next) { + fprintf(stderr,"%s\n",ln->line); + //parseLineNode(ln->line); + parseLineNode(ln->line); + dumpTokens(); + + } + + fprintf(stderr,"\nReplaced by:\n"); + for(ln = pr->replace; ln; ln = ln->next) + fprintf(stderr,"%s\n",ln->line); + + if(pr->cond) + fprintf(stderr,"\nCondition: %s\n",pr->cond); + + } + +} void printpCodeString(FILE *of, pCode *pc, int max) { @@ -233,11 +744,33 @@ void pCodePeepInit(void) peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps); { + /* + target: + + btfsc %0 + goto %1 + %3 + %1: %4 + + replace: + btfss %0 + %1: %4 + %3 + + The %3 and %4 are wild opcodes. Since the opcodes + are stored in a different array than the wild operands, + they can have the same indices and not conflict. So + below, the %3 is really a %0, %4 is a %1. + + */ pCodeOp *pcl; pCodeOp *pcw; pCodeOp *pcwb; + // Create a new wild operand subtyped as a bit pcwb = newpCodeOpWild(0,pcp,newpCodeOpBit(NULL,-1)); + + // Create a pb = newpCodeChain(NULL, 'W',newpCode(POC_BTFSC,pcwb)); pcl = newpCodeOpLabel(-1); @@ -665,7 +1198,7 @@ int pCodePeepMatchRule(pCode *pc) if(pcr->type == PC_OPCODE) { if(PCI(pcr)->pcop) pcop = pCodeOpCopy(PCI(pcr)->pcop); - + fprintf(stderr,"inserting pCode\n"); pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop)); } else if (pcr->type == PC_WILD) { pCodeInsertAfter(pc,peepBlock->wildpCodes[PCW(pcr)->id]); @@ -685,3 +1218,84 @@ int pCodePeepMatchRule(pCode *pc) return 0; } + + + + + + + + + + +#if 0 +/*******************/ +pCode *parseLineNode(char *ln) +{ + char buffer[50], *s; + int state=0; //0 label, 1 mnemonic, 2 operand, 3 operand, 4 comment + int var; + pCode *pc = NULL; + // pCodeLabel *pcl = NULL; + + if(!ln || !*ln) + return pc; + + s = buffer; + *s = 0; + + while(*ln) { + + /* skip white space */ + while (isspace (*ln)) + ln++; + + switch(state) { + + case 0: // look for a label + case 1: // look for mnemonic + + if(*ln == '%') { + + // Wild + + ln++; + if(!isdigit(*ln) ) + break; + //goto next_state; + + var = strtol(ln, &ln, 10); + if(*ln == ':') { + // valid wild card label + fprintf(stderr, " wildcard label: %d\n",var); + ln++; + } else + fprintf(stderr, " wild opcode: %d\n",var), state++; + + } else { + // not wild + // Extract the label/mnemonic from the line + + s = buffer; + while(*ln && !(isspace(*ln) || *ln == ':')) + *s++ = *ln++; + + *s = 0; + if(*ln == ':') + fprintf(stderr," regular label: %s\n",buffer), ln++; + else + fprintf(stderr," regular mnem: %s\n",buffer), state++; + } + state++; + break; + + default: + ln++; + + } + } + + return pc; + +} +#endif diff --git a/src/pic/peeph.def b/src/pic/peeph.def index d1a05166..37e15053 100644 --- a/src/pic/peeph.def +++ b/src/pic/peeph.def @@ -1,3 +1,15 @@ +//bogus test for pcode +replace restart { + movf %1,w ;comment at end +%4: movf %1,w + %2 %3,w +} by { + ; peep test remove redundant move +%4: movf %1,w ;another comment + %2 %3,w +} if AYBABTU %3 + + // peep 1 replace restart { movf %1,w diff --git a/src/regression/compare3.c b/src/regression/compare3.c new file mode 100644 index 00000000..ce91b6b9 --- /dev/null +++ b/src/regression/compare3.c @@ -0,0 +1,219 @@ +// +// compare3.c +// regression testing program for comparing literals to variables +// + + +unsigned char success = 0; +unsigned char failures = 0; +unsigned char dummy = 0; + +bit bit0 = 0; +unsigned int aint0 = 0; +unsigned int aint1 = 0; +unsigned char achar0 = 0; +unsigned char achar1 = 0; + +void +done () +{ + + dummy++; + +} + +// compare to 0 +// assumes +// achar0 == 0 +// achar1 != 0 +// aint0 == 0 +// aint1 != 0 + +void c_0(void) +{ + + if(achar0 != 0) + failures++; + + if(achar0) + failures++; + + if(achar1 == 0) + failures++; + + if(!achar1) + failures++; + + if(aint0 != 0) + failures++; + + if(aint0) + failures++; + + if(aint1 == 0) + failures++; + + if(!aint1) + failures++; + +} + +// compare to 1 +// assumes +// achar0 != 1 +// achar1 == 1 +// aint0 != 1 +// aint1 == 1 + +void c_1(void) +{ + + if(achar0 == 1) + failures++; + + if(achar1 != 1) + failures++; + + if(aint0 == 1) + failures++; + + if(aint1 != 1) + failures++; + +} + +// compare to 2 +// assumes +// achar0 == 2 +// aint0 == 2 + +void c_2(void) +{ + + if(achar0 != 2) + failures++; + + if(aint0 != 2) + failures++; + +} + +// compare to 0xff +// assumes +// achar0 == 0xff +// aint0 == 0xff + +void c_ff(void) +{ + + if(achar0 != 0xff) + failures++; + + if(aint0 != 0xff) + failures++; + + if(aint0 == 0xfe) + failures++; + + if(aint0 == 0xff00) + failures++; + +} + + +// compare to 0x00a5 +// assumes +// achar0 == 0xa5 +// aint0 == 0x00a5 + +void c_a5(void) +{ + + if(achar0 != 0xa5) + failures++; + + if(aint0 != 0xa5) + failures++; + + if(aint0 == 0xa4) + failures++; + + if(aint0 == 0xa500) + failures++; + +} + +// compare to 0xa500 +// assumes +// achar0 == 0xa5 +// aint0 == 0xa500 + +void c_a500(void) +{ + + if(achar0 == 0xa500) + failures++; + + if(aint0 != 0xa500) + failures++; + + if(aint0 == 0xa400) + failures++; + + if(aint0 == 0x00a5) + failures++; + +} + +// compare to 0xabcd +// assumes +// achar0 == 0xa5 +// aint0 == 0xabcd + +void c_abcd(void) +{ + + if(achar0 == 0xabcd) + failures++; + + if(aint0 != 0xabcd) + failures++; + + if(aint0 == 0xab00) + failures++; + + if(aint0 == 0x00cd) + failures++; + + if(aint0 == 0x1234abcd) + failures++; + +} + +void +main (void) +{ + + aint1 = 1; + achar1 = 1; + c_0(); + c_1(); + + aint0 = 2; + achar0 = 2; + c_2(); + + aint0 = 0xff; + achar0 = 0xff; + c_ff(); + + aint0 = 0xa5; + achar0 = 0xa5; + c_a5(); + + aint0 = 0xabcd; + c_abcd(); + + success = failures; + done (); +} diff --git a/src/regression/struct1.c b/src/regression/struct1.c index e8a5b031..32baf808 100644 --- a/src/regression/struct1.c +++ b/src/regression/struct1.c @@ -65,7 +65,7 @@ struct_test (void) if (struct1.c0 != 1) failures++; } - +/* void ptr_to_struct (struct chars *p) { @@ -79,7 +79,7 @@ ptr_to_struct (struct chars *p) if (p->c1 != 1) failures++; } - +*/ void add_chars(void) { @@ -97,7 +97,7 @@ main (void) struct1.c0 = 0; struct1.c1 = 0; struct_test (); - ptr_to_struct (&struct1); + // ptr_to_struct (&struct1); struct1.c0 = 0; struct1.c1 = 1;