1 /*-------------------------------------------------------------------------
3 pcoderegs.c - post code generation register optimizations
5 Written By - Scott Dattalo scott@dattalo.com
6 Ported To PIC16 By - m.dubuc@rogers.com
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 -------------------------------------------------------------------------*/
27 The purpose of the code in this file is to optimize the register usage.
32 #include "common.h" // Include everything in the SDCC src directory
37 #include "pcoderegs.h"
38 #include "pcodeflow.h"
41 #define DEBUG_REMOVE1PCODE 0
42 #define HAVE_DBGREGUSAGE 0
45 extern void pic16_pCodeInsertAfter(pCode *pc1, pCode *pc2);
46 extern pCode * pic16_findPrevInstruction(pCode *pci);
47 extern pBranch * pic16_pBranchAppend(pBranch *h, pBranch *n);
48 void pic16_unlinkpCode(pCode *pc);
49 extern int pic16_pCodeSearchCondition(pCode *pc, unsigned int cond);
51 static int total_registers_saved=0;
52 static int register_optimization=1;
54 /*-----------------------------------------------------------------*
55 * void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
56 *-----------------------------------------------------------------*/
58 void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
61 if(!reg || ! pcfl || !isPCFL(pcflow))
65 pcfl->registers = newSet();
71 /*-----------------------------------------------------------------*
73 *-----------------------------------------------------------------*/
76 static void dbg_regusage(set *fregs)
83 for (reg = setFirstItem(fregs) ; reg ;
84 reg = setNextItem(fregs)) {
86 if(elementsInSet(reg->reglives.usedpCodes)) {
88 fprintf (stderr, "%s addr=0x%03x rIdx=0x%03x",
93 pcfl = setFirstItem(reg->reglives.usedpFlows);
95 fprintf(stderr, "\n used in seq");
98 fprintf(stderr," 0x%03x",pcfl->seq);
99 pcfl = setNextItem(reg->reglives.usedpFlows);
102 pcfl = setFirstItem(reg->reglives.assignedpFlows);
104 fprintf(stderr, "\n assigned in seq");
107 fprintf(stderr," 0x%03x",pcfl->seq);
108 pcfl = setNextItem(reg->reglives.assignedpFlows);
111 pc = setFirstItem(reg->reglives.usedpCodes);
113 fprintf(stderr, "\n used in instructions ");
116 pcfl = PCODE(PCI(pc)->pcflow);
118 fprintf(stderr," 0x%03x:",pcfl->seq);
119 fprintf(stderr,"0x%03x",pc->seq);
121 pc = setNextItem(reg->reglives.usedpCodes);
124 fprintf(stderr, "\n");
129 /*-----------------------------------------------------------------*
131 *-----------------------------------------------------------------*/
134 void dbg_dumpregusage(void)
137 fprintf(stderr,"*** Register Usage ***\n");
138 fprintf(stderr,"InternalRegs:\n");
139 dbg_regusage(pic16_dynInternalRegs);
140 fprintf(stderr,"AllocRegs:\n");
141 dbg_regusage(pic16_dynAllocRegs);
142 fprintf(stderr,"StackRegs:\n");
143 dbg_regusage(pic16_dynStackRegs);
144 fprintf(stderr,"DirectRegs:\n");
145 dbg_regusage(pic16_dynDirectRegs);
146 fprintf(stderr,"DirectBitRegs:\n");
147 dbg_regusage(pic16_dynDirectBitRegs);
148 fprintf(stderr,"ProcessorRegs:\n");
149 dbg_regusage(pic16_dynProcessorRegs);
154 /*-----------------------------------------------------------------*
155 * void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
156 *-----------------------------------------------------------------*/
157 static void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
169 pc = pic16_findNextInstruction(pcfl->pc.next);
171 while(pic16_isPCinFlow(pc,PCODE(pcfl))) {
174 reg = pic16_getRegFromInstruction(pc);
176 if(reg && (reg->type != REG_TMP)) {
179 fprintf(stderr, "reg= %p\n", reg);
180 fprintf(stderr, "flow seq %d, inst seq %d %s ",PCODE(pcfl)->seq,pc->seq,reg->name);
181 fprintf(stderr, "addr = 0x%03x, type = %d rIdx=0x%03x ",
182 reg->address,reg->type,reg->rIdx);
183 fprintf(stderr, "command = %s\n", PCI(pc)->mnemonic);
187 // fprintf(stderr, "%s:%d: trying to get first operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
188 addSetIfnotP(& (PCFL(pcfl)->registers), reg);
190 if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
191 addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
193 if(PCC_REGISTER & PCI(pc)->outCond)
194 addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
196 addSetIfnotP(& (reg->reglives.usedpCodes), pc);
201 /* check to see if this pCode has 2 memory operands,
202 and set up the second operand too */
203 if(PCI(pc)->is2MemOp) {
204 reg = pic16_getRegFromInstruction2(pc);
206 // fprintf(stderr, "%s:%d: trying to get second operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
207 addSetIfnotP(& (PCFL(pcfl)->registers), reg);
209 if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
210 addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
212 if((PCC_REGISTER | PCC_REGISTER2) & PCI(pc)->outCond)
213 addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
215 addSetIfnotP(& (reg->reglives.usedpCodes), pc);
226 pc = pic16_findNextInstruction(pc->next);
232 /*-----------------------------------------------------------------*
233 * void pic16_pCodeRegMapLiveRanges(pBlock *pb)
234 *-----------------------------------------------------------------*/
235 void pic16_pCodeRegMapLiveRanges(pBlock *pb)
239 for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
241 pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
243 if(!isPCFL(pcflow)) {
244 fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
247 pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
251 for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
253 pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
255 regs *r = setFirstItem(PCFL(pcflow)->registers);
256 fprintf(stderr,"flow seq %d\n", pcflow->seq);
259 fprintf(stderr, " %s\n",r->name);
260 r = setNextItem(PCFL(pcflow)->registers);
274 /*-----------------------------------------------------------------*
276 *-----------------------------------------------------------------*/
277 static void Remove1pcode(pCode *pc, regs *reg)
284 deleteSetItem (&(reg->reglives.usedpCodes),pc);
286 #if DEBUG_REMOVE1PCODE
287 fprintf(stderr,"removing instruction:\n");
288 pc->print(stderr,pc);
292 pcn = pic16_findNextInstruction(pc->next);
295 PCI(pcn)->label = pic16_pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
300 pcn = pic16_findNextInstruction(pc->next);
303 if(PCI(pcn)->cline) {
305 #if DEBUG_REMOVE1PCODE
306 fprintf(stderr, "source line has been optimized completely out\n");
307 pc->print(stderr,pc);
311 PCI(pcn)->cline = PCI(pc)->cline;
320 /*-----------------------------------------------------------------*
321 * void RemoveRegsFromSet(set *regset)
323 *-----------------------------------------------------------------*/
324 static void RemoveRegsFromSet(set *regset)
331 regset = regset->next;
333 used = elementsInSet(reg->reglives.usedpCodes);
337 // fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
341 // fprintf(stderr,"%s:%d: getting rid of reg %s\n",__FILE__, __LINE__, reg->name);
349 pc = setFirstItem(reg->reglives.usedpCodes);
351 if(reg->type == REG_SFR) {
352 fprintf(stderr, "not removing SFR reg %s even though used only once\n", reg->name);
358 pCode *pcn = pic16_findNextInstruction(pc->next);
360 if(pcn && PCI(pcn)->label) {
361 //fprintf(stderr,"can't delete instruction with label...\n");
362 //pc->print(stderr,pc);
365 /* Move the label to the next instruction */
367 PCI(pcn)->label = PCI(pc)->label;
372 regs *r = pic16_getRegFromInstruction(pc);
373 fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
374 pc->print(stderr,pc);
375 fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
378 Remove1pcode(pc, reg);
380 pic16_unlinkpCode(pc);
381 deleteSetItem (&(reg->reglives.usedpCodes),pc);
385 total_registers_saved++; // debugging stats.
392 /*-----------------------------------------------------------------*
393 * void pic16_RemoveUnusedRegisters(void)
395 *-----------------------------------------------------------------*/
396 void pic16_RemoveUnusedRegisters(void)
398 /* First, get rid of registers that are used only one time */
400 //RemoveRegsFromSet(pic16_dynInternalRegs);
401 RemoveRegsFromSet(pic16_dynAllocRegs);
402 RemoveRegsFromSet(pic16_dynStackRegs);
404 don't do DirectRegs yet - there's a problem with arrays
405 RemoveRegsFromSet(pic16_dynDirectRegs);
407 RemoveRegsFromSet(pic16_dynDirectBitRegs);
409 if(total_registers_saved && pic16_pcode_verbose)
410 fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
413 static int insideLRBlock(pCode *pc)
420 if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
421 t1 = PCOLR (PCINF (pc1)->oper1)->type;
429 if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
430 t2 = PCOLR (PCINF (pc1)->oper1)->type;
436 if((t1 == LR_ENTRY_BEGIN && t2 == LR_ENTRY_END)
437 || (t1 == LR_EXIT_BEGIN && t2 == LR_EXIT_END))
444 static void RemoveRegFromLRBlock(regs *reg)
446 if(elementsInSet(reg->reglives.usedpCodes) == 2) {
449 /* only continue if there are just 2 uses of the register,
450 * in in the local *entry* block and one in the local *exit* block */
452 /* search for entry block */
453 pc1 = indexSet(reg->reglives.usedpCodes, 1);
455 if(insideLRBlock( pc1 )) {
456 fprintf(stderr, "usedpCodes[0] inside LR block\n");
457 deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
458 Remove1pcode(pc1, reg);
461 pc1 = indexSet(reg->reglives.usedpCodes, 0);
462 if(insideLRBlock( pc1 )) {
463 fprintf(stderr, "usedpCodes[1] inside LR block\n");
464 deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
465 Remove1pcode(pc1, reg);
476 /*-----------------------------------------------------------------*
478 *-----------------------------------------------------------------*/
479 static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
485 fprintf(stderr,"removing 2 instructions:\n");
486 pc1->print(stderr,pc1);
487 pc2->print(stderr,pc2);
491 Remove1pcode(pc1, reg);
494 Remove1pcode(pc2, reg);
495 deleteSetItem (&(PCFL(pcflow)->registers), reg);
504 pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
507 // fprintf(stderr, "register %s is used in %d pCodes, assigned in %d pCodes\n", reg->name,
508 // elementsInSet(reg->reglives.usedpCodes),
509 // elementsInSet(reg->reglives.assignedpFlows));
511 RemoveRegFromLRBlock(reg);
516 /*-----------------------------------------------------------------*
518 *-----------------------------------------------------------------*/
519 static int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
525 testreg = pic16_getRegFromInstruction(pc1);
526 if(testreg && (testreg->rIdx == reg->rIdx)) {
530 if(PCI(pc1)->is2MemOp) {
531 testreg = pic16_getRegFromInstruction2(pc1);
532 if(testreg && (testreg->rIdx == reg->rIdx)) {
537 pc1 = pic16_findNextInstruction(pc1->next);
539 } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
542 fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
547 /*-----------------------------------------------------------------*
548 * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
550 * ADHOC pattern checking
551 * Now look for specific sequences that are easy to optimize.
552 * Many of these sequences are characteristic of the compiler
553 * (i.e. it'd probably be a waste of time to apply these adhoc
554 * checks to hand written assembly.)
557 *-----------------------------------------------------------------*/
558 static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
563 int t = total_registers_saved;
565 if(reg->type == REG_SFR)return 0;
567 if(pc2->seq < pc1->seq) {
573 fprintf(stderr,"pCodeOptime2pCodes\n");
574 pc1->print(stderr,pc1);
575 pc2->print(stderr,pc2);
577 if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
591 //fprintf(stderr, " CLRF/MOVFW. instruction after MOVFW is:\n");
592 pct1 = pic16_findNextInstruction(pc2->next);
594 if(PCI(pct1)->op == POC_MOVWF) {
595 newpc = pic16_newpCode(POC_CLRF, PCI(pct1)->pcop);
596 pct1->destruct(pct1);
598 newpc = pic16_newpCode(POC_MOVLW, pic16_newpCodeOpLit(0));
601 pic16_pCodeInsertAfter(pc2, newpc);
602 PCI(newpc)->pcflow = PCFL(pcfl_used);
603 newpc->seq = pc2->seq;
605 /* take care if register is used after pc2, if yes, then don't delete
606 * clrf reg, because, reg should be initialized with zero */
611 for(spc=setFirstItem(reg->reglives.usedpCodes);spc;spc=setNextItem(reg->reglives.usedpCodes)) {
612 if(maxSeq < spc->seq)maxSeq = spc->seq;
615 // fprintf(stderr, "pc1->seq = %d\tpc2->seq = %d\tspc->seq = %d\n", pc1->seq, pc2->seq, maxSeq);
617 if(maxSeq > pc2->seq) {
618 /* this means that a pCode uses register after pc2, then
619 * we can't delete pc1 pCode */
620 Remove2pcodes(pcfl_used, NULL, pc2, reg, can_free);
622 /* we can remove both pCodes */
623 Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
626 total_registers_saved++; // debugging stats.
628 } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
629 //fprintf(stderr, " CLRF/IORFW.\n");
631 pct2 = pic16_findNextInstruction(pc2->next);
633 if(pic16_pCodeSearchCondition(pct2, PCC_Z) > 0) {
634 pct2 = pic16_newpCode(POC_IORLW, pic16_newpCodeOpLit(0));
635 pct2->seq = pc2->seq;
636 PCI(pct2)->pcflow = PCFL(pcfl_used);
637 pic16_pCodeInsertAfter(pc1,pct2);
639 Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
640 total_registers_saved++; // debugging stats.
642 } else if(PCI(pc1)->op == POC_MOVWF) {
644 reg1 = pic16_getRegFromInstruction(pc1);
646 if(reg1->type == REG_SFR)return (total_registers_saved != t);
648 pct2 = pic16_findNextInstruction(pc2->next);
650 if(PCI(pc2)->op == POC_MOVFW) {
653 fprintf(stderr, " MOVWF/MOVFW. instruction after MOVFW is:\n");
654 pct2->print(stderr,pct2);
657 if(PCI(pct2)->op == POC_MOVWF) {
672 reg2 = pic16_getRegFromInstruction(pct2);
673 if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
674 // if(reg2 && !regUsedinRange(pc1,pc2,reg2))
676 if(pic16_pCodeSearchCondition(pct2, PCC_Z) < 1) {
677 pCode *pct3 = pic16_findNextInstruction(pct2->next);
678 pct2->seq = pc1->seq;
679 pic16_unlinkpCode(pct2);
680 pic16_pCodeInsertAfter(pic16_findPrevInstruction(pc1->prev),pct2);
682 #define usesW(x) ((x) && (isPCI(x)) && ( (PCI(x)->inCond & PCC_W) != 0))
685 ; // Remove2pcodes(pcfl_used, pc1, NULL, reg, can_free);
687 Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
688 total_registers_saved++; // debugging stats.
692 // fprintf(stderr,"didn't optimize because Z bit is used\n");
696 fprintf(stderr, " couldn't optimize\n");
698 fprintf(stderr, " %s is used in range\n", reg2->name);
700 fprintf(stderr, " reg2 is NULL\n");
705 pct1 = pic16_findPrevInstruction(pc1->prev);
706 if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
708 if ( (PCI(pct1)->op == POC_MOVFW) &&
709 (PCI(pc2)->op == POC_MOVFW)) {
711 reg1 = pic16_getRegFromInstruction(pct1);
712 if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
715 fprintf(stderr, " MOVF/MOVFW. \n");
716 fprintf(stderr, " ...optimizing\n");
734 Or, if we're not deleting the register then the "To" is:
743 pct2 = pic16_newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
744 pic16_pCodeInsertAfter(pc2, pct2);
745 PCI(pct2)->pcflow = PCFL(pcfl_used);
746 pct2->seq = pc2->seq;
749 Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
751 /* If we're not freeing the register then that means (probably)
752 * the register is needed somewhere else.*/
753 pic16_unlinkpCode(pc1);
754 pic16_pCodeInsertAfter(pct2, pc1);
756 Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
759 Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
760 total_registers_saved++; // debugging stats.
763 } else if ( (PCI(pct1)->op == POC_MOVWF) &&
764 (PCI(pc2)->op == POC_MOVFW)) {
766 // fprintf(stderr,"movwf MOVWF/MOVFW\n");
768 if(optimize_level > 1 && can_free) {
769 pct2 = pic16_newpCode(POC_MOVFW, PCI(pc1)->pcop);
770 pic16_pCodeInsertAfter(pc2, pct2);
771 Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
772 total_registers_saved++; // debugging stats.
781 return (total_registers_saved != t);
784 /*-----------------------------------------------------------------*
785 * void pCodeRegOptimeRegUsage(pBlock *pb)
786 *-----------------------------------------------------------------*/
787 static void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_level)
791 pCode *pc1=NULL, *pc2=NULL;
795 pCode *pcfl_used, *pcfl_assigned;
797 /* Step through the set by directly accessing the 'next' pointer.
798 * We could also step through by using the set API, but the
799 * the (debug) calls to print instructions affect the state
800 * of the set pointers */
805 if(reg->type == REG_SFR) {
806 // fprintf(stderr,"skipping SFR: %s\n",reg->name);
810 pcfl_used = setFirstItem(reg->reglives.usedpFlows);
811 pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
813 used = elementsInSet(reg->reglives.usedpCodes);
814 // fprintf(stderr, "%s:%d register %s used %d times in pCode\n", __FILE__, __LINE__, reg->name, used);
818 * In this section, all registers that are used in only in two
819 * instructions are examined. If possible, they're optimized out.
823 fprintf (stderr, "OptimizeRegUsage: %s addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
826 reg->rIdx, reg->type, used);
829 pc1 = setFirstItem(reg->reglives.usedpCodes);
830 pc2 = setNextItem(reg->reglives.usedpCodes);
832 if(pcfl_used && pcfl_assigned) {
835 expected case - the register has been assigned a value and is
839 //fprintf(stderr," used only twice\n");
840 if(pcfl_used->seq == pcfl_assigned->seq && !(setNextItem(reg->reglives.usedpFlows)) && !(setNextItem(reg->reglives.assignedpFlows))) {
842 //fprintf(stderr, " and used in same flow\n");
844 pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
847 // fprintf(stderr, " and used in different flows\n");
851 } else if(pcfl_used) {
854 register has been used twice without ever being assigned */
855 //fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
858 // fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
859 Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
860 total_registers_saved++; // debugging stats.
864 /* register has been used either once, or more than twice */
866 if(used && !pcfl_used && pcfl_assigned) {
869 fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
871 pc = setFirstItem(reg->reglives.usedpCodes);
874 pcfl_assigned = PCODE(PCI(pc)->pcflow);
875 Remove1pcode(pc, reg);
877 deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
879 deleteSetItem (&(reg->reglives.usedpCodes),pc);
882 pc = setNextItem(reg->reglives.usedpCodes);
889 total_registers_saved++; // debugging stats.
890 } else if( (used > 2) && optimize_multi_uses) {
896 pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
898 /* examine the number of times this register is used */
901 rset1 = reg->reglives.usedpCodes;
902 while(rset1 && searching) {
907 if(pc1 && isPCI(pc1) && ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
909 //while(rset2 && searching) {
913 if(pc2 && isPCI(pc2) && ( (pcfl2 = PCI(pc2)->pcflow) != NULL) ) {
916 if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
921 //rset2 = rset2->next;
933 /*-----------------------------------------------------------------*
934 * void pic16_pCodeRegOptimeRegUsage(pBlock *pb)
935 *-----------------------------------------------------------------*/
936 void pic16_pCodeRegOptimizeRegUsage(int level)
941 int t = total_registers_saved;
943 if(getenv("NO_REG_OPT"))
946 if(!register_optimization)
953 saved = total_registers_saved;
955 /* Identify registers used in one flow sequence */
956 OptimizeRegUsage(pic16_dynAllocRegs,level, (OPT_PASSES-passes));
957 OptimizeRegUsage(pic16_dynStackRegs,level, (OPT_PASSES-passes));
958 OptimizeRegUsage(pic16_dynDirectRegs,0, (OPT_PASSES-passes));
960 if((total_registers_saved != saved)
961 && (pic16_pcode_verbose))
962 fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
963 (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
967 } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
969 if(total_registers_saved == t)
970 if(pic16_debug_verbose)
971 fprintf(stderr, "No registers saved on this pass\n");
975 fprintf(stderr,"dynamically allocated regs:\n");
976 dbg_regusage(pic16_dynAllocRegs);
977 fprintf(stderr,"stack regs:\n");
978 dbg_regusage(pic16_dynStackRegs);
979 fprintf(stderr,"direct regs:\n");
980 dbg_regusage(pic16_dynDirectRegs);
985 /*-----------------------------------------------------------------*
986 * void RegsUnMapLiveRanges(set *regset)
988 *-----------------------------------------------------------------*/
989 static void RegsSetUnMapLiveRanges(set *regset)
995 regset = regset->next;
997 deleteSet(®->reglives.usedpCodes);
998 deleteSet(®->reglives.usedpFlows);
999 deleteSet(®->reglives.assignedpFlows);
1005 void pic16_RegsUnMapLiveRanges(void)
1007 RegsSetUnMapLiveRanges(pic16_dynAllocRegs);
1008 RegsSetUnMapLiveRanges(pic16_dynStackRegs);
1009 RegsSetUnMapLiveRanges(pic16_dynDirectRegs);
1010 RegsSetUnMapLiveRanges(pic16_dynProcessorRegs);
1011 RegsSetUnMapLiveRanges(pic16_dynDirectBitRegs);
1012 RegsSetUnMapLiveRanges(pic16_dynInternalRegs);