[SimplifyCFG] Optionally update LI in sinkCommonCodeFromPredecessors.

[fhahn]

Summary

LI can easily preserved by sinkCommonCodeFromPredecessors by passing
through LI to SplitBlockPredecessors.

[lebedev.ri]

LG, thanks.

[RKSimon]

LGTM

llvm/include/llvm/Transforms/Utils/Local.h

60

sorting

[fhahn]

There are no plans to use this as utility would require updating loop info. Abandoning for now.

llvm/include/llvm/Transforms/Utils/Local.h

 class InvokeInst;
 class LoadInst;
 class MDNode;
 class MemorySSAUpdater;
 class PHINode;
 class StoreInst;
 class TargetLibraryInfo;
 class TargetTransformInfo;
+class LoopInfo;
 
 //===----------------------------------------------------------------------===//
 //  Local constant propagation.
 //
 
 /// If a terminator instruction is predicated on a constant value, convert it
 /// into an unconditional branch to the constant destination.
 /// This is a nontrivial operation because the successors of this basic block

 /// case, only the original BI will be replaced and selects for PHIs are added.
 bool hoistThenElseCodeToIf(BranchInst *BI, const TargetTransformInfo &TTI,
                            bool EqTermsOnly, DomTreeUpdater *DTU);
 
 /// Check whether BB's predecessors end with unconditional branches. If it is
 /// true, sink any common code from the predecessors to BB.
 /// We also allow one predecessor to end with conditional branch (but no more
 /// than one).
-bool sinkCommonCodeFromPredecessors(BasicBlock *BB, DomTreeUpdater *DTU);
+bool sinkCommonCodeFromPredecessors(BasicBlock *BB, DomTreeUpdater *DTU,
+                                    LoopInfo *LI = nullptr);
 
 /// This function is used to flatten a CFG. For example, it uses parallel-and
 /// and parallel-or mode to collapse if-conditions and merge if-regions with
 /// identical statements.
 bool FlattenCFG(BasicBlock *BB, AAResults *AA = nullptr);
 
 /// If this basic block is ONLY a setcc and a branch, and if a predecessor
 /// branches to us and one of our successors, fold the setcc into the

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

namespace {
   };
 
 } // end anonymous namespace
 
 // Check whether BB's predecessors end with unconditional branches. If it is
 // true, sink any common code from the predecessors to BB.
 // We also allow one predecessor to end with conditional branch (but no more
 // than one).
-bool llvm::sinkCommonCodeFromPredecessors(BasicBlock *BB, DomTreeUpdater *DTU) {
+bool llvm::sinkCommonCodeFromPredecessors(BasicBlock *BB, DomTreeUpdater *DTU,
+                                          LoopInfo *LI) {
   // We support two situations:
   //   (1) all incoming arcs are unconditional
   //   (2) one incoming arc is conditional
   //
   // (2) is very common in switch defaults and
   // else-if patterns;
   //
   //   if (a) f(1);
while (ProfitableToSinkInstruction(LRI) && Idx < ScanIdx) {
       ++Idx;
     }
     if (!Profitable)
       return false;
 
     LLVM_DEBUG(dbgs() << "SINK: Splitting edge\n");
     // We have a conditional edge and we're going to sink some instructions.
     // Insert a new block postdominating all blocks we're going to sink from.
-    if (!SplitBlockPredecessors(BB, UnconditionalPreds, ".sink.split", DTU))
+    if (!SplitBlockPredecessors(BB, UnconditionalPreds, ".sink.split", DTU, LI))
       // Edges couldn't be split.
       return false;
     Changed = true;
   }
 
   // Now that we've analyzed all potential sinking candidates, perform the
   // actual sink. We iteratively sink the last non-terminator of the source
   // blocks into their common successor unless doing so would require too