See Changelog 1.204

[fw/sdcc] / src / SDCCloop.c

diff --git a/src/SDCCloop.c b/src/SDCCloop.c
index 2819c859dcbf689953057e3b814b12baf14dfbef..9bb74e335539b7f6c08b133d4e1bddf5f864729e 100644 (file)
--- a/src/SDCCloop.c
+++ b/src/SDCCloop.c
@@ -1,3 +1,9 @@
+//#define LIVERANGEHUNT
+#ifdef LIVERANGEHUNT
+  #define LRH(x) x
+#else
+  #define LRH(x)
+#endif
 /*-------------------------------------------------------------------------
 
   SDCCloop.c - source file for loop detection & optimizations
@@ -153,6 +159,7 @@ loopInsert (set ** regionSet, eBBlock * block)
 {
   if (!isinSet (*regionSet, block))
     {
+      LRH(printf ("loopInsert: %s\n", block->entryLabel->name));
       addSetHead (regionSet, block);
       STACK_PUSH (regionStack, block);
     }
@@ -229,7 +236,7 @@ DEFSETFUNC (addToExitsMarkDepth)
   V_ARG (set **, exits);
   V_ARG (int, depth);
   V_ARG (region *, lr);
-
+  LRH(printf ("addToExitsMarkDepth: %s %d\n", ebp->entryLabel->name, depth));
   /* mark the loop depth of this block */
   //if (!ebp->depth)
   if (ebp->depth<depth)
@@ -265,13 +272,36 @@ DEFSETFUNC (createLoop)
   eBBlock *block;
   int dfMin = count ,dfMax =0, i;
 
+  LRH(printf("CreateLoop\n"));
   /* make sure regionStack is empty */
   while (!STACK_EMPTY (regionStack))
     STACK_POP (regionStack);
 
   /* add the entryBlock */
   addSet (&aloop->regBlocks, ep->to);
+#ifdef LIVERANGEHUNT
+  // print regBlocks jwk
+  { 
+    eBBlock *ebp;
+    region *lp=aloop;
+    for (ebp=setFirstItem(lp->regBlocks); ebp; ebp=setNextItem(lp->regBlocks)) {
+      printf ("cl1 %s ", ebp->entryLabel->name);
+    }
+    printf (" %d\n", count);
+  }
+#endif
   loopInsert (&aloop->regBlocks, ep->from);
+#ifdef LIVERANGEHUNT
+  // print regBlocks jwk
+  { 
+    eBBlock *ebp;
+    region *lp=aloop;
+    for (ebp=setFirstItem(lp->regBlocks); ebp; ebp=setNextItem(lp->regBlocks)) {
+      printf ("cl2 %s ", ebp->entryLabel->name);
+    }
+    printf (" %d\n", count);
+  }
+#endif
 
   while (!STACK_EMPTY (regionStack))
     {
@@ -281,6 +311,18 @@ DEFSETFUNC (createLoop)
        applyToSet (block->predList, insertIntoLoop, &aloop->regBlocks);
     }
 
+#ifdef LIVERANGEHUNT
+  // print regBlocks jwk
+  { 
+    eBBlock *ebp;
+    region *lp=aloop;
+    for (ebp=setFirstItem(lp->regBlocks); ebp; ebp=setNextItem(lp->regBlocks)) {
+      printf ("cl3 %s ", ebp->entryLabel->name);
+    }
+    printf (" %d\n", count);
+  }
+#endif
+
   aloop->entry = ep->to;
   /* set max & min dfNum for loopRegion */
   for ( block = setFirstItem(aloop->regBlocks); block; 
@@ -292,13 +334,39 @@ DEFSETFUNC (createLoop)
   /* all blocks that have dfnumbers between dfMin & dfMax are also
      part of loop */
   for (i = 0 ; i < count ; i++) {
-      if (ebbs[i]->dfnum > dfMin && 
-         ebbs[i]->dfnum < dfMax &&
+    if (ebbs[i]->dfnum > dfMin && 
+          ebbs[i]->dfnum < dfMax &&
          !isinSet(aloop->regBlocks,ebbs[i])) {
-         if (!ebbs[i]->partOfLoop) ebbs[i]->partOfLoop = aloop;
+         if (!ebbs[i]->partOfLoop) {
+#if !defined(LIVERANGEHUNT)
+           ebbs[i]->partOfLoop = aloop;
+#else
+           loopInsert(&aloop->regBlocks,ebbs[i]);
+#endif
+         }
       }
   }
 
+#ifdef LIVERANGEHUNT
+  printf ("================\n");
+  printf (" loop with entry -- > ");
+  printEntryLabel (aloop->entry, ap);
+  printf ("\n");
+  printf (" loop body --> ");
+  applyToSet (aloop->regBlocks, printEntryLabel);
+  printf ("\n");
+  printf (" loop exits --> ");
+  applyToSet (aloop->exits, printEntryLabel);
+  printf ("\n");
+#endif
+
+  /* and if this is a conditional block, the other side of the IFX 
+     (if any, that could have a greater dfnum) is too */
+  {
+    // just a burp, but I'm getting close :)
+  }
+  
+
   /* now add it to the set */
   addSetHead (allRegion, aloop);
   return 0;
@@ -384,6 +452,9 @@ isOperandInvariant (operand * op, region * theLoop, set * lInvars)
               !IS_OP_VOLATILE (op) &&
               assignmentsToSym (theLoop->regBlocks, op) == 0)
        opin = 1;
+      LRH(if (opin && IS_SYMOP(op)) {
+       printf("isOperandInvariant: %s\n", OP_SYMBOL(op)->name);
+      });
     }
   else
     opin++;
@@ -887,10 +958,10 @@ basicInduction (region * loopReg, eBBlock ** ebbs, int count)
                              iCode *newic = newiCode ('=', NULL,
                                        operandFromOperand (IC_RIGHT (ic)));
                              IC_RESULT (newic) = operandFromOperand (IC_RESULT (ic));
-                             OP_DEFS_SET ((IC_RESULT (newic)),
-                               bitVectSetBit (OP_DEFS (IC_RESULT (newic)), newic->key));
-                             OP_USES_SET ((IC_RIGHT (newic)),
-                               bitVectSetBit (OP_USES (IC_RIGHT (newic)), newic->key));
+                             OP_DEFS(IC_RESULT (newic))=
+                               bitVectSetBit (OP_DEFS (IC_RESULT (newic)), newic->key);
+                             OP_USES(IC_RIGHT (newic))=
+                               bitVectSetBit (OP_USES (IC_RIGHT (newic)), newic->key);
                              /* and add it */
                              if (eblock->sch && eblock->sch->op == LABEL)
                                addiCodeToeBBlock (eblock, newic, eblock->sch->next);
@@ -1167,6 +1238,7 @@ createLoopRegions (eBBlock ** ebbs, int count)
   int maxDepth = 0;
   region *lp;
 
+  LRH(printf ("createLoopRegions: %p\n", ebbs));
   /* get all the back edges in the graph */
   if (!applyToSet (graphEdges, backEdges, &bEdges))
     return 0;                  /* found no loops */
@@ -1174,6 +1246,18 @@ createLoopRegions (eBBlock ** ebbs, int count)
   /* for each of these back edges get the blocks that */
   /* constitute the loops                             */
   applyToSet (bEdges, createLoop, &allRegion, ebbs,count);
+#ifdef LIVERANGEHUNT
+  // print regBlocks
+  { 
+    eBBlock *ebp;
+    lp=setFirstItem(allRegion);
+    printf ("createLoopRegions: ");
+    for (ebp=setFirstItem(lp->regBlocks); ebp; ebp=setNextItem(lp->regBlocks)) {
+      printf ("%s ", ebp->entryLabel->name);
+    }
+    printf (" %d\n", count);
+  }
+#endif
 
   /* now we will create regions from these loops               */
   /* loops with the same entry points are considered to be the */
@@ -1187,6 +1271,7 @@ createLoopRegions (eBBlock ** ebbs, int count)
 
   applyToSet (allRegion, mergeInnerLoops, allRegion, &maxDepth);
   maxDepth++;
+
   /* now create all the exits .. also */
   /* create an ordered set of loops   */
   /* i.e. we process loops in the inner to outer order */