X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FBranchFolding.cpp;h=d4b1e90fd54c8f530ba483edca7c8265f69a3800;hb=524825b626e8cf9b323a9dd985dcf0f74a99c46e;hp=71fac0b8eb766b216bf945110ac9fe6c67696d17;hpb=1a90a5aebe3488dc3feaab60ba16bed1659ba27b;p=oota-llvm.git

diff --git a/lib/CodeGen/BranchFolding.cpp b/lib/CodeGen/BranchFolding.cpp
index 71fac0b8eb7..d4b1e90fd54 100644
--- a/lib/CodeGen/BranchFolding.cpp
+++ b/lib/CodeGen/BranchFolding.cpp
@@ -46,7 +46,7 @@ namespace {
 
   struct BranchFolder : public MachineFunctionPass {
     static char ID;
-    BranchFolder(bool defaultEnableTailMerge) : 
+    explicit BranchFolder(bool defaultEnableTailMerge) : 
         MachineFunctionPass((intptr_t)&ID) {
           switch (FlagEnableTailMerge) {
           case cl::BOU_UNSET: EnableTailMerge = defaultEnableTailMerge; break;
@@ -87,12 +87,6 @@ namespace {
   char BranchFolder::ID = 0;
 }
 
-static bool CorrectExtraCFGEdges(MachineBasicBlock &MBB, 
-                                 MachineBasicBlock *DestA,
-                                 MachineBasicBlock *DestB,
-                                 bool isCond, 
-                                 MachineFunction::iterator FallThru);
-
 FunctionPass *llvm::createBranchFoldingPass(bool DefaultEnableTailMerge) { 
       return new BranchFolder(DefaultEnableTailMerge); }
 
@@ -133,8 +127,7 @@ bool BranchFolder::runOnMachineFunction(MachineFunction &MF) {
     MachineBasicBlock *MBB = I, *TBB = 0, *FBB = 0;
     std::vector<MachineOperand> Cond;
     if (!TII->AnalyzeBranch(*MBB, TBB, FBB, Cond))
-      EverMadeChange |= CorrectExtraCFGEdges(*MBB, TBB, FBB, 
-                        !Cond.empty(), next(I));
+      EverMadeChange |= MBB->CorrectExtraCFGEdges(TBB, FBB, !Cond.empty());
   }
 
   RegInfo = MF.getTarget().getRegisterInfo();
@@ -278,7 +271,13 @@ static unsigned ComputeCommonTailLength(MachineBasicBlock *MBB1,
   unsigned TailLen = 0;
   while (I1 != MBB1->begin() && I2 != MBB2->begin()) {
     --I1; --I2;
-    if (!I1->isIdenticalTo(I2)) {
+    if (!I1->isIdenticalTo(I2) || 
+        // FIXME: This check is dubious. It's used to get around a problem where
+        // people incorrectly expect inline asm directives to remain in the same
+        // relative order. This is untenable because normal compiler
+        // optimizations (like this one) may reorder and/or merge these
+        // directives.
+        I1->getOpcode() == TargetInstrInfo::INLINEASM) {
       ++I1; ++I2;
       break;
     }
@@ -436,8 +435,14 @@ static bool MergeCompare(const std::pair<unsigned,MachineBasicBlock*> &p,
       return true;
     else if (p.second->getNumber() > q.second->getNumber())
       return false;
-    else
+    else {
+      // _GLIBCXX_DEBUG checks strict weak ordering, which involves comparing
+      // an object with itself.
+#ifndef _GLIBCXX_DEBUG
       assert(0 && "Predecessor appears twice");
+#endif
+      return(false);
+    }
 }
 
 // See if any of the blocks in MergePotentials (which all have a common single
@@ -702,68 +707,6 @@ bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
 }
 
 
-/// CorrectExtraCFGEdges - Various pieces of code can cause excess edges in the
-/// CFG to be inserted.  If we have proven that MBB can only branch to DestA and
-/// DestB, remove any other MBB successors from the CFG.  DestA and DestB can
-/// be null.
-/// Besides DestA and DestB, retain other edges leading to LandingPads (currently
-/// there can be only one; we don't check or require that here).
-/// Note it is possible that DestA and/or DestB are LandingPads.
-static bool CorrectExtraCFGEdges(MachineBasicBlock &MBB, 
-                                 MachineBasicBlock *DestA,
-                                 MachineBasicBlock *DestB,
-                                 bool isCond, 
-                                 MachineFunction::iterator FallThru) {
-  bool MadeChange = false;
-  bool AddedFallThrough = false;
-  
-  // If this block ends with a conditional branch that falls through to its
-  // successor, set DestB as the successor.
-  if (isCond) {
-    if (DestB == 0 && FallThru != MBB.getParent()->end()) {
-      DestB = FallThru;
-      AddedFallThrough = true;
-    }
-  } else {
-    // If this is an unconditional branch with no explicit dest, it must just be
-    // a fallthrough into DestB.
-    if (DestA == 0 && FallThru != MBB.getParent()->end()) {
-      DestA = FallThru;
-      AddedFallThrough = true;
-    }
-  }
-  
-  MachineBasicBlock::succ_iterator SI = MBB.succ_begin();
-  MachineBasicBlock *OrigDestA = DestA, *OrigDestB = DestB;
-  while (SI != MBB.succ_end()) {
-    if (*SI == DestA && DestA == DestB) {
-      DestA = DestB = 0;
-      ++SI;
-    } else if (*SI == DestA) {
-      DestA = 0;
-      ++SI;
-    } else if (*SI == DestB) {
-      DestB = 0;
-      ++SI;
-    } else if ((*SI)->isLandingPad() && 
-               *SI!=OrigDestA && *SI!=OrigDestB) {
-      ++SI;
-    } else {
-      // Otherwise, this is a superfluous edge, remove it.
-      MBB.removeSuccessor(SI);
-      MadeChange = true;
-    }
-  }
-  if (!AddedFallThrough) {
-    assert(DestA == 0 && DestB == 0 &&
-           "MachineCFG is missing edges!");
-  } else if (isCond) {
-    assert(DestA == 0 && "MachineCFG is missing edges!");
-  }
-  return MadeChange;
-}
-
-
 /// CanFallThrough - Return true if the specified block (with the specified
 /// branch condition) can implicitly transfer control to the block after it by
 /// falling off the end of it.  This should return false if it can reach the
@@ -880,8 +823,8 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
     TII->AnalyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond);
   if (!PriorUnAnalyzable) {
     // If the CFG for the prior block has extra edges, remove them.
-    MadeChange |= CorrectExtraCFGEdges(PrevBB, PriorTBB, PriorFBB,
-                                       !PriorCond.empty(), MBB);
+    MadeChange |= PrevBB.CorrectExtraCFGEdges(PriorTBB, PriorFBB,
+                                              !PriorCond.empty());
     
     // If the previous branch is conditional and both conditions go to the same
     // destination, remove the branch, replacing it with an unconditional one or
@@ -993,9 +936,7 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
   bool CurUnAnalyzable = TII->AnalyzeBranch(*MBB, CurTBB, CurFBB, CurCond);
   if (!CurUnAnalyzable) {
     // If the CFG for the prior block has extra edges, remove them.
-    MadeChange |= CorrectExtraCFGEdges(*MBB, CurTBB, CurFBB,
-                                       !CurCond.empty(),
-                                       ++MachineFunction::iterator(MBB));
+    MadeChange |= MBB->CorrectExtraCFGEdges(CurTBB, CurFBB, !CurCond.empty());
 
     // If this is a two-way branch, and the FBB branches to this block, reverse 
     // the condition so the single-basic-block loop is faster.  Instead of:
@@ -1049,17 +990,18 @@ void BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
           }
 
           // Iterate through all the predecessors, revectoring each in-turn.
-          MachineBasicBlock::pred_iterator PI = MBB->pred_begin();
+          size_t PI = 0;
           bool DidChange = false;
           bool HasBranchToSelf = false;
-          while (PI != MBB->pred_end()) {
-            if (*PI == MBB) {
+          while(PI != MBB->pred_size()) {
+            MachineBasicBlock *PMBB = *(MBB->pred_begin() + PI);
+            if (PMBB == MBB) {
               // If this block has an uncond branch to itself, leave it.
               ++PI;
               HasBranchToSelf = true;
             } else {
               DidChange = true;
-              (*PI)->ReplaceUsesOfBlockWith(MBB, CurTBB);
+              PMBB->ReplaceUsesOfBlockWith(MBB, CurTBB);
             }
           }