[JumpThread] Do not break loop structures when splitting blocks

[junbuml]

Summary

This change prevent SimplifyPartiallyRedundantLoad() from breaking a loop structure if splitting predecessors turn a loop into an irreducible loop.

[haicheng]

include/llvm/Transforms/Scalar/JumpThreading.h

67

Please add a comment to explain how the map works.

[junbuml]

Kindly ping. Please let me know any comment.

[junbuml]

Kindly ping. Please let me know any comment.

include/llvm/Transforms/Scalar/JumpThreading.h

 /// revectored to the false side of the second if.
 ///
 class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
   TargetLibraryInfo *TLI;
   LazyValueInfo *LVI;
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
   bool HasProfileData = false;
+
 #ifdef NDEBUG
-  SmallPtrSet<const BasicBlock *, 16> LoopHeaders;
+  DenseMap<const BasicBlock *, SmallPtrSet<const BasicBlock *, 16>> LoopHeaders;
 #else
-  SmallSet<AssertingVH<const BasicBlock>, 16> LoopHeaders;
+  DenseMap<AssertingVH<const BasicBlock>, SmallPtrSet<const BasicBlock *, 16>>
+      LoopHeaders;
 #endif
+
   DenseSet<std::pair<Value *, BasicBlock *>> RecursionSet;
 
   unsigned BBDupThreshold;
 
   // RAII helper for updating the recursion stack.
   struct RecursionSetRemover {
     DenseSet<std::pair<Value *, BasicBlock *>> &TheSet;
     std::pair<Value *, BasicBlock *> ThePair;

lib/Transforms/Scalar/JumpThreading.cpp

 /// enough to track all of these properties and keep it up-to-date as the CFG
 /// mutates, so we don't allow any of these transformations.
 ///
 void JumpThreadingPass::FindLoopHeaders(Function &F) {
   SmallVector<std::pair<const BasicBlock*,const BasicBlock*>, 32> Edges;
   FindFunctionBackedges(F, Edges);
 
   for (const auto &Edge : Edges)
-    LoopHeaders.insert(Edge.second);
+    LoopHeaders[Edge.second].insert(Edge.first);
 }
 
 /// getKnownConstant - Helper method to determine if we can thread over a
 /// terminator with the given value as its condition, and if so what value to
 /// use for that. What kind of value this is depends on whether we want an
 /// integer or a block address, but an undef is always accepted.
 /// Returns null if Val is null or not an appropriate constant.
 static Constant *getKnownConstant(Value *Val, ConstantPreference Preference) {
bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) {
   // successor, merge the blocks.  This encourages recursive jump threading
   // because now the condition in this block can be threaded through
   // predecessors of our predecessor block.
   if (BasicBlock *SinglePred = BB->getSinglePredecessor()) {
     const TerminatorInst *TI = SinglePred->getTerminator();
     if (!TI->isExceptional() && TI->getNumSuccessors() == 1 &&
         SinglePred != BB && !hasAddressTakenAndUsed(BB)) {
       // If SinglePred was a loop header, BB becomes one.
-      if (LoopHeaders.erase(SinglePred))
-        LoopHeaders.insert(BB);
+      if (LoopHeaders.count(SinglePred)) {
+        LoopHeaders[BB] = LoopHeaders[SinglePred];
+        LoopHeaders.erase(SinglePred);
+      }
 
       LVI->eraseBlock(SinglePred);
       MergeBasicBlockIntoOnlyPred(BB);
 
       return true;
     }
   }
 
for (BasicBlock *P : predecessors(LoadBB)) {
       if (isa<IndirectBrInst>(P->getTerminator()))
         return false;
 
       if (!AvailablePredSet.count(P))
         PredsToSplit.push_back(P);
     }
 
     // Split them out to their own block.
-    UnavailablePred = SplitBlockPreds(LoadBB, PredsToSplit, "thread-pre-split");
+    if (!(UnavailablePred = SplitBlockPreds(LoadBB, PredsToSplit, "thread-pre-split")))
+      return false;
   }
 
   // If the value isn't available in all predecessors, then there will be
   // exactly one where it isn't available.  Insert a load on that edge and add
   // it to the AvailablePreds list.
   if (UnavailablePred) {
     assert(UnavailablePred->getTerminator()->getNumSuccessors() == 1 &&
            "Can't handle critical edge here!");

 }
 
 /// Create a new basic block that will be the predecessor of BB and successor of
 /// all blocks in Preds. When profile data is available, update the frequency of
 /// this new block.
 BasicBlock *JumpThreadingPass::SplitBlockPreds(BasicBlock *BB,
                                                ArrayRef<BasicBlock *> Preds,
                                                const char *Suffix) {
+  bool HasBackedge = false;
+  bool HasNonBackedge = false;
+  if (LoopHeaders.count(BB)) {
+    for (auto PredBB : Preds) {
+      if (LoopHeaders[BB].count(PredBB))
+        HasBackedge = true;
+      else
+        HasNonBackedge = true;
+      if (HasNonBackedge && HasBackedge)
+        return nullptr;
+    }
+  }
+
   // Collect the frequencies of all predecessors of BB, which will be used to
   // update the edge weight on BB->SuccBB.
   BlockFrequency PredBBFreq(0);
   if (HasProfileData)
     for (auto Pred : Preds)
       PredBBFreq += BFI->getBlockFreq(Pred) * BPI->getEdgeProbability(Pred, BB);
 
   BasicBlock *PredBB = SplitBlockPredecessors(BB, Preds, Suffix);

test/Transforms/JumpThreading/thread-loads.ll

 cond3:
   call void @fn3(i64 %l2)
   br label %end
 
 end:
   ret i32 0
 }
 
+; This tests jump threading do not turn a proper loop structures into an
+; irreducible loop by SimplifyPartiallyRedundantLoad(). Note this test contain
+; unswithch opportunity in %while.cond2, so we want to keep %while.cond2 as a
+; loop header.
+; CHECK-LABEL: @fn_keep_loop
+; CHECK-NOT: while.cond2thread-pre-split  
+define i32 @fn_keep_loop(i1 %c0, i1 %c1, i64* %ptr0, i64* %ptr1) {
+entry:
+  br i1 %c0, label %while.cond, label %sw.epilog
+
+while.cond:                                       ; preds = %land.rhs, %entry
+  %magicptr = load i64, i64* %ptr1, align 8
+  %c = icmp eq i64 %magicptr, 0
+  br i1 %c, label %while.cond2, label %land.rhs
+
+land.rhs:                                         ; preds = %while.cond
+  %arrayidx = getelementptr inbounds i64, i64* %ptr0, i64 1
+  %l2 = load i64, i64* %arrayidx, align 4
+  %tobool1 = icmp eq i64 %l2, 0
+  br i1 %tobool1, label %while.cond2, label %while.cond
+
+while.cond2:
+  %l3 = load i64, i64* %ptr1, align 8
+  br i1 %c1, label %if.then, label %if.end
+
+if.then:
+  call void @fn3(i64 %l3)
+  br label %if.end
+
+if.end:
+  %c2 = icmp eq i64 %l3,  0
+  br i1 %c2, label %sw.epilog, label %while.body4
+
+while.body4:                                      ; preds = %while.cond2
+  call void @fn2(i64 %l3)             
+  br label %while.cond2
+
+sw.epilog:                                        ; preds = %while.cond2, %entry
+  ret i32 undef
+}
+
 declare void @fn2(i64)
 declare void @fn3(i64)
 
 
 !0 = !{!3, !3, i64 0}
 !1 = !{!"omnipotent char", !2}
 !2 = !{!"Simple C/C++ TBAA"}
 !3 = !{!"int", !1}
 !4 = !{ i32 0, i32 1 }
 !5 = !{ i32 8, i32 10 }
 !6 = !{!6}
 !7 = !{!7, !6}
 !8 = !{!8, !6}
 !9 = !{!7}
 !10 = !{!8}