factor some logic out into a helper function, allow remat of loads from constant

[oota-llvm.git] / lib / CodeGen / CodePlacementOpt.cpp

diff --git a/lib/CodeGen/CodePlacementOpt.cpp b/lib/CodeGen/CodePlacementOpt.cpp
index d297d5aceb6513397a240ec5f6f3ed04002c1190..383098e11efdc3d0b470b11803357c5abb208429 100644 (file)
--- a/lib/CodeGen/CodePlacementOpt.cpp
+++ b/lib/CodeGen/CodePlacementOpt.cpp
@@ -19,17 +19,11 @@
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/Statistic.h"
 using namespace llvm;
 
-static cl::opt<bool>
-OptLoopBBPlacement("opt-loop-bb-placement",
-                   cl::init(false), cl::Hidden,
-                   cl::desc("Optimize block placements in loops"));
-
 STATISTIC(NumHeaderAligned, "Number of loop header aligned");
 STATISTIC(NumIntraElim,     "Number of intra loop branches eliminated");
 STATISTIC(NumIntraMoved,    "Number of intra loop branches moved");
@@ -68,6 +62,8 @@ namespace {
 
   private:
     bool OptimizeIntraLoopEdges();
+    bool HeaderShouldBeAligned(MachineBasicBlock *MBB, MachineLoop *L,
+                               SmallPtrSet<MachineBasicBlock*, 4> &DoNotAlign);
     bool AlignLoops(MachineFunction &MF);
   };
 
@@ -108,7 +104,7 @@ FunctionPass *llvm::createCodePlacementOptPass() {
 ///       jcc <cond> C, [exit]
 ///
 bool CodePlacementOpt::OptimizeIntraLoopEdges() {
-  if (!OptLoopBBPlacement)
+  if (!TLI->shouldOptimizeCodePlacement())
     return false;
 
   bool Changed = false;
@@ -138,6 +134,7 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
       TII->RemoveBranch(*MBB);
       ChangedMBBs.insert(MBB);
       ++NumIntraElim;
+      Changed = true;
       continue;
     }
 
@@ -164,10 +161,10 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
         // A fallthrough.
         FtMBB = PredMBB;
         MachineLoop *PL = MLI->getLoopFor(PredMBB);
-        if (PL && (PL == L || PL->getLoopDepth() >= L->getLoopDepth())) {
+        if (PL && (PL == L || PL->getLoopDepth() >= L->getLoopDepth()))
           OkToMove = false;
-          break;
-        }
+
+        break;
       }
     }
 
@@ -203,7 +200,7 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
       if (SuccMBB->isLayoutSuccessor(SSMBB))
         // This will become a jmp.
         ++Cost;
-      else if (MBB->isLayoutSuccessor(SSMBB))
+      else if (MBB->isLayoutSuccessor(SSMBB)) {
         // One of the successor will become the new fallthrough.
         if (SSMBB == FBB) {
           FBB = 0;
@@ -211,11 +208,13 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
         } else if (!FBB && SSMBB == TBB && Cond.empty()) {
           TBB = 0;
           --Cost;
-        } else if (!TII->ReverseBranchCondition(Cond)) {
+        } else if (!Cond.empty() && !TII->ReverseBranchCondition(Cond)) {
+          assert(SSMBB == TBB);
           TBB = FBB;
           FBB = 0;
           --Cost;
         }
+      }
     }
     if (Cost)
       continue;
@@ -233,6 +232,7 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
       TII->InsertBranch(*FtMBB, FtTBB, FtFBB, FtCond);
       ChangedMBBs.insert(FtMBB);
     }
+    Changed = true;
 
     // If BB is the loop latch, we may have a new loop headr.
     if (MBB == L->getLoopLatch()) {
@@ -247,6 +247,43 @@ bool CodePlacementOpt::OptimizeIntraLoopEdges() {
   return Changed;
 }
 
+/// HeaderShouldBeAligned - Return true if the specified loop header block
+/// should be aligned. For now, we will not align it if all the predcessors
+/// (i.e. loop back edges) are laid out above the header. FIXME: Do not
+/// align small loops.
+bool
+CodePlacementOpt::HeaderShouldBeAligned(MachineBasicBlock *MBB, MachineLoop *L,
+                               SmallPtrSet<MachineBasicBlock*, 4> &DoNotAlign) {
+  if (DoNotAlign.count(MBB))
+    return false;
+
+  bool BackEdgeBelow = false;
+  for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
+         PE = MBB->pred_end(); PI != PE; ++PI) {
+    MachineBasicBlock *PredMBB = *PI;
+    if (PredMBB == MBB || PredMBB->getNumber() > MBB->getNumber()) {
+      BackEdgeBelow = true;
+      break;
+    }
+  }
+
+  if (!BackEdgeBelow)
+    return false;
+
+  // Ok, we are going to align this loop header. If it's an inner loop,
+  // do not align its outer loop.
+  MachineBasicBlock *PreHeader = L->getLoopPreheader();
+  if (PreHeader) {
+    MachineLoop *L = MLI->getLoopFor(PreHeader);
+    if (L) {
+      MachineBasicBlock *HeaderBlock = L->getHeader();
+      HeaderBlock->setAlignment(0);
+      DoNotAlign.insert(HeaderBlock);
+    }
+  }
+  return true;
+}
+
 /// AlignLoops - Align loop headers to target preferred alignments.
 ///
 bool CodePlacementOpt::AlignLoops(MachineFunction &MF) {
@@ -262,12 +299,16 @@ bool CodePlacementOpt::AlignLoops(MachineFunction &MF) {
   MF.RenumberBlocks();
 
   bool Changed = false;
+  SmallPtrSet<MachineBasicBlock*, 4> DoNotAlign;
   for (unsigned i = 0, e = LoopHeaders.size(); i != e; ++i) {
     MachineBasicBlock *HeaderMBB = LoopHeaders[i];
     MachineBasicBlock *PredMBB = prior(MachineFunction::iterator(HeaderMBB));
-    if (MLI->getLoopFor(HeaderMBB) != MLI->getLoopFor(PredMBB)) {
+    MachineLoop *L = MLI->getLoopFor(HeaderMBB);
+    if (L == MLI->getLoopFor(PredMBB))
       // If previously BB is in the same loop, don't align this BB. We want
       // to prevent adding noop's inside a loop.
+      continue;
+    if (HeaderShouldBeAligned(HeaderMBB, L, DoNotAlign)) {
       HeaderMBB->setAlignment(Align);
       Changed = true;
       ++NumHeaderAligned;