* src/pic16/{device.c,pcode.c}: s/free/Safe_free/g for

[fw/sdcc] / src / pic16 / pcoderegs.c

diff --git a/src/pic16/pcoderegs.c b/src/pic16/pcoderegs.c
index a4b5b25955b9116a83964370a5d9627516f65330..807d9c043558bdc39a156a180e5acc1f74790808 100644 (file)
--- a/src/pic16/pcoderegs.c
+++ b/src/pic16/pcoderegs.c
@@ -167,17 +167,17 @@ static void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 
     reg = pic16_getRegFromInstruction(pc);
 
-    if(reg) {
-
+    if(reg && (reg->type != REG_TMP)) {
 #if 0
       fprintf(stderr, "reg= %p\n", reg);
       fprintf(stderr, "flow seq %d, inst seq %d  %s  ",PCODE(pcfl)->seq,pc->seq,reg->name);
-      fprintf(stderr, "addr = 0x%03x, type = %d  rIdx=0x%03x",
+      fprintf(stderr, "addr = 0x%03x, type = %d  rIdx=0x%03x ",
              reg->address,reg->type,reg->rIdx);
       fprintf(stderr, "command = %s\n", PCI(pc)->mnemonic);
              
 #endif
 
+//      fprintf(stderr, "%s:%d: trying to get first operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
       addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 
       if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
@@ -193,18 +193,18 @@ static void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
           and set up the second operand too */
        if(PCI(pc)->is2MemOp) {
                        reg = pic16_getRegFromInstruction2(pc);
-
-//                     fprintf(stderr, "trying to get second operand from pCode reg= %s\n", reg->name);
-                       addSetIfnotP(& (PCFL(pcfl)->registers), reg);
-
-                       if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
-                               addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
-
-                       if(PCC_REGISTER & PCI(pc)->outCond)
-                               addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
+                       if(reg) {
+//                             fprintf(stderr, "%s:%d: trying to get second operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
+                               addSetIfnotP(& (PCFL(pcfl)->registers), reg);
+
+                               if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
+                                       addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
+                                       
+                               if((PCC_REGISTER | PCC_REGISTER2) & PCI(pc)->outCond)
+                                       addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
                        
-                       addSetIfnotP(& (reg->reglives.usedpCodes), pc);
-
+                               addSetIfnotP(& (reg->reglives.usedpCodes), pc);
+                       }
        }
 #endif
 
@@ -318,8 +318,11 @@ static void  RemoveRegsFromSet(set *regset)
     if(used <= 1) {
 
 //     fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
+
       if(used == 0) {
-//             fprintf(stderr,"%s:%d: getting rid of reg %s\n",__FILE__, __LINE__, reg->name);
+
+//     fprintf(stderr,"%s:%d: getting rid of reg %s\n",__FILE__, __LINE__, reg->name);
+
        reg->isFree = 1;
        reg->wasUsed = 0;
       } else {
@@ -329,11 +332,10 @@ static void  RemoveRegsFromSet(set *regset)
        pc = setFirstItem(reg->reglives.usedpCodes);
 
        if(reg->type == REG_SFR) {
-               fprintf(stderr, "not removing SFR reg %s even though used only once\n",reg->name);
+               fprintf(stderr, "not removing SFR reg %s even though used only once\n", reg->name);
          continue;
        }
 
-
        if(isPCI(pc)) {
          if(PCI(pc)->label) {
            pCode *pcn = pic16_findNextInstruction(pc->next);
@@ -355,7 +357,10 @@ static void  RemoveRegsFromSet(set *regset)
            pc->print(stderr,pc);
            fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
          }
-//             fprintf(stderr,"%s:%d: removing reg %s because it is used only once\n",__FILE__, __LINE__, reg->name);
+
+         fprintf(stderr,"%s:%d: removing reg %s because it is used only once\n",__FILE__, __LINE__, reg->name);
+
+
          Remove1pcode(pc, reg);
          /*
            pic16_unlinkpCode(pc);
@@ -387,7 +392,8 @@ void pic16_RemoveUnusedRegisters(void)
   */
   RemoveRegsFromSet(pic16_dynDirectBitRegs);
 
-  if(total_registers_saved) fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
+  if(total_registers_saved && pic16_pcode_verbose)
+       fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
 }
 
 
@@ -399,6 +405,12 @@ static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int
   if(!reg)
     return;
 
+#if 0
+  fprintf(stderr,"removing 2 instructions:\n");
+  pc1->print(stderr,pc1);
+  pc2->print(stderr,pc2);
+#endif
+
   if(pc1)
     Remove1pcode(pc1, reg);
 
@@ -515,13 +527,18 @@ static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *re
 
   }  else if(PCI(pc1)->op == POC_MOVWF) {
 
+    reg1 = pic16_getRegFromInstruction(pc1);
+
+    if(reg1->type == REG_SFR)return (total_registers_saved != t);
+
     pct2 = pic16_findNextInstruction(pc2->next);
 
     if(PCI(pc2)->op == POC_MOVFW) {
-      /*
+
+#if 0
        fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
        pct2->print(stderr,pct2);
-      */
+#endif
 
       if(PCI(pct2)->op == POC_MOVWF) {
        /*
@@ -539,8 +556,8 @@ static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *re
            
        */
        reg2 = pic16_getRegFromInstruction(pct2);
-       //if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
-       if(reg2 && !regUsedinRange(pc1,pc2,reg2)) {
+       if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
+//     if(reg2 && !regUsedinRange(pc1,pc2,reg2)) 
 
          if(pic16_pCodeSearchCondition(pct2, PCC_Z) < 1) {
            pCode *pct3 = pic16_findNextInstruction(pct2->next);
@@ -561,13 +578,13 @@ static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *re
              //fprintf(stderr,"didn't optimize because Z bit is used\n");
            }
        }
-/*
+#if 0
        fprintf(stderr, " couldn't optimize\n");
        if(reg2)
          fprintf(stderr, " %s is used in range\n",reg2->name);
        else
          fprintf(stderr, " reg2 is NULL\n");
-*/
+#endif
       }
     }
 
@@ -630,7 +647,9 @@ static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *re
        }
       } else if ( (PCI(pct1)->op == POC_MOVWF) &&
           (PCI(pc2)->op == POC_MOVFW)) {
-       //fprintf(stderr,"movwf MOVWF/MOVFW\n");
+
+//        fprintf(stderr,"movwf MOVWF/MOVFW\n");
+
        if(optimize_level > 1 && can_free) {
          pct2 = pic16_newpCode(POC_MOVFW, PCI(pc1)->pcop);
          pic16_pCodeInsertAfter(pc2, pct2);
@@ -703,7 +722,7 @@ static void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_l
        */
 
        //fprintf(stderr," used only twice\n");
-       if(pcfl_used->seq == pcfl_assigned->seq) {
+       if(pcfl_used->seq == pcfl_assigned->seq && !(setNextItem(reg->reglives.usedpFlows)) && !(setNextItem(reg->reglives.assignedpFlows))) {
 
          //fprintf(stderr, "  and used in same flow\n");
 
@@ -732,7 +751,7 @@ static void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_l
       if(used && !pcfl_used && pcfl_assigned) {
        pCode *pc;
 
-//             fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
+               fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 
        pc = setFirstItem(reg->reglives.usedpCodes);
        while(pc) {
@@ -819,7 +838,8 @@ void pic16_pCodeRegOptimizeRegUsage(int level)
     OptimizeRegUsage(pic16_dynStackRegs,level, (OPT_PASSES-passes));
     OptimizeRegUsage(pic16_dynDirectRegs,0, (OPT_PASSES-passes));
 
-    if(total_registers_saved != saved)
+    if((total_registers_saved != saved)
+       && (pic16_pcode_verbose))
       fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n", 
              (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
       
@@ -833,14 +853,14 @@ void pic16_pCodeRegOptimizeRegUsage(int level)
     fprintf(stderr, "No registers saved on this pass\n");
 
 
-/*
+#if 0
   fprintf(stderr,"dynamically allocated regs:\n");
   dbg_regusage(pic16_dynAllocRegs);
   fprintf(stderr,"stack regs:\n");
   dbg_regusage(pic16_dynStackRegs);
   fprintf(stderr,"direct regs:\n");
   dbg_regusage(pic16_dynDirectRegs);
-*/
+#endif
 }