[CodeMoverUtils]Add option to skip control flow equivalence checks when sure

[RithikSharma]

Summary

This patch adds option to skip control flow equivalence checks, there are passes which has code-motion in control flow equivalent blocks and due to unavailability of PDT, it doesn't allow us to use CodeMoverUtils in it. The code-motion client can pass true for skipping control flow equivalence and can also pass PDT as an argument instead of true/false if it is available.

[bmahjour]

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

313

PDT could be nullptr and *PDT could cause a segfault.

We don't need yet another version of isSafeToMoveBefore. Can you add bool skipControlFlowEquivalence to the existing isSafeToMoveBefore functions? If the boolean flag is on, then PDT is used, otherwise PDT will be unused. If a nullptr PDT is provided and the flag is on, then it returns unsafe to move.

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

 /// Two basic blocks are control flow equivalent if when one executes, the other
 /// is guaranteed to execute.
 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,
+                        DominatorTree &DT, bool skipControlFlowEquivalence,
+                        DependenceInfo *DI = nullptr);
+
+/// Return true if \p I can be safely moved before \p InsertPoint.
+bool isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                         DominatorTree &DT,
                         const PostDominatorTree *PDT = nullptr,
                         DependenceInfo *DI = nullptr);
 
 /// Return true if all instructions (except the terminator) in \p BB can be
 /// safely moved before \p InsertPoint.
 bool isSafeToMoveBefore(BasicBlock &BB, Instruction &InsertPoint,
                         DominatorTree &DT,

llvm/lib/Transforms/Utils/CodeMoverUtils.cpp

if (CurInst == &EndInst)
       continue;
 
     if (!InBetweenInsts.insert(CurInst).second)
       continue;
 
     getNextInsts(*CurInst, WorkList);
   }
 }
-
 bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
                               DominatorTree &DT, const PostDominatorTree *PDT,
                               DependenceInfo *DI) {
-  // Skip tests when we don't have PDT or DI
-  if (!PDT || !DI)
+  // TODO remove this limitation.
+  if (!isControlFlowEquivalent(I, InsertPoint, DT, *PDT))
+    return reportInvalidCandidate(I, NotControlFlowEquivalent);
+  return isSafeToMoveBefore(I, InsertPoint, DT, true, DI);
+}
+
+bool llvm::isSafeToMoveBefore(Instruction &I, Instruction &InsertPoint,
+                              DominatorTree &DT,
+                              bool skipControlFlowEquivalence,
+                              DependenceInfo *DI) {
+  // Skip tests when we don't have DI
+  if (!skipControlFlowEquivalence || !DI)
     return false;
 
   // Cannot move itself before itself.
   if (&I == &InsertPoint)
     return false;
 
   // Not moved.
   if (I.getNextNode() == &InsertPoint)
     return true;
 
   if (isa<PHINode>(I) || isa<PHINode>(InsertPoint))
     return reportInvalidCandidate(I, NotMovedPHINode);
 
   if (I.isTerminator())
     return reportInvalidCandidate(I, NotMovedTerminator);
 
-  // TODO remove this limitation.
-  if (!isControlFlowEquivalent(I, InsertPoint, DT, *PDT))
-    return reportInvalidCandidate(I, NotControlFlowEquivalent);
-
   if (!DT.dominates(&InsertPoint, &I))
     for (const Use &U : I.uses())
       if (auto *UserInst = dyn_cast<Instruction>(U.getUser()))
         if (UserInst != &InsertPoint && !DT.dominates(&InsertPoint, U))
           return false;
   if (!DT.dominates(&I, &InsertPoint))
     for (const Value *Op : I.operands())
       if (auto *OpInst = dyn_cast<Instruction>(Op))