[NFC][LoopFusion] Use isControlFlowEquivalent() from CodeMoverUtils.

[Meinersbur]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

42

[suggestion] Add a shortcut:

if (&BB0 == &BB1)
  return true;

[Whitney]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

42

Done the change when commit.

[kbarton]

LGTM.

[Whitney]

landed

[Meinersbur]

For reference: landed as aaf7f05a96e6c21b7a6d1ad9e73fb7ab5eee7d83

Phabricator didn't recognize it because the Differential Revision: line wasn't its own paragraph.

llvm/include/llvm/Transforms/Utils/CodeMoverUtils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
 #define LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H
 
 namespace llvm {
 
+class BasicBlock;
 class DependenceInfo;
 class DominatorTree;
 class Instruction;
 class PostDominatorTree;
 
 /// Return true if \p I0 and \p I1 are control flow equivalent.
 /// Two instructions are control flow equivalent if when one executes,
 /// the other is guaranteed to execute. This is determined using dominators
 /// and post-dominators: if A dominates B and B post-dominates A then A and B
 /// are control-flow equivalent.
 bool isControlFlowEquivalent(const Instruction &I0, const Instruction &I1,
                              const DominatorTree &DT,
                              const PostDominatorTree &PDT);
 
+/// Return true if \p BB0 and \p BB1 are control flow equivalent.
+/// Two basic blocks are control flow equivalent if when one executes, the other
+/// is guaranteed to execute. This is determined using dominators and
+/// post-dominators: if A dominates B and B post-dominates A then A and B are
+/// control-flow equivalent.
+bool isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
+                             const DominatorTree &DT,
+                             const PostDominatorTree &PDT);
+
 /// Return true if \p I can be safely moved before \p InsertPoint.
 bool isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                         const DominatorTree &DT, const PostDominatorTree &PDT,
                         DependenceInfo &DI);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_CODEMOVERUTILS_H

llvm/lib/Transforms/Scalar/LoopFuse.cpp

 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Transforms/Utils/CodeMoverUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-fusion"
 
 STATISTIC(FuseCounter, "Loops fused");
 STATISTIC(NumFusionCandidates, "Number of candidates for loop fusion");
 STATISTIC(InvalidPreheader, "Loop has invalid preheader");
private:
   /// Two fusion candidates are control flow equivalent if when one executes,
   /// the other is guaranteed to execute. This is determined using dominators
   /// and post-dominators: if A dominates B and B post-dominates A then A and B
   /// are control-flow equivalent.
   bool isControlFlowEquivalent(const FusionCandidate &FC0,
                                const FusionCandidate &FC1) const {
     assert(FC0.Preheader && FC1.Preheader && "Expecting valid preheaders");
 
-    BasicBlock *FC0EntryBlock = FC0.getEntryBlock();
-    BasicBlock *FC1EntryBlock = FC1.getEntryBlock();
-
-    if (DT.dominates(FC0EntryBlock, FC1EntryBlock))
-      return PDT.dominates(FC1EntryBlock, FC0EntryBlock);
-
-    if (DT.dominates(FC1EntryBlock, FC0EntryBlock))
-      return PDT.dominates(FC0EntryBlock, FC1EntryBlock);
-
-    return false;
+    return ::isControlFlowEquivalent(*FC0.getEntryBlock(), *FC1.getEntryBlock(),
+                                     DT, PDT);
   }
 
   /// Iterate over all loops in the given loop set and identify the loops that
   /// are eligible for fusion. Place all eligible fusion candidates into Control
   /// Flow Equivalent sets, sorted by dominance.
   void collectFusionCandidates(const LoopVector &LV) {
     for (Loop *L : LV) {
       FusionCandidate CurrCand(L, &DT, &PDT, ORE);

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

 STATISTIC(NotControlFlowEquivalent,
           "Instructions are not control flow equivalent");
 STATISTIC(NotMovedPHINode, "Movement of PHINodes are not supported");
 STATISTIC(NotMovedTerminator, "Movement of Terminator are not supported");
 
 bool llvm::isControlFlowEquivalent(const Instruction &I0, const Instruction &I1,
                                    const DominatorTree &DT,
                                    const PostDominatorTree &PDT) {
-  const BasicBlock *BB0 = I0.getParent();
-  const BasicBlock *BB1 = I1.getParent();
-  return ((DT.dominates(BB0, BB1) && PDT.dominates(BB1, BB0)) ||
-          (PDT.dominates(BB0, BB1) && DT.dominates(BB1, BB0)));
+  return isControlFlowEquivalent(*I0.getParent(), *I1.getParent(), DT, PDT);
+}
+
+bool llvm::isControlFlowEquivalent(const BasicBlock &BB0, const BasicBlock &BB1,
+                                   const DominatorTree &DT,
+                                   const PostDominatorTree &PDT) {
+  return ((DT.dominates(&BB0, &BB1) && PDT.dominates(&BB1, &BB0)) ||
+          (PDT.dominates(&BB0, &BB1) && DT.dominates(&BB1, &BB0)));
 }
 
 static bool reportInvalidCandidate(const Instruction &I,
                                    llvm::Statistic &Stat) {
   ++Stat;
   LLVM_DEBUG(dbgs() << "Unable to move instruction: " << I << ". "
                     << Stat.getDesc());
   return false;