(bandaid) Fixed core dump. You have to specify a valid include file otherwise

you spew core. This temporary fix keeps the core intact; eventually there will be a more graceful fix.

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@2035 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/src/pic/device.c b/src/pic/device.c
index 3872735ff1cdab9e36333e1ab0cdfa95a481ccdb..7c6d28a5339c857f7b95eab3ddd5efa9df8e14ef 100644 (file)
--- a/src/pic/device.c
+++ b/src/pic/device.c
@@ -369,6 +369,18 @@ void init_pic(char *pic_type)
   pic->maxRAMaddress = -1;
 }
 
+/*-----------------------------------------------------------------*
+ *  
+ *-----------------------------------------------------------------*/
+int picIsInitialized(void)
+{
+  if(pic && pic->maxRAMaddress > 0)
+    return 1;
+
+  return 0;
+
+}
+
 /*-----------------------------------------------------------------*
  *  char *processor_base_name(void) - Include file is derived from this.
  *-----------------------------------------------------------------*/

diff --git a/src/pic/pcode.c b/src/pic/pcode.c
index 7c2bc0a0604aabc87d717e3f3ba7818c91003f1a..49568d18af0094ad80160b47317249e0415add12 100644 (file)
--- a/src/pic/pcode.c
+++ b/src/pic/pcode.c
@@ -75,7 +75,7 @@ static pBlock *pb_dead_pcodes = NULL;
 /* Hardcoded flags to change the behavior of the PIC port */
 static int peepOptimizing = 1;        /* run the peephole optimizer if nonzero */
 static int functionInlining = 1;      /* inline functions if nonzero */
-int debug_verbose = 0;                /* Set true to inundate .asm file */
+int debug_verbose = 1;                /* Set true to inundate .asm file */
 
 static int GpCodeSequenceNumber = 1;
 int GpcFlowSeq = 1;
@@ -84,6 +84,7 @@ extern void RemoveUnusedRegisters(void);
 extern void RegsUnMapLiveRanges(void);
 extern void BuildFlowTree(pBlock *pb);
 extern void pCodeRegOptimizeRegUsage(int level);
+extern int picIsInitialized(void);
 
 /****************************************************************/
 /*                      Forward declarations                    */
@@ -4709,6 +4710,15 @@ void AnalyzeBanking(void)
 {
   pBlock  *pb;
 
+  if(!picIsInitialized()) {
+    fprintf(stderr,"Temporary ERROR: at the moment you have to use\n");
+    fprintf(stderr,"an include file create by inc2h.pl. See SDCC source:\n");
+    fprintf(stderr,"support/scripts/inc2h.pl\n");
+    fprintf(stderr,"this is a nuisance bug that will be fixed shortly\n");
+
+    exit(1);
+  }
+
   /* Phase x - Flow Analysis - Used Banks
    *
    * In this phase, the individual flow blocks are examined

diff --git a/src/pic/pcoderegs.c b/src/pic/pcoderegs.c
index 2857771db50d8a9fbc4114fbcd7bc0be73df1ba7..f1c3717306aa9069049c5b66e419ce179929132b 100644 (file)
--- a/src/pic/pcoderegs.c
+++ b/src/pic/pcoderegs.c
@@ -421,7 +421,7 @@ int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
  * 
  *
  *-----------------------------------------------------------------*/
-int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free)
+int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
 {
   pCode *pct1, *pct2;
   regs  *reg1, *reg2;
@@ -488,10 +488,10 @@ int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int
     pct2 = findNextInstruction(pc2->next);
 
     if(PCI(pc2)->op == POC_MOVFW) {
-      /*
+      
        fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
        pct2->print(stderr,pct2);
-      */
+      
 
       if(PCI(pct2)->op == POC_MOVWF) {
        /*
@@ -542,20 +542,20 @@ int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int
     }
 
     pct1 = findPrevInstruction(pc1->prev);
-    if(pct1 && 
-       (PCI(pct1)->pcflow == PCI(pc1)->pcflow) && 
-       (PCI(pct1)->op == POC_MOVFW) &&
-       (PCI(pc2)->op == POC_MOVFW)) {
+    if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
 
-      reg1 = getRegFromInstruction(pct1);
-      if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
-       /*
-         fprintf(stderr, "   MOVF/MOVFW. \n");
-         fprintf(stderr, "     ...optimizing\n");
-       */
+      if ( (PCI(pct1)->op == POC_MOVFW) &&
+          (PCI(pc2)->op == POC_MOVFW)) {
 
-       /*
-         Change:
+       reg1 = getRegFromInstruction(pct1);
+       if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
+         /*
+           fprintf(stderr, "   MOVF/MOVFW. \n");
+           fprintf(stderr, "     ...optimizing\n");
+         */
+
+         /*
+           Change:
 
            movf   reg1,w
            movwf  reg
@@ -563,13 +563,13 @@ int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int
            stuff...
            movf   reg,w
 
-         To:
+           To:
 
            stuff...
 
            movf   reg1,w
 
-         Or, if we're not deleting the register then the "To" is:
+           Or, if we're not deleting the register then the "To" is:
 
            stuff...
 
@@ -577,30 +577,41 @@ int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int
            movwf  reg
 
 
-       */
-       pct2 = newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
-       pCodeInsertAfter(pc2, pct2);
-       PCI(pct2)->pcflow = PCFL(pcfl_used);
-       pct2->seq = pc2->seq;
+         */
+         pct2 = newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
+         pCodeInsertAfter(pc2, pct2);
+         PCI(pct2)->pcflow = PCFL(pcfl_used);
+         pct2->seq = pc2->seq;
+
+         if(can_free) {
+           Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
+         } else {
+           /* If we're not freeing the register then that means (probably)
+            * the register is needed somewhere else.*/
+           unlinkpCode(pc1);
+           pCodeInsertAfter(pct2, pc1);
+
+           Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
+         }
 
-       if(can_free) {
-         Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
-       } else {
-         /* If we're not freeing the register then that means (probably)
-          * the register is needed somewhere else.*/
-         unlinkpCode(pc1);
-         pCodeInsertAfter(pct2, pc1);
+         Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
+         total_registers_saved++;  // debugging stats.
 
-         Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
        }
+      } else if ( (PCI(pct1)->op == POC_MOVWF) &&
+          (PCI(pc2)->op == POC_MOVFW)) {
+       fprintf(stderr,"movwf MOVWF/MOVFW\n");
+       if(optimize_level > 1 && can_free) {
+         pct2 = newpCode(POC_MOVFW, PCI(pc1)->pcop);
+         pCodeInsertAfter(pc2, pct2);
+         Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
+         total_registers_saved++;  // debugging stats.
+       }
+      }
 
-       Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
-       total_registers_saved++;  // debugging stats.
 
-      }
     }
 
-
   }
 
   return (total_registers_saved != t);
@@ -609,7 +620,7 @@ int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int
 /*-----------------------------------------------------------------*
  * void pCodeRegOptimeRegUsage(pBlock *pb) 
  *-----------------------------------------------------------------*/
-void OptimizeRegUsage(set *fregs, int optimize_multi_uses)
+void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_level)
 {
   regs *reg;
   int used;
@@ -664,7 +675,7 @@ void OptimizeRegUsage(set *fregs, int optimize_multi_uses)
 
          //fprintf(stderr, "  and used in same flow\n");
 
-         pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1);
+         pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
 
        } else {
          // fprintf(stderr, "  and used in different flows\n");
@@ -736,8 +747,8 @@ void OptimizeRegUsage(set *fregs, int optimize_multi_uses)
              if(pc2 && isPCI(pc2)  &&  ( (pcfl2 = PCI(pc2)->pcflow) != NULL) )  {
                if(pcfl2 == pcfl1) {
 
-                 if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0))
-                 searching = 0;
+                 if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
+                   searching = 0;
                }
              }
 
@@ -765,22 +776,24 @@ void pCodeRegOptimizeRegUsage(int level)
 
   if(!register_optimization)
     return;
-
-  passes = 4;
+#define OPT_PASSES 4
+  passes = OPT_PASSES;
 
   do {
     saved = total_registers_saved;
 
     /* Identify registers used in one flow sequence */
-    OptimizeRegUsage(dynAllocRegs,level);
-    OptimizeRegUsage(dynStackRegs,level);
-    OptimizeRegUsage(dynDirectRegs,0);
+    OptimizeRegUsage(dynAllocRegs,level, (OPT_PASSES-passes));
+    OptimizeRegUsage(dynStackRegs,level, (OPT_PASSES-passes));
+    OptimizeRegUsage(dynDirectRegs,0, (OPT_PASSES-passes));
 
     if(total_registers_saved != saved)
-      fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n", (5-passes),total_registers_saved-saved,total_registers_saved);
+      fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n", 
+             (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
       
+    passes--;
 
-  } while( passes-- && (total_registers_saved != saved) );
+  } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
 
   if(total_registers_saved == t) 
     fprintf(stderr, "No registers saved on this pass\n");