One more place to skip debug info.

[oota-llvm.git] / lib / Transforms / Scalar / CodeGenPrepare.cpp

diff --git a/lib/Transforms/Scalar/CodeGenPrepare.cpp b/lib/Transforms/Scalar/CodeGenPrepare.cpp
index 1f3a13cc9cec2193da4c804ba484878deefed8f3..4eb49e9a95cd4f772166b54c547838f5c14b8a6c 100644 (file)
--- a/lib/Transforms/Scalar/CodeGenPrepare.cpp
+++ b/lib/Transforms/Scalar/CodeGenPrepare.cpp
@@ -20,6 +20,7 @@
 #include "llvm/Function.h"
 #include "llvm/InlineAsm.h"
 #include "llvm/Instructions.h"
+#include "llvm/IntrinsicInst.h"
 #include "llvm/Pass.h"
 #include "llvm/Target/TargetAsmInfo.h"
 #include "llvm/Target/TargetData.h"
@@ -144,10 +145,11 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
   return EverMadeChange;
 }
 
-/// EliminateMostlyEmptyBlocks - eliminate blocks that contain only PHI nodes
-/// and an unconditional branch.  Passes before isel (e.g. LSR/loopsimplify)
-/// often split edges in ways that are non-optimal for isel.  Start by
-/// eliminating these blocks so we can split them the way we want them.
+/// EliminateMostlyEmptyBlocks - eliminate blocks that contain only PHI nodes,
+/// debug info directives, and an unconditional branch.  Passes before isel
+/// (e.g. LSR/loopsimplify) often split edges in ways that are non-optimal for
+/// isel.  Start by eliminating these blocks so we can split them the way we
+/// want them.
 bool CodeGenPrepare::EliminateMostlyEmptyBlocks(Function &F) {
   bool MadeChange = false;
   // Note that this intentionally skips the entry block.
@@ -159,12 +161,18 @@ bool CodeGenPrepare::EliminateMostlyEmptyBlocks(Function &F) {
     if (!BI || !BI->isUnconditional())
       continue;
 
-    // If the instruction before the branch isn't a phi node, then other stuff
-    // is happening here.
+    // If the instruction before the branch (skipping debug info) isn't a phi
+    // node, then other stuff is happening here.
     BasicBlock::iterator BBI = BI;
     if (BBI != BB->begin()) {
       --BBI;
-      if (!isa<PHINode>(BBI)) continue;
+      while (isa<DbgInfoIntrinsic>(BBI)) {
+        if (BBI == BB->begin())
+          break;
+        --BBI;
+      }
+      if (!isa<DbgInfoIntrinsic>(BBI) && !isa<PHINode>(BBI))
+        continue;
     }
 
     // Do not break infinite loops.
@@ -327,6 +335,12 @@ static void SplitEdgeNicely(TerminatorInst *TI, unsigned SuccNum,
   assert(isa<PHINode>(Dest->begin()) &&
          "This should only be called if Dest has a PHI!");
 
+  // Do not split edges to EH landing pads.
+  if (InvokeInst *Invoke = dyn_cast<InvokeInst>(TI)) {
+    if (Invoke->getSuccessor(1) == Dest)
+      return;
+  }
+
   // As a hack, never split backedges of loops.  Even though the copy for any
   // PHIs inserted on the backedge would be dead for exits from the loop, we
   // assume that the cost of *splitting* the backedge would be too high.
@@ -344,15 +358,20 @@ static void SplitEdgeNicely(TerminatorInst *TI, unsigned SuccNum,
       BasicBlock *Pred = *PI;
       // To be usable, the pred has to end with an uncond branch to the dest.
       BranchInst *PredBr = dyn_cast<BranchInst>(Pred->getTerminator());
-      if (!PredBr || !PredBr->isUnconditional() ||
-          // Must be empty other than the branch.
-          &Pred->front() != PredBr ||
-          // Cannot be the entry block; its label does not get emitted.
-          Pred == &(Dest->getParent()->getEntryBlock()))
+      if (!PredBr || !PredBr->isUnconditional())
+        continue;
+      // Must be empty other than the branch and debug info.
+      BasicBlock::iterator I = Pred->begin();
+      while (isa<DbgInfoIntrinsic>(I))
+        I++;
+      if (dyn_cast<Instruction>(I) != PredBr)
+        continue;
+      // Cannot be the entry block; its label does not get emitted.
+      if (Pred == &(Dest->getParent()->getEntryBlock()))
         continue;
 
       // Finally, since we know that Dest has phi nodes in it, we have to make
-      // sure that jumping to Pred will have the same affect as going to Dest in
+      // sure that jumping to Pred will have the same effect as going to Dest in
       // terms of PHI values.
       PHINode *PN;
       unsigned PHINo = 0;