pCodeOp *newpCodeOpWild(int id, pCodePeep *pcp, pCodeOp *subtype);
pCode *newpCodeWild(int pCodeID, pCodeOp *optional_operand, pCodeOp *optional_label);
pCode * findNextInstruction(pCode *pc);
-char *Safe_strdup(char *str);
int getpCode(char *mnem,int dest);
void pBlockMergeLabels(pBlock *pb);
char *pCode2str(char *str, int size, pCode *pc);
{
parsedPattern *p = pp;
- fprintf(stderr,"altpat_label with ID = %d\n",p->pct[1].tok.n);
+ DFPRINTF((stderr,"altpat_label with ID = %d\n",p->pct[1].tok.n));
return newpCodeLabel(-p->pct[1].tok.n);
}
{
parsedPattern *p = pp;
- fprintf(stderr,"altpat_comment = %s\n",p->pct[0].tok.s);
+ DFPRINTF((stderr,"altpat_comment = %s\n",p->pct[0].tok.s));
return newpCodeCharP(p->pct[0].tok.s);
}
pCodeInstruction *pci=NULL;
- fprintf(stderr,"altpat_mnem0 %s\n", p->pct[0].tok.s);
+ DFPRINTF((stderr,"altpat_mnem0 %s\n", p->pct[0].tok.s));
opcode = getpCode(p->pct[0].tok.s,0);
if(opcode < 0) {
{
parsedPattern *p = pp;
- fprintf(stderr,"altpat_mnem0a wild mnem # %d\n", p[0].pct[1].tok.n);
+ DFPRINTF((stderr,"altpat_mnem0a wild mnem # %d\n", p[0].pct[1].tok.n));
/* Save the index of the maximum wildcard mnemonic */
pCodeInstruction *pci=NULL;
pCodeOp *pcosubtype;
- fprintf(stderr,"altpat_mnem1 %s var %s\n", p->pct[0].tok.s,p[1].pct[0].tok.s);
+ DFPRINTF((stderr,"altpat_mnem1 %s var %s\n", p->pct[0].tok.s,p[1].pct[0].tok.s));
opcode = getpCode(p->pct[0].tok.s,0);
if(opcode < 0) {
pCodeInstruction *pci=NULL;
pCodeOp *pcosubtype;
- fprintf(stderr,"altpat_mnem1a %s var %d\n", p->pct[0].tok.s,p[1].pct[1].tok.n);
+ DFPRINTF((stderr,"altpat_mnem1a %s var %d\n", p->pct[0].tok.s,p[1].pct[1].tok.n));
opcode = getpCode(p->pct[0].tok.s,0);
if(opcode < 0) {
pCodeInstruction *pci=NULL;
- fprintf(stderr,"altpat_mnem1b %s var %d\n", p->pct[0].tok.s,p[1].pct[0].tok.n);
+ DFPRINTF((stderr,"altpat_mnem1b %s var %d\n", p->pct[0].tok.s,p[1].pct[0].tok.n));
opcode = getpCode(p->pct[0].tok.s,0);
if(opcode < 0) {
dest = cvt_extract_destination(&p[3]);
- fprintf(stderr,"altpat_mnem2 %s var %s destination %s(%d)\n",
+ DFPRINTF((stderr,"altpat_mnem2 %s var %s destination %s(%d)\n",
p->pct[0].tok.s,
p[1].pct[0].tok.s,
p[3].pct[0].tok.s,
- dest);
+ dest));
opcode = getpCode(p->pct[0].tok.s,dest);
dest = cvt_extract_destination(&p[3]);
- fprintf(stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
+ DFPRINTF((stderr,"altpat_mnem2a %s var %d destination %s(%d)\n",
p->pct[0].tok.s,
p[1].pct[1].tok.n,
p[3].pct[0].tok.s,
- dest);
+ dest));
opcode = getpCode(p->pct[0].tok.s,dest);
void dump1Token(pCodeTokens tt)
{
-
+#ifdef PCODE_DEBUG
switch(tt) {
case PCT_SPACE:
fprintf(stderr, " space ");
fprintf(stderr, " null ");
}
+#endif
}
if(!pct || !pat || !*pat)
return 0;
- //fprintf(stderr,"comparing against:\n");
+ //DFPRINTF((stderr,"comparing against:\n"));
while(i < max_tokens) {
if(*pat == 0){
- //fprintf(stderr,"matched\n");
+ //DFPRINTF((stderr,"matched\n"));
return (i+1);
}
- //dump1Token(*pat); fprintf(stderr,"\n");
+ //dump1Token(*pat); DFPRINTF((stderr,"\n"));
if(pct->tt != *pat)
return 0;
while(i < max_tokens) {
if(*pct == 0) {
- //fprintf(stderr,"matched\n");
+ //DFPRINTF((stderr,"matched\n"));
return i;
}
- //dump1Token(*pat); fprintf(stderr,"\n");
+ //dump1Token(*pat); DFPRINTF((stderr,"\n"));
if( !pat || !pat->pcp )
return 0;
if (pat->pcp->pt != *pct)
return 0;
- //fprintf(stderr," pct=%d\n",*pct);
+ //DFPRINTF((stderr," pct=%d\n",*pct));
pct++;
pat++;
i++;
for(i=0; i<=tokIdx; i++)
dump1Token(tokArr[i].tt);
-
+#ifdef PCODE_DEBUG
fputc('\n',stderr);
-
+#endif
{
int lparsedPatIdx=0;
int lpcpIdx;
switch(pcpArr[lpcpIdx].pt) {
case PCP_LABEL:
if(state == PS_START){
- fprintf(stderr," label\n");
+ DFPRINTF((stderr," label\n"));
state = PS_HAVE_LABEL;
} else
- fprintf(stderr," bad state (%d) for label\n",state);
+ DFPRINTF((stderr," bad state (%d) for label\n",state));
break;
case PCP_STR:
- fprintf(stderr," %s is",tokArr[ltokIdx].tok.s);
+ DFPRINTF((stderr," %s is",tokArr[ltokIdx].tok.s));
switch(state) {
case PS_START:
case PS_HAVE_LABEL:
- fprintf(stderr," mnem\n");
+ DFPRINTF((stderr," mnem\n"));
cPmnem = tokArr[ltokIdx].tok.s;
state = PS_HAVE_MNEM;
break;
case PS_HAVE_MNEM:
- fprintf(stderr," 1st operand\n");
+ DFPRINTF((stderr," 1st operand\n"));
cP1stop = tokArr[ltokIdx].tok.s;
//pco1 = newpCodeOp(NULL,PO_GPR_REGISTER);
state = PS_HAVE_1OPERAND;
break;
case PS_HAVE_1OPERAND:
- fprintf(stderr," error expecting comma\n");
+ DFPRINTF((stderr," error expecting comma\n"));
break;
case PS_HAVE_COMMA:
- fprintf(stderr," 2 operands\n");
+ DFPRINTF((stderr," 2 operands\n"));
cP2ndop = tokArr[ltokIdx].tok.s;
break;
case PS_HAVE_2OPERANDS:
switch(state) {
case PS_START:
case PS_HAVE_LABEL:
- fprintf(stderr," wild mnem\n");
+ DFPRINTF((stderr," wild mnem\n"));
state = PS_HAVE_MNEM;
break;
case PS_HAVE_MNEM:
- fprintf(stderr," 1st operand is wild\n");
+ DFPRINTF((stderr," 1st operand is wild\n"));
state = PS_HAVE_1OPERAND;
break;
case PS_HAVE_1OPERAND:
- fprintf(stderr," error expecting comma\n");
+ DFPRINTF((stderr," error expecting comma\n"));
break;
case PS_HAVE_COMMA:
- fprintf(stderr," 2nd operand is wild\n");
+ DFPRINTF((stderr," 2nd operand is wild\n"));
break;
case PS_HAVE_2OPERANDS:
break;
fprintf(stderr," ERROR number\n");
break;
case PS_HAVE_MNEM:
- fprintf(stderr," 1st operand is a number\n");
+ DFPRINTF((stderr," 1st operand is a number\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 a number\n");
+ DFPRINTF((stderr," 2nd operand is a number\n"));
break;
case PS_HAVE_2OPERANDS:
break;
break;
case PCP_COMMA:
if(state == PS_HAVE_1OPERAND){
- fprintf(stderr," got a comma\n");
+ DFPRINTF((stderr," got a comma\n"));
state = PS_HAVE_COMMA;
} else
fprintf(stderr," unexpected comma\n");
//dump1Token(tokArr[ltokIdx].tt);
if(advTokIdx(<okIdx, strlen(pcpArr[lpcpIdx].tokens) ) ) {
- fprintf(stderr," reached end \n");
+ DFPRINTF((stderr," reached end \n"));
matching = 0;
//return;
}
if( altArr[k].f) {
pc = altArr[k].f(&parsedPatArr[j]);
- if(pc && pc->print)
- pc->print(stderr,pc);
+ //if(pc && pc->print)
+ // pc->print(stderr,pc);
//if(pc && pc->destruct) pc->destruct(pc); dumps core?
if(curBlock && pc)
addpCode2pBlock(curBlock, pc);
while(j<=lparsedPatIdx && k<ALTPATTERNS);
/*
- fprintf(stderr,"\nConverting parsed line to pCode:\n\n");
+ DFPRINTF((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]);
- fprintf(stderr," %d",parsedPatArr[j].pcp->pt);
+ DFPRINTF((stderr," %d",parsedPatArr[j].pcp->pt));
j++;
}
while(j<lparsedPatIdx);
*/
- fprintf(stderr,"\n");
+ DFPRINTF((stderr,"\n"));
}
for( ; ln; ln = ln->next) {
- fprintf(stderr,"%s\n",ln->line);
+ //DFPRINTF((stderr,"%s\n",ln->line));
tokenizeLineNode(ln->line);
parseTokens();
if(!cond)
return;
- fprintf(stderr,"\nCondition: %s\n",cond);
+ //DFPRINTF((stderr,"\nCondition: %s\n",cond));
/* brute force compares for now */
if(STRCASECMP(cond, "NZ") == 0) {
- fprintf(stderr,"found NZ\n");
+ //DFPRINTF((stderr,"found NZ\n"));
curPeep->postFalseCond = PCC_Z;
}
for (pr = rules; pr; pr = pr->next) {
- fprintf(stderr,"\nRule:\n\n");
+ //DFPRINTF((stderr,"\nRule:\n\n"));
pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
curPeep = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
/* Convert the target block */
peepRuleBlock2pCodeBlock(pr->match);
- fprintf(stderr,"finished target, here it is in pcode form:\n");
- printpBlock(stderr, curBlock);
+ //DFPRINTF((stderr,"finished target, here it is in pcode form:\n"));
+ //printpBlock(stderr, curBlock);
- fprintf(stderr,"target with labels merged:\n");
+ //DFPRINTF((stderr,"target with labels merged:\n"));
pBlockMergeLabels(curBlock);
+#ifdef PCODE_DEBUG
printpBlock(stderr, curBlock);
+#endif
- fprintf(stderr,"\nReplaced by:\n");
+ //DFPRINTF((stderr,"\nReplaced by:\n"));
curPeep->replace = curBlock = newpCodeChain(NULL, 'W', NULL);
/* Convert the replace block */
peepRuleBlock2pCodeBlock(pr->replace);
- fprintf(stderr,"finished replace block, here it is in pcode form:\n");
- printpBlock(stderr, curBlock);
+ //DFPRINTF((stderr,"finished replace block, here it is in pcode form:\n"));
+ //printpBlock(stderr, curBlock);
- fprintf(stderr,"replace with labels merged:\n");
+ //DFPRINTF((stderr,"replace with labels merged:\n"));
pBlockMergeLabels(curBlock);
- printpBlock(stderr, curBlock);
+ //printpBlock(stderr, curBlock);
peepRuleCondition(pr->cond);
-----------------------------------------------------------------*/
-#if 0
-/*-----------------------------------------------------------------*/
-/* pCodePeep */
-/*-----------------------------------------------------------------*/
-int pCodePeepCompare(pCode *pc, pCodePeep *pcp)
-{
- pCode *pcfrom,*pcto;
-
- pcfrom = pc;
- for( pcto=pcp->target; pcto; pcto=pcto->next) {
- pcfrom = findNextInstruction(pcfrom);
-
- if( pcfrom &&
- (PCI(pcfrom)->op == PCI(pcto)->op ||
- PCI(pcto)->op == POC_WILD))
- continue;
- return 0;
- }
- return 0;
-}
-
-/*-----------------------------------------------------------------*/
-/* pCodePeep */
-/*-----------------------------------------------------------------*/
-void pCodePeepSearch(pCodePeep *snippet)
-{
- pBlock *pb;
- pCode *pc;
-
- if(!the_pFile)
- return;
-
- /* compare the chain to the pCode that we've
- got so far. If a match is found, then replace
- the pCode chain.
- */
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- for(pc = pb->pcHead; pc; pc = pc->next) {
- pCodePeepCompare(pc,snippet);
- }
- }
-
-}
-#endif
-
-#if 0
-pBlock *pBlockAppend(pBlock *pb1, pBlock *pb2)
-{
- pBlock *pb;
-
- if(!pb1->tail)
- return pb2;
-
- pb = pb1->tail;
-
- pb2->head = pb1;
- pb2->tail = NULL;
- pb1->tail = pb2;
-
-}
-
-#endif
-
-void pCodePeepInit(void)
-{
-#if 0
- pBlock *pb;
- // pCode *pc;
- pCodePeep *pcp;
- pCodePeepSnippets *pcps;
-
- /* Declare a peep code snippet */
- /* <FIXME> do I really need a separate struct just to DLL the snippets? */
- /* e.g. I could put the DLL into the pCodePeep structure */
-
- /*
-
- target:
-
- movwf %1
- movf %1,w
-
- replace:
-
- movwf %1
-
- Condition:
- false condition - PCC_Z (Z bit is not used as input to subsequent code)
- true condition - none
- */
- pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
- pcp = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
- peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
-
-
- pb = newpCodeChain(NULL, 'W', newpCode(POC_MOVWF, newpCodeOpWild(0,pcp,newpCodeOp(NULL,PO_GPR_REGISTER))) );
- addpCode2pBlock( pb, newpCode(POC_MOVFW, newpCodeOpWild(0,pcp,newpCodeOp(NULL,PO_GPR_REGISTER))) );
-
- pcp->target = pb;
-
- pcp->replace = newpCodeChain(NULL, 'W',newpCode(POC_MOVWF, newpCodeOpWild(0,pcp,newpCodeOp(NULL,PO_GPR_REGISTER))) );
-
- /* Allocate space to store pointers to the wildcard variables */
- pcp->nvars = 1;
- pcp->vars = Safe_calloc(pcp->nvars, sizeof(char *));
- pcp->nwildpCodes = 0;
- pcp->wildpCodes = NULL;
-
- pcp->postFalseCond = PCC_Z;
- pcp->postTrueCond = PCC_NONE;
-
- fprintf(stderr,"Peep rule\nTarget:\n");
- printpCodeString(stderr,pcp->target->pcHead, 10);
- fprintf(stderr,"Replaced with:\n");
- printpCodeString(stderr,pcp->replace->pcHead, 10);
-
- /* Now for another peep example */
- pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
- pcp = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
- peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
-
- {
- /*
- target:
-
- btfsc %0
- goto %1
- %3
- %1: %4
-
- replace:
- btfss %0
- %3
- %1: %4
-
- 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,0));
-
- // Create a
- pb = newpCodeChain(NULL, 'W',newpCode(POC_BTFSC,pcwb));
-
- pcl = newpCodeOpLabel(-1);
- pcw = newpCodeOpWild(1, pcp, pcl);
- addpCode2pBlock( pb, newpCode(POC_GOTO, pcw));
- addpCode2pBlock( pb, newpCodeWild(0,NULL,NULL));
- addpCode2pBlock( pb, newpCodeWild(1,NULL,pcw));
-
-
- pcp->target = pb;
-
- pb = newpCodeChain(NULL, 'W',newpCode(POC_BTFSS, pcwb));
- addpCode2pBlock( pb, newpCodeWild(0,NULL,NULL));
- addpCode2pBlock( pb, newpCodeWild(1,NULL,pcw));
-
- pcp->replace = pb;
-
- /* Allocate space to store pointers to the wildcard variables */
- pcp->nvars = 2;
- pcp->vars = Safe_calloc(pcp->nvars, sizeof(char *));
- pcp->nwildpCodes = 2;
- pcp->wildpCodes = Safe_calloc(pcp->nwildpCodes, sizeof(pCode *));
-
- pcp->postFalseCond = PCC_NONE;
- pcp->postTrueCond = PCC_NONE;
- }
-
-
-
-
-
-
-
-
-
-
- //-------------
-
- /* Now for another peep example */
- pcps = Safe_calloc(1,sizeof(pCodePeepSnippets));
- pcp = pcps->peep = Safe_calloc(1,sizeof(pCodePeep));
- peepSnippets = DLL_append((_DLL*)peepSnippets,(_DLL*)pcps);
-
- {
- pCodeOp *pcw;
-
- pcw = newpCodeOpWild(0,pcp,newpCodeOp(NULL,PO_GPR_REGISTER));
-
- pb = newpCodeChain(NULL, 'W', newpCode(POC_MOVWF, pcw));
- addpCode2pBlock( pb, newpCode(POC_MOVWF, pcw));
-
- pcp->target = pb;
-
- pb = newpCodeChain(NULL, 'W',newpCode(POC_MOVWF, pcw));
-
- pcp->replace = pb;
-
- /* Allocate space to store pointers to the wildcard variables */
- pcp->nvars = 1;
- pcp->vars = Safe_calloc(pcp->nvars, sizeof(char *));
- pcp->nwildpCodes = 0;
- pcp->wildpCodes = NULL;
-
- pcp->postFalseCond = PCC_NONE;
- pcp->postTrueCond = PCC_NONE;
- }
-
-
-
-#endif
-}
/*-----------------------------------------------------------------*/
/* pCodeSearchCondition - Search a pCode chain for a 'condition' */
return 0;
pcl = pcd->label->pc;
- //labindex = PCOW(pcl)->id;
+
labindex = -PCL(pcl)->key;
- fprintf(stderr,"label id = %d (labindex = %d)\n",PCL(pcl)->key,labindex);
+ //DFPRINTF((stderr,"label id = %d (labindex = %d)\n",PCL(pcl)->key,labindex));
if(peepBlock->vars[labindex] == NULL) {
// First time to encounter this label
peepBlock->vars[labindex] = PCL(pcs->label->pc)->label;
- fprintf(stderr,"first time for a label: %d %s\n",labindex, peepBlock->vars[labindex]);
+ //DFPRINTF((stderr,"first time for a label: %d %s\n",labindex, peepBlock->vars[labindex]));
} else {
if(strcmp(peepBlock->vars[labindex],PCL(pcs->label->pc)->label) != 0) {
- fprintf(stderr,"labels don't match\n");
+ // DFPRINTF((stderr,"labels don't match\n"));
return 0;
}
- fprintf(stderr,"matched a label\n");
+ //DFPRINTF((stderr,"matched a label\n"));
}
} else {
- fprintf(stderr,"destination doesn't have a label\n");
+ // DFPRINTF((stderr,"destination doesn't have a label\n"));
if(pcs->label)
return 0;
if(PCI(pcs)->op != PCI(pcd)->op)
return 0;
- fprintf(stderr,"%s comparing\n",__FUNCTION__);
+ /*
+ DFPRINTF((stderr,"%s comparing\n",__FUNCTION__));
pcs->print(stderr,pcs);
pcd->print(stderr,pcd);
+ */
if(!pCodePeepMatchLabels(peepBlock, pcs, pcd))
return 0;
if (PCI(pcd)->pcop->type == PO_WILD) {
index = PCOW(PCI(pcd)->pcop)->id;
- fprintf(stderr,"destination is wild\n");
+ //DFPRINTF((stderr,"destination is wild\n"));
#ifdef DEBUG_PCODEPEEP
if (index > peepBlock->nops) {
- fprintf(stderr,"%s - variables exceeded\n",__FUNCTION__);
+ DFPRINTF((stderr,"%s - variables exceeded\n",__FUNCTION__));
exit(1);
}
#endif
{
char *n;
- if(PCI(pcs)->pcop->type == PO_GPR_TEMP)
+ switch(PCI(pcs)->pcop->type) {
+ case PO_GPR_TEMP:
+ case PO_FSR:
+ //case PO_INDF:
n = PCOR(PCI(pcs)->pcop)->r->name;
- else
+
+ break;
+ default:
n = PCI(pcs)->pcop->name;
+ }
if(peepBlock->vars[index])
return (strcmp(peepBlock->vars[index],n) == 0);
else {
- fprintf(stderr,"first time for a variable: %d, %s\n",index,n);
- peepBlock->vars[index] = n; //PCI(pcs)->pcop->name;
+ // DFPRINTF((stderr,"first time for a variable: %d, %s\n",index,n));
+ peepBlock->vars[index] = n;
return 1;
}
}
index = PCW(pcd)->id;
- fprintf(stderr,"%s comparing wild cards\n",__FUNCTION__);
- pcs->print(stderr,pcs);
- pcd->print(stderr,pcd);
+ // DFPRINTF((stderr,"%s comparing wild cards\n",__FUNCTION__));
+ //pcs->print(stderr,pcs);
+ //pcd->print(stderr,pcd);
peepBlock->wildpCodes[PCW(pcd)->id] = pcs;
PCOW(PCI(pcd)->pcop)->matched = PCI(pcs)->pcop;
if(peepBlock->vars[index]) {
int i = (strcmp(peepBlock->vars[index],PCI(pcs)->pcop->name) == 0);
+ /*
if(i)
- fprintf(stderr," (matched)\n");
+ DFPRINTF((stderr," (matched)\n"));
else {
- fprintf(stderr," (no match: wild card operand mismatch\n");
- fprintf(stderr," peepblock= %s, pcodeop= %s\n",
+ DFPRINTF((stderr," (no match: wild card operand mismatch\n"));
+ DFPRINTF((stderr," peepblock= %s, pcodeop= %s\n"),
peepBlock->vars[index],
PCI(pcs)->pcop->name);
}
+ */
return i;
} else {
peepBlock->vars[index] = PCI(pcs)->pcop->name;
pcs = findNextInstruction(pcs->next);
if(pcs) {
- fprintf(stderr," (next to match)\n");
- pcs->print(stderr,pcs);
+ //DFPRINTF((stderr," (next to match)\n"));
+ //pcs->print(stderr,pcs);
} else if(pcd->next) {
/* oops, we ran out of code, but there's more to the rule */
return 0;
switch(pcop->type) {
case PO_CRY:
case PO_BIT:
- fprintf(stderr,"pCodeOpCopy bit\n");
+ //DFPRINTF((stderr,"pCodeOpCopy bit\n"));
pcopnew = Safe_calloc(1,sizeof(pCodeOpBit) );
PCOB(pcopnew)->bit = PCOB(pcop)->bit;
PCOB(pcopnew)->inBitSpace = PCOB(pcop)->inBitSpace;
case PO_WILD:
/* Here we expand the wild card into the appropriate type: */
/* By recursively calling pCodeOpCopy */
- fprintf(stderr,"pCodeOpCopy wild\n");
+ //DFPRINTF((stderr,"pCodeOpCopy wild\n"));
if(PCOW(pcop)->matched)
pcopnew = pCodeOpCopy(PCOW(pcop)->matched);
else {
// Probably a label
pcopnew = pCodeOpCopy(PCOW(pcop)->subtype);
pcopnew->name = Safe_strdup(PCOW(pcop)->pcp->vars[PCOW(pcop)->id]);
- fprintf(stderr,"copied a wild op named %s\n",pcopnew->name);
+ //DFPRINTF((stderr,"copied a wild op named %s\n",pcopnew->name));
}
return pcopnew;
break;
case PO_LABEL:
- fprintf(stderr,"pCodeOpCopy label\n");
+ //DFPRINTF((stderr,"pCodeOpCopy label\n"));
pcopnew = Safe_calloc(1,sizeof(pCodeOpLabel) );
PCOLAB(pcopnew)->key = PCOLAB(pcop)->key;
break;
case PO_LITERAL:
case PO_IMMEDIATE:
- fprintf(stderr,"pCodeOpCopy lit\n");
+ //DFPRINTF((stderr,"pCodeOpCopy lit\n"));
pcopnew = Safe_calloc(1,sizeof(pCodeOpLit) );
PCOL(pcopnew)->lit = PCOL(pcop)->lit;
break;
case PO_GPR_REGISTER:
case PO_GPR_TEMP:
case PO_GPR_BIT:
- fprintf(stderr,"pCodeOpCopy GPR register\n");
+ case PO_FSR:
+ case PO_INDF:
+ //DFPRINTF((stderr,"pCodeOpCopy GPR register\n"));
pcopnew = Safe_calloc(1,sizeof(pCodeOpReg) );
PCOR(pcopnew)->r = PCOR(pcop)->r;
PCOR(pcopnew)->rIdx = PCOR(pcop)->rIdx;
- fprintf(stderr," register index %d\n", PCOR(pcop)->r->rIdx);
+ DFPRINTF((stderr," register index %d\n", PCOR(pcop)->r->rIdx));
break;
case PO_DIR:
- fprintf(stderr,"pCodeOpCopy PO_DIR\n");
+ //DFPRINTF((stderr,"pCodeOpCopy PO_DIR\n"));
case PO_SFR_REGISTER:
case PO_STR:
case PO_NONE:
case PO_W:
case PO_STATUS:
- case PO_FSR:
- case PO_INDF:
case PO_PCL:
case PO_PCLATH:
- fprintf(stderr,"pCodeOpCopy register type %d\n", pcop->type);
+ //DFPRINTF((stderr,"pCodeOpCopy register type %d\n", pcop->type));
pcopnew = Safe_calloc(1,sizeof(pCodeOp) );
}
pcopnew->type = pcop->type;
- pcopnew->name = Safe_strdup(pcop->name);
+ if(pcop->name)
+ pcopnew->name = Safe_strdup(pcop->name);
+ else
+ pcopnew->name = NULL;
return pcopnew;
}
while(f && f!=t) {
- fprintf(stderr,"delete pCode:\n");
+ DFPRINTF((stderr,"delete pCode:\n"));
pc = f->next;
f->print(stderr,f);
//f->delete(f); this dumps core...
pcin = findNextInstruction(pcin->next);
pct = pct->next;
//debug:
- fprintf(stderr," matched\n");
+ //DFPRINTF((stderr," matched\n"));
if(!pcin)
- fprintf(stderr," end of code\n");
+ DFPRINTF((stderr," end of code\n"));
if(!pct)
- fprintf(stderr," end of rule\n");
+ DFPRINTF((stderr," end of rule\n"));
}
if(matched) {
* following the point just past where we have matched depend on
* the `postFalseCond' as input then we abort the match
*/
- fprintf(stderr," matched rule so far, now checking conditions\n");
+ DFPRINTF((stderr," matched rule so far, now checking conditions\n"));
if (pcin && peepBlock->postFalseCond &&
(pCodeSearchCondition(pcin,peepBlock->postFalseCond) > 0) )
matched = 0;
/* We matched a rule! Now we have to go through and remove the
inefficient code with the optimized version */
-
- fprintf(stderr, "Found a pcode peep match:\nRule:\n");
+#ifdef PCODE_DEBUG
+ DFPRINTF((stderr, "Found a pcode peep match:\nRule:\n"));
printpCodeString(stderr,peepBlock->target->pcHead,10);
- fprintf(stderr,"first thing matched\n");
+ DFPRINTF((stderr,"first thing matched\n"));
pc->print(stderr,pc);
+#endif
if(pcin) {
- fprintf(stderr,"last thing matched\n");
+ DFPRINTF((stderr,"last thing matched\n"));
pcin->print(stderr,pcin);
}
* Is it wild? */
if(PCI(pcr)->pcop->type == PO_WILD) {
int index = PCOW(PCI(pcr)->pcop)->id;
- fprintf(stderr,"copying wildopcode\n");
+ //DFPRINTF((stderr,"copying wildopcode\n"));
if(peepBlock->wildpCodeOps[index])
pcop = pCodeOpCopy(peepBlock->wildpCodeOps[index]);
else
- fprintf(stderr,"error, wildopcode in replace but not source?\n");
+ DFPRINTF((stderr,"error, wildopcode in replace but not source?\n"));
} else
pcop = pCodeOpCopy(PCI(pcr)->pcop);
}
- fprintf(stderr,"inserting pCode\n");
+ //DFPRINTF((stderr,"inserting pCode\n"));
pCodeInsertAfter(pc, newpCode(PCI(pcr)->op,pcop));
} else if (pcr->type == PC_WILD) {
pCodeInsertAfter(pc,peepBlock->wildpCodes[PCW(pcr)->id]);
pc = pc->next;
- if(pc)
- pc->print(stderr,pc);
+ //if(pc)
+ // pc->print(stderr,pc);
pcr = pcr->next;
}
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
projects / fw / sdcc / blobdiff