- pCode *pcflow;
-
-
- //pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- //pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- BanksUsedFlow2(pcflow);
- }
-
-}
-
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void insertBankSwitch(pCode *pc, int Set_Clear, int RP_BankBit)
-{
- pCode *new_pc;
-
- if(!pc)
- return;
-
- if(RP_BankBit < 0)
- new_pc = newpCode(POC_CLRF, popCopyReg(&pc_status));
- else
- new_pc = newpCode((Set_Clear ? POC_BSF : POC_BCF),
- popCopyGPR2Bit(PCOP(&pc_status),RP_BankBit));
-
- pCodeInsertAfter(pc->prev, new_pc);
-
- /* Move the label, if there is one */
-
- if(PCI(pc)->label) {
- PCI(new_pc)->label = PCI(pc)->label;
- PCI(pc)->label = NULL;
- }
-
- /* The new instruction has the same pcflow block */
- PCI(new_pc)->pcflow = PCI(pc)->pcflow;
-
-}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void FixRegisterBankingInFlow(pCodeFlow *pcfl, int cur_bank)
-{
- pCode *pc=NULL;
- pCode *pcprev=NULL;
- pCode *new_pc;
-
- regs *reg;
-
- if(!pcfl)
- return;
-
- pc = findNextInstruction(pcfl->pc.next);
-
- while(isPCinFlow(pc,PCODE(pcfl))) {
-
-
- 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 || (pcprev && !isPCI_SKIP(pcprev))) {
- int b = cur_bank ^ REG_BANK(reg);
-
- //fprintf(stderr, "Cool! can switch banks\n");
- cur_bank = REG_BANK(reg);
- switch(b & 3) {
- case 0:
- break;
- case 1:
- insertBankSwitch(pc, cur_bank&1, PIC_RP0_BIT);
- break;
- case 2:
- insertBankSwitch(pc, cur_bank&2, PIC_RP1_BIT);
- insertBankSwitch(pc, cur_bank&2, PIC_RP1_BIT);
- break;
- case 3:
- if(cur_bank & 3) {
- insertBankSwitch(pc, cur_bank&1, PIC_RP0_BIT);
- insertBankSwitch(pc, cur_bank&2, PIC_RP1_BIT);
- } else
- insertBankSwitch(pc, -1, -1);
- break;
- /*
- 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 = findNextInstruction(pc->next);
-
- }
-
- 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;
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/*int compareBankFlow - compare the banking requirements between */
-/* flow objects. */
-/*-----------------------------------------------------------------*/
-int compareBankFlow(pCodeFlow *pcflow, pCodeFlowLink *pcflowLink, int toORfrom)
-{
-
- if(!pcflow || !pcflowLink || !pcflowLink->pcflow)
- return 0;
-
- if(!isPCFL(pcflow) || !isPCFL(pcflowLink->pcflow))
- return 0;
-
- if(pcflow->firstBank == -1)
- return 0;
-
-
- if(pcflowLink->pcflow->firstBank == -1) {
- pCodeFlowLink *pctl = setFirstItem( toORfrom ?
- pcflowLink->pcflow->to :
- pcflowLink->pcflow->from);
- return compareBankFlow(pcflow, pctl, toORfrom);
- }
-
- if(toORfrom) {
- if(pcflow->lastBank == pcflowLink->pcflow->firstBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->FromConflicts++;
- pcflow->ToConflicts++;
- } else {
-
- if(pcflow->firstBank == pcflowLink->pcflow->lastBank)
- return 0;
-
- pcflowLink->bank_conflict++;
- pcflowLink->pcflow->ToConflicts++;
- pcflow->FromConflicts++;
-
- }
- /*
- fprintf(stderr,"compare flow found conflict: seq %d from conflicts %d, to conflicts %d\n",
- pcflowLink->pcflow->pc.seq,
- pcflowLink->pcflow->FromConflicts,
- pcflowLink->pcflow->ToConflicts);
- */
- return 1;
-
-}
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void FixBankFlow(pBlock *pb)
-{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
- pCode *pcflow_max_To=NULL;
- pCode *pcflow_max_From=NULL;
- int max_ToConflicts=0;
- int max_FromConflicts=0;
-
- //fprintf(stderr,"Fix Bank flow \n");
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
-
-
- /*
- First loop through all of the flow objects in this pcode block
- and fix the ones that have banking conflicts between the
- entry and exit.
- */
-
- //fprintf(stderr, "FixBankFlow - Phase 1\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
-
- if(PCFL(pcflow)->firstBank != PCFL(pcflow)->lastBank &&
- PCFL(pcflow)->firstBank >= 0 &&
- PCFL(pcflow)->lastBank >= 0 ) {
-
- int cur_bank = (PCFL(pcflow)->firstBank < PCFL(pcflow)->lastBank) ?
- PCFL(pcflow)->firstBank : PCFL(pcflow)->lastBank;
-
- FixRegisterBankingInFlow(PCFL(pcflow),cur_bank);
- BanksUsedFlow2(pcflow);
-
- }
- }
-
- //fprintf(stderr, "FixBankFlow - Phase 2\n");
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- int nFlows;
- int nConflicts;
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "FixBankFlow - pcflow is not a flow object ");
- continue;
- }
-
- PCFL(pcflow)->FromConflicts = 0;
- PCFL(pcflow)->ToConflicts = 0;
-
- nFlows = 0;
- nConflicts = 0;
-
- //fprintf(stderr, " FixBankFlow flow seq %d\n",pcflow->seq);
- pcfl = setFirstItem(PCFL(pcflow)->from);
- while (pcfl) {
-
- pc = PCODE(pcfl->pcflow);
-
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 0);
- nFlows++;
-
- pcfl=setNextItem(PCFL(pcflow)->from);
- }
-
- if((nFlows >= 2) && nConflicts && (PCFL(pcflow)->firstBank>0)) {
- //fprintf(stderr, " From conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
-
- FixRegisterBankingInFlow(PCFL(pcflow),0);
- BanksUsedFlow2(pcflow);
-
- continue; /* Don't need to check the flow from here - it's already been fixed */
-
- }
-
- nFlows = 0;
- nConflicts = 0;
-
- pcfl = setFirstItem(PCFL(pcflow)->to);
- while (pcfl) {
-
- pc = PCODE(pcfl->pcflow);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- nConflicts += compareBankFlow(PCFL(pcflow), pcfl, 1);
- nFlows++;
-
- pcfl=setNextItem(PCFL(pcflow)->to);
- }
-
- if((nFlows >= 2) && nConflicts &&(nConflicts != nFlows) && (PCFL(pcflow)->lastBank>0)) {
- //fprintf(stderr, " To conflicts flow seq %d, nflows %d ,nconflicts %d\n",pcflow->seq,nFlows, nConflicts);
-
- FixRegisterBankingInFlow(PCFL(pcflow),0);
- BanksUsedFlow2(pcflow);
- }
- }
-
- /*
- Loop through the flow objects again and find the ones with the
- maximum conflicts
- */
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(PCFL(pcflow)->ToConflicts > max_ToConflicts)
- pcflow_max_To = pcflow;
-
- if(PCFL(pcflow)->FromConflicts > max_FromConflicts)
- pcflow_max_From = pcflow;
- }
-/*
- if(pcflow_max_To)
- fprintf(stderr,"compare flow Max To conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_To)->pc.seq,
- PCFL(pcflow_max_To)->ToConflicts);
-
- if(pcflow_max_From)
- fprintf(stderr,"compare flow Max From conflicts: seq %d conflicts %d\n",
- PCFL(pcflow_max_From)->pc.seq,
- PCFL(pcflow_max_From)->FromConflicts);
-*/
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-void DumpFlow(pBlock *pb)
-{
- pCode *pc=NULL;
- pCode *pcflow;
- pCodeFlowLink *pcfl;
-
-
- fprintf(stderr,"Dump flow \n");
- pb->pcHead->print(stderr, pb->pcHead);
-
- pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow->print(stderr,pcflow);
-
- for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
- pcflow != NULL;
- pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
-
- if(!isPCFL(pcflow)) {
- fprintf(stderr, "DumpFlow - pcflow is not a flow object ");
- continue;
- }
- fprintf(stderr,"dumping: ");
- pcflow->print(stderr,pcflow);
- FlowStats(PCFL(pcflow));
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " from seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - from is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- for(pcfl = setFirstItem(PCFL(pcflow)->to); pcfl; pcfl=setNextItem(PCFL(pcflow)->to)) {
-
- pc = PCODE(pcfl->pcflow);
-
- fprintf(stderr, " to seq %d:\n",pc->seq);
- if(!isPCFL(pc)) {
- fprintf(stderr,"oops dumpflow - to is not a pcflow\n");
- pc->print(stderr,pc);
- }
-
- }
-
- }
-
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-int OptimizepBlock(pBlock *pb)
-{
- pCode *pc, *pcprev;
- 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);
-*/
-
- pc = findNextInstruction(pb->pcHead);
- if(!pc)
- return 0;
-
- pcprev = pc->prev;
- do {
-
-
- if(pCodePeepMatchRule(pc)) {
-
- matches++;
-
- if(pcprev)
- pc = findNextInstruction(pcprev->next);
- else
- pc = findNextInstruction(pb->pcHead);
- } else
- pc = findNextInstruction(pc->next);
- } while(pc);
-
- if(matches)
- DFPRINTF((stderr," Optimizing pBlock: %c - matches=%d\n",getpBlock_dbName(pb),matches));
- return matches;
-
-}
-
-/*-----------------------------------------------------------------*/
-/* pBlockRemoveUnusedLabels - remove the pCode labels from the */
-/*-----------------------------------------------------------------*/
-pCode * findInstructionUsingLabel(pCodeLabel *pcl, pCode *pcs)
-{
- pCode *pc;
-
- 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 exchangeLabels(pCodeLabel *pcl, pCode *pc)
-{
-
- if(isPCI(pc) &&
- (PCI(pc)->pcop) &&
- (PCI(pc)->pcop->type == PO_LABEL)) {
-
- pCodeOpLabel *pcol = PCOLAB(PCI(pc)->pcop);
-
- //fprintf(stderr,"changing label key from %d to %d\n",pcol->key, pcl->key);
- if(pcol->pcop.name)
- free(pcol->pcop.name);
-
- sprintf(buffer,"_%05d_DS_",pcl->key);
-
- pcol->pcop.name = Safe_strdup(buffer);
- pcol->key = pcl->key;
- //pc->print(stderr,pc);
-
- }
-
-
-}
-
-/*-----------------------------------------------------------------*/
-/* pBlockRemoveUnusedLabels - remove the pCode labels from the */
-/* pCode chain if they're not used. */
-/*-----------------------------------------------------------------*/
-void pBlockRemoveUnusedLabels(pBlock *pb)
-{
- pCode *pc; pCodeLabel *pcl;
-
- if(!pb)
- return;
-
- for(pc = pb->pcHead; (pc=findNextInstruction(pc->next)) != NULL; ) {
-
- pBranch *pbr = PCI(pc)->label;
- if(pbr && pbr->next) {
- pCode *pcd = pb->pcHead;
-
- //fprintf(stderr, "multiple labels\n");
- //pc->print(stderr,pc);
-
- pbr = pbr->next;
- while(pbr) {
-
- while ( (pcd = findInstructionUsingLabel(PCL(PCI(pc)->label->pc), pcd)) != NULL) {
- //fprintf(stderr,"Used by:\n");
- //pcd->print(stderr,pcd);
-
- exchangeLabels(PCL(pbr->pc),pcd);
-
- pcd = pcd->next;
- }
- pbr = pbr->next;
- }
- }
- }
-
- for(pc = pb->pcHead; pc; pc = pc->next) {
-
- if(isPCL(pc)) // pc->type == PC_LABEL)
- pcl = PCL(pc);
- else if (isPCI(pc) && PCI(pc)->label) //((pc->type == PC_OPCODE) && PCI(pc)->label)
- pcl = PCL(PCI(pc)->label->pc);
- else continue;
-
- //fprintf(stderr," found A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
-
- /* This pCode is a label, so search the pBlock to see if anyone
- * refers to it */
-
- if( (pcl->key>0) && (!findInstructionUsingLabel(pcl, pb->pcHead))) {
- //if( !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 */
- //fprintf(stderr," removed A LABEL !!! key = %d, %s\n", pcl->key,pcl->label);
-
- DFPRINTF((stderr," !!! REMOVED A LABEL !!! key = %d, %s\n", pcl->key,pcl->label));
- if(pc->type == PC_LABEL) {
- unlinkpCode(pc);
- pCodeLabelDestruct(pc);
- } else {
- unlinkpCodeFromBranch(pc, PCODE(pcl));
- /*if(pc->label->next == NULL && pc->label->pc == NULL) {
- free(pc->label);
- }*/
- }
-
- }
- }
-
-}
-
-
-/*-----------------------------------------------------------------*/
-/* pBlockMergeLabels - remove the pCode labels from the pCode */
-/* chain and put them into pBranches that are */
-/* associated with the appropriate pCode */
-/* instructions. */
-/*-----------------------------------------------------------------*/
-void pBlockMergeLabels(pBlock *pb)
-{
- pBranch *pbr;
- pCode *pc, *pcnext=NULL;
-
- if(!pb)
- return;
-
- /* First, Try to remove any unused labels */
- //pBlockRemoveUnusedLabels(pb);
-
- /* Now loop through the pBlock and merge the labels with the opcodes */
-
- pc = pb->pcHead;
- // for(pc = pb->pcHead; pc; pc = pc->next) {
-
- while(pc) {
- pCode *pcn = pc->next;
-
- if(pc->type == PC_LABEL) {
-
- //fprintf(stderr," checking merging label %s\n",PCL(pc)->label);
- //fprintf(stderr,"Checking label key = %d\n",PCL(pc)->key);
- if((pcnext = findNextInstruction(pc) )) {
-
- // Unlink the pCode label from it's pCode chain
- unlinkpCode(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));
- pbr = Safe_calloc(1,sizeof(pBranch));
- pbr->pc = pc;
- pbr->next = NULL;
-
- PCI(pcnext)->label = pBranchAppend(PCI(pcnext)->label,pbr);
-
- } else {
- fprintf(stderr, "WARNING: couldn't associate label %s with an instruction\n",PCL(pc)->label);
- }
- } else if(pc->type == PC_CSOURCE) {
-
- /* merge the source line symbolic info into the next instruction */
- if((pcnext = findNextInstruction(pc) )) {
-
- // Unlink the pCode label from it's pCode chain
- unlinkpCode(pc);
- PCI(pcnext)->cline = PCCS(pc);
- //fprintf(stderr, "merging CSRC\n");
- //genericPrint(stderr,pcnext);
- }
-
- }
- pc = pcn;
- }
- pBlockRemoveUnusedLabels(pb);
-
-}
-
-/*-----------------------------------------------------------------*/
-/*-----------------------------------------------------------------*/
-int OptimizepCode(char dbName)
-{
-#define MAX_PASSES 4
-
- int matches = 0;
- int passes = 0;
- pBlock *pb;
-
- if(!the_pFile)
- return 0;
-
- DFPRINTF((stderr," Optimizing pCode\n"));
-
- do {
- matches = 0;
- for(pb = the_pFile->pbHead; pb; pb = pb->next) {
- if('*' == dbName || getpBlock_dbName(pb) == dbName)
- matches += OptimizepBlock(pb);
- }
- }
- while(matches && ++passes < MAX_PASSES);
-
- return matches;
-}
-
-/*-----------------------------------------------------------------*/
-/* popCopyGPR2Bit - copy a pcode operator */
-/*-----------------------------------------------------------------*/
-
-pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
-{
- pCodeOp *pcop;
-
- 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);
- pc = findNextpCode(pb->pcHead, PC_OPCODE);
- 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 || (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)));
-
-
- }while (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;
- }
-
-}
-
-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;
- }
-