[LV][WIP] Lazy creation of BFI when required by cost model

[ebrevnov]

Summary

NOTE: just shows the concept, not to be committed as is

This patch introduces utility class which helps to request analysis in a lazy fashion. It automatically manages invalidation and updates of predefined set of analysis behind the scene. JumpThreading already uses the same idea but has implementation covering its needs only. This is an attempt to generalize the solution so it can be used in other similar cases. It doesn't replace existing functionality of analysis managers. Instead it introduces a convenient way to have a local cache of analysis results (aka. LoopInfo* LI class member) that automatically updated when needed. The benefit of having such an utility class (as opposite to using analysis manager API directly) is minimized probability of introducing new bugs due to well defined API and extra internal verifications.

Please let me know if like the idea or not. If I have a green light I can split this patch and introduce new functionality by steps.

[ebrevnov]

Removed acidental changes

[ebrevnov]

Any feedback?

[fhahn]

Just to make sure I understand the motivation for this: the goal is to only request BFI and PSI when the cost-model actually uses them to save compile time for cases which aren't vectorizable according to Legal for example?

llvm/include/llvm/Transforms/Vectorize/LoopVectorize.h

 //  S. Maleki, Y. Gao, M. Garzaran, T. Wong and D. Padua.  An Evaluation of
 //  Vectorizing Compilers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
 #define LLVM_TRANSFORMS_VECTORIZE_LOOPVECTORIZE_H
 
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/BlockFrequencyInfo.h"
+#include "llvm/Analysis/DemandedBits.h"
+#include "llvm/Analysis/LoopAccessAnalysis.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationRemarkEmitter.h"
+#include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/CommandLine.h"
+
+
 #include <functional>
 
 namespace llvm {
 
-class AssumptionCache;
-class BlockFrequencyInfo;
-class DemandedBits;
-class DominatorTree;
+//class AssumptionCache;
+//class BlockFrequencyInfo;
+//class DemandedBits;
+//class DominatorTree;
 class Function;
 class Loop;
-class LoopAccessInfoManager;
-class LoopInfo;
-class OptimizationRemarkEmitter;
-class ProfileSummaryInfo;
-class ScalarEvolution;
-class TargetLibraryInfo;
-class TargetTransformInfo;
+//class LoopAccessInfoManager;
+//class LoopInfo;
+//class OptimizationRemarkEmitter;
+//class ProfileSummaryInfo;
+//class ScalarEvolution;
+//class TargetLibraryInfo;
+//class TargetTransformInfo;
 
 extern cl::opt<bool> EnableLoopInterleaving;
 extern cl::opt<bool> EnableLoopVectorization;
 
 /// A marker to determine if extra passes after loop vectorization should be
 /// run.
 struct ShouldRunExtraVectorPasses
     : public AnalysisInfoMixin<ShouldRunExtraVectorPasses> {
struct LoopVectorizeOptions {
   }
 
   LoopVectorizeOptions &setVectorizeOnlyWhenForced(bool Value) {
     VectorizeOnlyWhenForced = Value;
     return *this;
   }
 };
 
-/// Storage for information about made changes.
-struct LoopVectorizeResult {
-  bool MadeAnyChange;
-  bool MadeCFGChange;
+/// Utility class aimed at simplification of analyses tracking when they need to
+/// be requested in a lazy fashion with potential invalidation in between.
+/// It automatically updates/rebuilds tracked analyses in cases when they have
+/// been direct or indirectly invalidated.
+/// Let us assume some transformation pass 'T' depends on analyses 'A', 'B' and
+/// 'C'. In addition, 'T' needs analyses 'C' at some cases only while analysis
+/// 'B' may be invalidated by the time 'C' is needed. Then instead of explicit
+/// declaration of 'A', 'B' and 'C' (and manual tracking) simply declare
+/// class T  {
+///   LocalAnalysesProvider<A, B, C> LAP;
+/// }
+///
+/// Now, at the moment you need 'A' and 'B' enable them the following way:
+///
+///   LAP->enable<A>(true /* is_required_analysis */);
+///   LAP->enable<B>(true /* is_required_analysis */);
+///
+/// From that moment (and until explicit invalidation through corresponding APIs)
+/// analysis result can be obtained by calling:
+///
+///   LAP->getResult<A>();
+///   LAP->getResult<B>();
+///
+/// At the moment analysis 'B' (or any other analysis even not explicitly tracked
+/// by 'LAP') become invalid notify about that and optionally re-enable 'B' if
+/// it still needed. Note that 'A' may be implicitly updated as well (if 'A'
+//// depends on 'B').
+///
+///   LAP->abandon<B>();
+///   LAP->enable<B>(); // optionally
+///
+/// Similarly, when 'C' is needed simply enable it and use:
+///
+///  LAP->enable<C>(true /* is_required_analysis */);
+///  LAP->getResult<C>();
+template <typename... LocalAnalyses> class LocalAnalysesProvider;
+template <typename... LocalAnalyses>
+class LocalAnalysesProvider<std::tuple<LocalAnalyses...>> {
+  using LocalAnalysesTupleT = std::tuple<LocalAnalyses...>;
+
+  FunctionAnalysisManager &FAM;
+  Function &F;
+
+  template <typename Analysis>
+  using AnalysesInfoElemT =
+      std::tuple<bool /*is_enabled*/, bool /*is_valid*/, bool /*is_required*/,
+                 typename Analysis::Result *>;
+
+  // Data structure to keep results and status of local analysis.
+  // For each local analysis we maintain 4 things:
+  //   is_enabled - whether analysis should be tracked or not
+  //   is_valid - whether locally cached analysis result is valid or not. Note
+  ///    that global result (as seen by FAM) may or may not be valid.
+  //   is_required - whether analysis is "required" or "optional"
+  std::tuple<
+      std::tuple<bool /*is_enabled*/, bool /*is_valid*/, bool /*is_required*/,
+                 typename LocalAnalyses::Result *>...>
+      LocalAnalysisInfo;
+
+  // Set of preserved analysis communicated to FAM during invalidation. Please
+  // note that actual analysis result may still be invalidated (even if listed
+  // in GlobalPA) if one of the analysis it depends on is invalidated.
+  PreservedAnalyses GlobalPA = PreservedAnalyses::all();
+
+  // 'true' if any analysis has been invalidated trough the corresponding API
+  // since last time FAM has been notified about invalidation.
+  bool InvalidateGlobalAnalyses = false;
+
+public:
+  explicit LocalAnalysesProvider(FunctionAnalysisManager &FAM, Function &F)
+      : FAM(FAM), F(F) {}
+
+  /// Returns locally cached result of the specified analysis if known to be
+  /// valid. If locally cached result is not known to be invalid or specified
+  /// analysis hasn't been enabled via corresponding API nullptr is returned.
+  template <typename Analysis>
+  typename Analysis::Result *getResultIfValid() const {
+    if (IsEnabled<Analysis>() && isValid<Analysis>())
+      return const_cast<typename Analysis::Result *>(getResultImpl<Analysis>());
+
+    return nullptr;
+  }
+
+  /// Returns locally cached result of the specified analysis. It makes sure
+  /// the returned result is up to date before returning it. If specified
+  /// analysis hasn't been enabled via corresponding API nullptr is returned.
+  template <typename Analysis> typename Analysis::Result *getResult() {
+    if (!IsEnabled<Analysis>())
+      return nullptr;
+
+    updateLocalAnalysis<Analysis>();
+    return getResultImpl<Analysis>();
+  }
+
+  /// Returns set of "supposed to be valid/preserved" analyses. In other words,
+  /// the set consists of all not explicitly invalidated analyses. Note that
+  /// local as well as global analysis result may still be not valid due to
+  /// dependencies between analysis.
+  PreservedAnalyses getPreservedAnalyses() const { return GlobalPA; }
+
+  /// Turns on local tracking of the specified analysis. If 'IsRequired' is true
+  /// and there is no global result of the analysis available it will be
+  /// re-created. If 'IsRequired' is false a cached global result will be used
+  /// if exist.
+  template<typename Analysis>
+  void enable(bool IsRequired) {
+    if (IsRequired)
+      enableRequiredAnalysis<Analysis>();
+    else
+      enableOptionalAnalysis<Analysis>();
+  }
+
+  /// Turns on local tracking of the specified analyses. See 'enable(bool
+  /// IsRequired) API for details about "required" and "optional" analysis'.
+  template <typename RequiredAnalyses, typename OptionalAnalyses>
+  void enable() {
+    if ((std::tuple_size_v<RequiredAnalyses>) > 0) {
+      enableRequiredAnalyses<RequiredAnalyses>(
+          std::make_index_sequence<std::tuple_size_v<RequiredAnalyses>>{});
+    }
+
+    enableOptionalAnalyses<OptionalAnalyses>(
+        std::make_index_sequence<std::tuple_size_v<OptionalAnalyses>>{});
+  }
+
+  /// Turns off local tracking of the specified analysis. Once analysis is
+  /// disabled 'getResult/getResultIfEanbled<Analysis>' APIs will return
+  /// nullptr.
+  template<typename Analysis>
+  void disable() {
+    SetEnabled<Analysis>(false);
+  }
+
+  /// Notify about invalidation of the specified analysis result.
+  template<typename Analysis>
+  void invalidate() {
+    InvalidateGlobalAnalyses = true;
+    (setValid<LocalAnalyses>(false), ...);
+    GlobalPA.abandon<Analysis>();
+  }
+
+  /// Notify about invalidation of all analysis results except the specified
+  /// ones.
+  template <typename Analyses>
+  void invalidateExcept()
+  {
+    InvalidateGlobalAnalyses = true;
+    (setValid<LocalAnalyses>(false), ...);
+    GlobalPA.intersect(as_preserved<Analyses>(
+        std::make_index_sequence<std::tuple_size_v<Analyses>>{}));
+  }
+
+  /// Same as the above but takes set of "PreservedAnalyses".
+  void invalidateExcept(PreservedAnalyses PA)
+  {
+    InvalidateGlobalAnalyses = true;
+    (setValid<LocalAnalyses>(false), ...);
+    GlobalPA.intersect(PA);
+  }
+
+  /// Notify about invalidation of all analysis.
+  void invalidateAll()
+  {
+    InvalidateGlobalAnalyses = true;
+    (setValid<LocalAnalyses>(false), ...);
+    GlobalPA = PreservedAnalyses::none();
+  }
+
+  template <typename Analysis>
+  void abandon() {
+    invalidate<Analysis>();
+    disable<Analysis>();
+  }
+
+private:
+  template <typename Analysis>
+  const AnalysesInfoElemT<Analysis> &getAnalysesInfoElem() const {
+    return std::get<AnalysesInfoElemT<Analysis>>(LocalAnalysisInfo);
+  }
+
+  template <typename Analysis>
+  AnalysesInfoElemT<Analysis> &getAnalysesInfoElem() {
+    return std::get<AnalysesInfoElemT<Analysis>>(LocalAnalysisInfo);
+  }
+
+  template <typename Analysis> bool IsEnabled() const {
+    return std::get<0>(getAnalysesInfoElem<Analysis>());
+  }
+
+  template <typename Analysis> void SetEnabled(bool Enabled)  {
+    std::get<0>(getAnalysesInfoElem<Analysis>()) = Enabled;
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  void SetEnabled(bool Enabled, std::index_sequence<Is...>) {
+    (SetEnabled<std::tuple_element_t<Is, Analyses>>(Enabled), ...);
+  }
+
+  template <typename Analysis> bool isValid() const {
+    return std::get<1>(getAnalysesInfoElem<Analysis>());
+  }
+
+  template <typename Analysis> void setValid(bool Valid) {
+    std::get<1>(getAnalysesInfoElem<Analysis>()) = Valid;
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  void setValid(bool Valid, std::index_sequence<Is...>) {
+    (setValid<std::tuple_element_t<Is, Analyses>>(Valid), ...);
+  }
+
+  template <typename Analysis> bool isRequired() const {
+    return std::get<2>(getAnalysesInfoElem<Analysis>());
+  }
+
+  template <typename Analysis> void setRequired(bool Required) {
+    std::get<2>(getAnalysesInfoElem<Analysis>()) = Required;
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  void setRequired(bool Required, std::index_sequence<Is...>) {
+    (setRequired<std::tuple_element_t<Is, Analyses>>(Required), ...);
+  }
+
+  template <typename Analysis>
+  typename Analysis::Result *const &getResultImpl() const {
+    return std::get<3>(getAnalysesInfoElem<Analysis>());
+  }
+
+  template <typename Analysis>
+  typename Analysis::Result *&getResultImpl() {
+    return std::get<3>(getAnalysesInfoElem<Analysis>());
+  }
+
+  template <typename Analysis>
+  void setResultImpl(typename Analysis::Result *R) {
+    setValid<Analysis>(true);
+    getResultImpl<Analysis>() = R;
+  }
 
-  LoopVectorizeResult(bool MadeAnyChange, bool MadeCFGChange)
-      : MadeAnyChange(MadeAnyChange), MadeCFGChange(MadeCFGChange) {}
+  template <typename Analysis> void updateLocalAnalysis() {
+    if (!IsEnabled<Analysis>())
+      return;
+
+    if (!isValid<Analysis>() || !getResultImpl<Analysis>()) {
+      if (InvalidateGlobalAnalyses) {
+        FAM.invalidate(F, GlobalPA);
+        InvalidateGlobalAnalyses = false;
+      }
+      typename Analysis::Result *Res = nullptr;
+      if constexpr(std::is_same_v<Analysis, ProfileSummaryAnalysis>) {
+          auto &MAMProxy = FAM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
+          Res = MAMProxy.getCachedResult<Analysis>(*F.getParent());
+      } else if (isRequired<Analysis>()){
+        Res = &FAM.getResult<Analysis>(F);
+      } else {
+        Res = FAM.getCachedResult<Analysis>(F);
+      }
+      setResultImpl<Analysis>(Res);
+    }
+  }
+
+  template <typename Analysis> void enableRequiredAnalysis() {
+    static_assert(
+        !std::is_same<Analysis, ProfileSummaryAnalysis>::value &&
+        "PSI can only be provided on best effort basis");
+    SetEnabled<Analysis>(true);
+    setRequired<Analysis>(true);
+    updateLocalAnalysis<Analysis>();
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  void enableRequiredAnalyses(std::index_sequence<Is...>) {
+    (enableRequiredAnalysis<std::tuple_element_t<Is, Analyses>>(), ...);
+  }
+
+  template<typename Analysis>
+  void enableOptionalAnalysis() {
+    SetEnabled<Analysis>(true);
+    setRequired<Analysis>(false);
+    updateLocalAnalysis<Analysis>();
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  void enableOptionalAnalyses(std::index_sequence<Is...>) {
+    (enableOptionalAnalysis<std::tuple_element_t<Is, Analyses>>(), ...);
+  }
+
+  template<typename Analyses, std::size_t... Is>
+  PreservedAnalyses as_preserved(std::index_sequence<Is...>) const {
+    PreservedAnalyses PA;
+    (PA.preserve<std::tuple_element_t<Is, Analyses>>(), ...);
+    return PA;
+  }
 };
 
 /// The LoopVectorize Pass.
 struct LoopVectorizePass : public PassInfoMixin<LoopVectorizePass> {
+public:
+  using VecRequiredAnalyses =
+      std::tuple<ScalarEvolutionAnalysis, LoopAnalysis, TargetIRAnalysis,
+                 DominatorTreeAnalysis, TargetLibraryAnalysis,
+                 DemandedBitsAnalysis, AssumptionAnalysis, LoopAccessAnalysis,
+                 OptimizationRemarkEmitterAnalysis>;
+  using VecOptionalAnalysis =
+      std::tuple<BlockFrequencyAnalysis, ProfileSummaryAnalysis,
+                 ShouldRunExtraVectorPasses>;
+  using AllLocalAnalyses =
+      decltype(std::tuple_cat(std::declval<VecRequiredAnalyses>(),
+                              std::declval<VecOptionalAnalysis>()));
+  using VecAnalysesProviderT = LocalAnalysesProvider<AllLocalAnalyses>;
+
 private:
+  std::unique_ptr<VecAnalysesProviderT> LAP = nullptr;
+  Function *F;
+
   /// If false, consider all loops for interleaving.
   /// If true, only loops that explicitly request interleaving are considered.
   bool InterleaveOnlyWhenForced;
 
   /// If false, consider all loops for vectorization.
   /// If true, only loops that explicitly request vectorization are considered.
   bool VectorizeOnlyWhenForced;
 
 public:
   LoopVectorizePass(LoopVectorizeOptions Opts = {});
 
-  ScalarEvolution *SE;
-  LoopInfo *LI;
-  TargetTransformInfo *TTI;
-  DominatorTree *DT;
-  BlockFrequencyInfo *BFI;
-  TargetLibraryInfo *TLI;
-  DemandedBits *DB;
-  AssumptionCache *AC;
-  LoopAccessInfoManager *LAIs;
-  OptimizationRemarkEmitter *ORE;
-  ProfileSummaryInfo *PSI;
-
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   void printPipeline(raw_ostream &OS,
                      function_ref<StringRef(StringRef)> MapClassName2PassName);
 
-  // Shim for old PM.
-  LoopVectorizeResult runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
-                              TargetTransformInfo &TTI_, DominatorTree &DT_,
-                              BlockFrequencyInfo *BFI_, TargetLibraryInfo *TLI_,
-                              DemandedBits &DB_, AssumptionCache &AC_,
-                              LoopAccessInfoManager &LAIs_,
-                              OptimizationRemarkEmitter &ORE_,
-                              ProfileSummaryInfo *PSI_);
+  PreservedAnalyses runImpl();
 
-  bool processLoop(Loop *L);
+  void processLoop(Loop *L);
 };
 
 /// Reports a vectorization failure: print \p DebugMsg for debugging
 /// purposes along with the corresponding optimization remark \p RemarkName.
 /// If \p I is passed, it is an instruction that prevents vectorization.
 /// Otherwise, the loop \p TheLoop is used for the location of the remark.
 void reportVectorizationFailure(const StringRef DebugMsg,
     const StringRef OREMsg, const StringRef ORETag,

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PatternMatch.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"

 /// vectorization.
 /// In many cases vectorization is not profitable. This can happen because of
 /// a number of reasons. In this class we mainly attempt to predict the
 /// expected speedup/slowdowns due to the supported instruction set. We use the
 /// TargetTransformInfo to query the different backends for the cost of
 /// different operations.
 class LoopVectorizationCostModel {
 public:
-  LoopVectorizationCostModel(ScalarEpilogueLowering SEL, Loop *L,
-                             PredicatedScalarEvolution &PSE, LoopInfo *LI,
-                             LoopVectorizationLegality *Legal,
-                             const TargetTransformInfo &TTI,
-                             const TargetLibraryInfo *TLI, DemandedBits *DB,
-                             AssumptionCache *AC, BlockFrequencyInfo *BFI,
-                             OptimizationRemarkEmitter *ORE, const Function *F,
-                             const LoopVectorizeHints *Hints,
-                             InterleavedAccessInfo &IAI)
-      : ScalarEpilogueStatus(SEL), TheLoop(L), PSE(PSE), LI(LI), Legal(Legal),
-        TTI(TTI), TLI(TLI), DB(DB), AC(AC), BFI(BFI), ORE(ORE), TheFunction(F),
+  LoopVectorizationCostModel(
+      LoopVectorizePass::VecAnalysesProviderT *LAP, ScalarEpilogueLowering SEL,
+      Loop *L, PredicatedScalarEvolution &PSE, LoopInfo *LI,
+      LoopVectorizationLegality *Legal, const TargetTransformInfo &TTI,
+      const TargetLibraryInfo *TLI, DemandedBits *DB, AssumptionCache *AC,
+      const LoopVectorizeHints *Hints, InterleavedAccessInfo &IAI)
+      : ScalarEpilogueStatus(SEL), LAP(LAP), TheLoop(L), PSE(PSE), LI(LI), Legal(Legal),
+        TTI(TTI), TLI(TLI), DB(DB), AC(AC), ORE(ORE), TheFunction(F),
         Hints(Hints), InterleaveInfo(IAI) {}
 
   /// \return An upper bound for the vectorization factors (both fixed and
   /// scalable). If the factors are 0, vectorization and interleaving should be
   /// avoided up front.
   FixedScalableVFPair computeMaxVF(ElementCount UserVF, unsigned UserIC);
 
   /// \return True if runtime checks are required for vectorization, and false
private:
   bool isEpilogueVectorizationProfitable(const ElementCount VF) const;
 
   /// A helper function that scales provide instruction cost to the
   /// probability of it's execution relative to the loop header.
   InstructionCost getInstCostScaledByFreq(InstructionCost &Cost,
                                           const BasicBlock *BB) const;
 
 public:
+  /// TODO:
+  LoopVectorizePass::VecAnalysesProviderT *LAP;
+
   /// The loop that we evaluate.
   Loop *TheLoop;
 
   /// Predicated scalar evolution analysis.
   PredicatedScalarEvolution &PSE;
 
   /// Loop Info analysis.
   LoopInfo *LI;
 
   /// Vectorization legality.
   LoopVectorizationLegality *Legal;
 
   /// Vector target information.
   const TargetTransformInfo &TTI;
 
   /// Target Library Info.
   const TargetLibraryInfo *TLI;
 
   /// Demanded bits analysis.
   DemandedBits *DB;
 
   /// Assumption cache.
   AssumptionCache *AC;
 
-  BlockFrequencyInfo *BFI;
-
   /// Interface to emit optimization remarks.
   OptimizationRemarkEmitter *ORE;
 
   const Function *TheFunction;
 
   /// Loop Vectorize Hint.
   const LoopVectorizeHints *Hints;
 
GeneratedRTChecks(ScalarEvolution &SE, DominatorTree *DT, LoopInfo *LI,
       : DT(DT), LI(LI), TTI(TTI), SCEVExp(SE, DL, "scev.check"),
         MemCheckExp(SE, DL, "scev.check") {}
 
   /// Generate runtime checks in SCEVCheckBlock and MemCheckBlock, so we can
   /// accurately estimate the cost of the runtime checks. The blocks are
   /// un-linked from the IR and is added back during vector code generation. If
   /// there is no vector code generation, the check blocks are removed
   /// completely.
-  void Create(Loop *L, const LoopAccessInfo &LAI,
+  bool Create(Loop *L, const LoopAccessInfo &LAI,
               const SCEVPredicate &UnionPred, ElementCount VF, unsigned IC) {
 
     // Hard cutoff to limit compile-time increase in case a very large number of
     // runtime checks needs to be generated.
     // TODO: Skip cutoff if the loop is guaranteed to execute, e.g. due to
     // profile info.
     CostTooHigh =
         LAI.getNumRuntimePointerChecks() > VectorizeMemoryCheckThreshold;
     if (CostTooHigh)
-      return;
+      return false;
 
     BasicBlock *LoopHeader = L->getHeader();
     BasicBlock *Preheader = L->getLoopPreheader();
 
     // Use SplitBlock to create blocks for SCEV & memory runtime checks to
     // ensure the blocks are properly added to LoopInfo & DominatorTree. Those
     // may be used by SCEVExpander. The blocks will be un-linked from their
     // predecessors and removed from LI & DT at the end of the function.
if (RtPtrChecking.Need) {
                              RtPtrChecking.getChecks(), MemCheckExp);
       }
       assert(MemRuntimeCheckCond &&
              "no RT checks generated although RtPtrChecking "
              "claimed checks are required");
     }
 
     if (!MemCheckBlock && !SCEVCheckBlock)
-      return;
+      return false;
 
     // Unhook the temporary block with the checks, update various places
     // accordingly.
     if (SCEVCheckBlock)
       SCEVCheckBlock->replaceAllUsesWith(Preheader);
     if (MemCheckBlock)
       MemCheckBlock->replaceAllUsesWith(Preheader);
 
bool Create(Loop *L, const LoopAccessInfo &LAI,
     if (MemCheckBlock) {
       DT->eraseNode(MemCheckBlock);
       LI->removeBlock(MemCheckBlock);
     }
     if (SCEVCheckBlock) {
       DT->eraseNode(SCEVCheckBlock);
       LI->removeBlock(SCEVCheckBlock);
     }
+    return true;
   }
 
   InstructionCost getCost() {
     if (SCEVCheckBlock || MemCheckBlock)
       LLVM_DEBUG(dbgs() << "Calculating cost of runtime checks:\n");
 
     if (CostTooHigh) {
       InstructionCost Cost;

 
 InstructionCost LoopVectorizationCostModel::getInstCostScaledByFreq(
     InstructionCost &Cost, const BasicBlock *BB) const {
 
   if (!Cost.isValid()) {
     return Cost;
   }
 
-  if (!BFI)
-    return Cost / getReciprocalPredBlockProb();
+  LAP->enable<BlockFrequencyAnalysis>(true);
+  auto *BFI = LAP->getResult<BlockFrequencyAnalysis>();
 
   auto HeaderFreq = BFI->getBlockFreq(TheLoop->getHeader()).getFrequency();
 
   if (HeaderFreq == 0)
     return Cost / getReciprocalPredBlockProb();
 
   // Scale the total scalar cost by relative block probability.
   return (*Cost.getValue() *
Value *VPTransformState::get(VPValue *Def, unsigned Part) {
   Builder.restoreIP(OldIP);
   return VectorValue;
 }
 
 // Process the loop in the VPlan-native vectorization path. This path builds
 // VPlan upfront in the vectorization pipeline, which allows to apply
 // VPlan-to-VPlan transformations from the very beginning without modifying the
 // input LLVM IR.
-static bool processLoopInVPlanNativePath(
-    Loop *L, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT,
-    LoopVectorizationLegality *LVL, TargetTransformInfo *TTI,
-    TargetLibraryInfo *TLI, DemandedBits *DB, AssumptionCache *AC,
-    OptimizationRemarkEmitter *ORE, BlockFrequencyInfo *BFI,
-    ProfileSummaryInfo *PSI, LoopVectorizeHints &Hints,
-    LoopVectorizationRequirements &Requirements) {
+static void processLoopInVPlanNativePath(
+    LoopVectorizePass::VecAnalysesProviderT *LAP, Loop *L,
+    PredicatedScalarEvolution &PSE, LoopVectorizationLegality *LVL,
+    LoopVectorizeHints &Hints, LoopVectorizationRequirements &Requirements) {
+
+  auto *DT = LAP->getResult<DominatorTreeAnalysis>();
+  auto *TTI = LAP->getResult<TargetIRAnalysis>();
+  auto *TLI = LAP->getResult<TargetLibraryAnalysis>();
+  auto *LI = LAP->getResult<LoopAnalysis>();
+  auto *ORE = LAP->getResult<OptimizationRemarkEmitterAnalysis>();
+  auto *DB = LAP->getResult<DemandedBitsAnalysis>();
+  auto *AC = LAP->getResult<AssumptionAnalysis>();
 
   if (isa<SCEVCouldNotCompute>(PSE.getBackedgeTakenCount())) {
     LLVM_DEBUG(dbgs() << "LV: cannot compute the outer-loop trip count\n");
-    return false;
+    return;
   }
   assert(EnableVPlanNativePath && "VPlan-native path is disabled.");
   Function *F = L->getHeader()->getParent();
   InterleavedAccessInfo IAI(PSE, L, DT, LI, LVL->getLAI());
 
-  ScalarEpilogueLowering SEL =
-      getScalarEpilogueLowering(F, L, Hints, PSI, BFI, TTI, TLI, *LVL, &IAI);
+  ScalarEpilogueLowering SEL = getScalarEpilogueLowering(
+      F, L, Hints, LAP->getResult<ProfileSummaryAnalysis>(),
+      LAP->getResult<BlockFrequencyAnalysis>(), TTI, TLI, *LVL, &IAI);
 
-  LoopVectorizationCostModel CM(SEL, L, PSE, LI, LVL, *TTI, TLI, DB, AC, BFI,
+  LoopVectorizationCostModel CM(LAP, SEL, L, PSE, LI, LVL, *TTI, TLI, DB, AC,
                                 ORE, F, &Hints, IAI);
   // Use the planner for outer loop vectorization.
   // TODO: CM is not used at this point inside the planner. Turn CM into an
   // optional argument if we don't need it in the future.
   LoopVectorizationPlanner LVP(L, LI, TLI, TTI, LVL, CM, IAI, PSE, Hints, ORE);
 
   // Get user vectorization factor.
   ElementCount UserVF = Hints.getWidth();
 
   CM.collectElementTypesForWidening();
 
   // Plan how to best vectorize, return the best VF and its cost.
   const VectorizationFactor VF = LVP.planInVPlanNativePath(UserVF);
 
   // If we are stress testing VPlan builds, do not attempt to generate vector
   // code. Masked vector code generation support will follow soon.
   // Also, do not attempt to vectorize if no vector code will be produced.
   if (VPlanBuildStressTest || VectorizationFactor::Disabled() == VF)
-    return false;
+    return;
 
   VPlan &BestPlan = LVP.getBestPlanFor(VF.Width);
 
   {
     GeneratedRTChecks Checks(*PSE.getSE(), DT, LI, TTI,
                              F->getParent()->getDataLayout());
     InnerLoopVectorizer LB(L, PSE, LI, DT, TLI, TTI, AC, ORE, VF.Width,
-                           VF.Width, 1, LVL, &CM, BFI, PSI, Checks);
+                           VF.Width, 1, LVL, &CM,
+                           LAP->getResult<BlockFrequencyAnalysis>(),
+                           LAP->getResult<ProfileSummaryAnalysis>(), Checks);
     LLVM_DEBUG(dbgs() << "Vectorizing outer loop in \""
                       << L->getHeader()->getParent()->getName() << "\"\n");
     LVP.executePlan(VF.Width, 1, BestPlan, LB, DT, false);
   }
 
   // Mark the loop as already vectorized to avoid vectorizing again.
   Hints.setAlreadyVectorized();
   assert(!verifyFunction(*L->getHeader()->getParent(), &dbgs()));
-  return true;
+
+  // TODO: Preserve Loop and Dominator analyses for VPlan-native path.
+  LAP->invalidateAll();
+  return;
 }
 
 // Emit a remark if there are stores to floats that required a floating point
 // extension. If the vectorized loop was generated with floating point there
 // will be a performance penalty from the conversion overhead and the change in
 // the vector width.
 static void checkMixedPrecision(Loop *L, OptimizationRemarkEmitter *ORE) {
   SmallVector<Instruction *, 4> Worklist;

 }
 
 LoopVectorizePass::LoopVectorizePass(LoopVectorizeOptions Opts)
     : InterleaveOnlyWhenForced(Opts.InterleaveOnlyWhenForced ||
                                !EnableLoopInterleaving),
       VectorizeOnlyWhenForced(Opts.VectorizeOnlyWhenForced ||
                               !EnableLoopVectorization) {}
 
-bool LoopVectorizePass::processLoop(Loop *L) {
+void LoopVectorizePass::processLoop(Loop *L) {
   assert((EnableVPlanNativePath || L->isInnermost()) &&
          "VPlan-native path is not enabled. Only process inner loops.");
 
+  auto *LI = LAP->getResultIfValid<LoopAnalysis>();
+  assert(LI && "LI is expected to be valid since L depends on it");
+
+  LAP->enable<VecRequiredAnalyses, VecOptionalAnalysis>();
+
+  auto *SE = LAP->getResult<ScalarEvolutionAnalysis>();
+  auto *DT = LAP->getResult<DominatorTreeAnalysis>();
+  auto *TTI = LAP->getResult<TargetIRAnalysis>();
+  auto *TLI = LAP->getResult<TargetLibraryAnalysis>();
+  auto *LAIs = LAP->getResult<LoopAccessAnalysis>();
+  auto *ORE = LAP->getResult<OptimizationRemarkEmitterAnalysis>();
+  auto *DB = LAP->getResult<DemandedBitsAnalysis>();
+  auto *AC = LAP->getResult<AssumptionAnalysis>();
+
+  auto *PSI = LAP->getResult<ProfileSummaryAnalysis>();
+  if (PSI && PSI->hasProfileSummary()) {
+    LAP->enable<BlockFrequencyAnalysis>(true);
+  }
+
 #ifndef NDEBUG
   const std::string DebugLocStr = getDebugLocString(L);
 #endif /* NDEBUG */
 
   LLVM_DEBUG(dbgs() << "\nLV: Checking a loop in '"
                     << L->getHeader()->getParent()->getName() << "' from "
                     << DebugLocStr << "\n");
 
#endif /* NDEBUG */
   // is important to generate an optimization remark for each loop. Most of
   // these messages are generated as OptimizationRemarkAnalysis. Remarks
   // generated as OptimizationRemark and OptimizationRemarkMissed are
   // less verbose reporting vectorized loops and unvectorized loops that may
   // benefit from vectorization, respectively.
 
   if (!Hints.allowVectorization(F, L, VectorizeOnlyWhenForced)) {
     LLVM_DEBUG(dbgs() << "LV: Loop hints prevent vectorization.\n");
-    return false;
+    return;
   }
 
   PredicatedScalarEvolution PSE(*SE, *L);
 
   // Check if it is legal to vectorize the loop.
   LoopVectorizationRequirements Requirements;
   LoopVectorizationLegality LVL(L, PSE, DT, TTI, TLI, F, *LAIs, LI, ORE,
-                                &Requirements, &Hints, DB, AC, BFI, PSI);
+                                &Requirements, &Hints, DB, AC,
+                                LAP->getResult<BlockFrequencyAnalysis>(),
+                                LAP->getResult<ProfileSummaryAnalysis>());
+
   if (!LVL.canVectorize(EnableVPlanNativePath)) {
     LLVM_DEBUG(dbgs() << "LV: Not vectorizing: Cannot prove legality.\n");
     Hints.emitRemarkWithHints();
-    return false;
+    return;
   }
 
   // Entrance to the VPlan-native vectorization path. Outer loops are processed
   // here. They may require CFG and instruction level transformations before
   // even evaluating whether vectorization is profitable. Since we cannot modify
   // the incoming IR, we need to build VPlan upfront in the vectorization
   // pipeline.
-  if (!L->isInnermost())
-    return processLoopInVPlanNativePath(L, PSE, LI, DT, &LVL, TTI, TLI, DB, AC,
-                                        ORE, BFI, PSI, Hints, Requirements);
+  if (!L->isInnermost()) {
+    processLoopInVPlanNativePath(LAP.get(), L, PSE, &LVL, Hints, Requirements);
+    return;
+  }
 
   assert(L->isInnermost() && "Inner loop expected.");
 
   InterleavedAccessInfo IAI(PSE, L, DT, LI, LVL.getLAI());
   bool UseInterleaved = TTI->enableInterleavedAccessVectorization();
 
   // If an override option has been passed in for interleaved accesses, use it.
   if (EnableInterleavedMemAccesses.getNumOccurrences() > 0)
     UseInterleaved = EnableInterleavedMemAccesses;
 
   // Analyze interleaved memory accesses.
   if (UseInterleaved)
     IAI.analyzeInterleaving(useMaskedInterleavedAccesses(*TTI));
 
   // Check the function attributes and profiles to find out if this function
   // should be optimized for size.
-  ScalarEpilogueLowering SEL =
-      getScalarEpilogueLowering(F, L, Hints, PSI, BFI, TTI, TLI, LVL, &IAI);
+  ScalarEpilogueLowering SEL = getScalarEpilogueLowering(
+      F, L, Hints, LAP->getResult<ProfileSummaryAnalysis>(),
+      LAP->getResult<BlockFrequencyAnalysis>(), TTI, TLI, LVL, &IAI);
 
   // Check the loop for a trip count threshold: vectorize loops with a tiny trip
   // count by optimizing for size, to minimize overheads.
   auto ExpectedTC = getSmallBestKnownTC(*SE, L);
   if (ExpectedTC && *ExpectedTC < TinyTripCountVectorThreshold) {
     LLVM_DEBUG(dbgs() << "LV: Found a loop with a very small trip count. "
                       << "This loop is worth vectorizing only if no scalar "
                       << "iteration overheads are incurred.");
     if (Hints.getForce() == LoopVectorizeHints::FK_Enabled)
       LLVM_DEBUG(dbgs() << " But vectorizing was explicitly forced.\n");
     else {
       if (*ExpectedTC > TTI->getMinTripCountTailFoldingThreshold()) {
         LLVM_DEBUG(dbgs() << "\n");
         SEL = CM_ScalarEpilogueNotAllowedLowTripLoop;
       } else {
         LLVM_DEBUG(dbgs() << " But the target considers the trip count too "
                              "small to consider vectorizing.\n");
         reportVectorizationFailure(
             "The trip count is below the minial threshold value.",
             "loop trip count is too low, avoiding vectorization",
             "LowTripCount", ORE, L);
         Hints.emitRemarkWithHints();
-        return false;
+        return;
       }
     }
   }
 
   // Check the function attributes to see if implicit floats or vectors are
   // allowed.
   if (F->hasFnAttribute(Attribute::NoImplicitFloat)) {
     reportVectorizationFailure(
         "Can't vectorize when the NoImplicitFloat attribute is used",
         "loop not vectorized due to NoImplicitFloat attribute",
         "NoImplicitFloat", ORE, L);
     Hints.emitRemarkWithHints();
-    return false;
+    return;
   }
 
   // Check if the target supports potentially unsafe FP vectorization.
   // FIXME: Add a check for the type of safety issue (denormal, signaling)
   // for the target we're vectorizing for, to make sure none of the
   // additional fp-math flags can help.
   if (Hints.isPotentiallyUnsafe() &&
       TTI->isFPVectorizationPotentiallyUnsafe()) {
     reportVectorizationFailure(
         "Potentially unsafe FP op prevents vectorization",
         "loop not vectorized due to unsafe FP support.",
         "UnsafeFP", ORE, L);
     Hints.emitRemarkWithHints();
-    return false;
+    return;
   }
 
   bool AllowOrderedReductions;
   // If the flag is set, use that instead and override the TTI behaviour.
   if (ForceOrderedReductions.getNumOccurrences() > 0)
     AllowOrderedReductions = ForceOrderedReductions;
   else
     AllowOrderedReductions = TTI->enableOrderedReductions();
   if (!LVL.canVectorizeFPMath(AllowOrderedReductions)) {
     ORE->emit([&]() {
       auto *ExactFPMathInst = Requirements.getExactFPInst();
       return OptimizationRemarkAnalysisFPCommute(DEBUG_TYPE, "CantReorderFPOps",
                                                  ExactFPMathInst->getDebugLoc(),
                                                  ExactFPMathInst->getParent())
              << "loop not vectorized: cannot prove it is safe to reorder "
                 "floating-point operations";
     });
     LLVM_DEBUG(dbgs() << "LV: loop not vectorized: cannot prove it is safe to "
                          "reorder floating-point operations\n");
     Hints.emitRemarkWithHints();
-    return false;
+    return;
   }
 
   // Use the cost model.
-  LoopVectorizationCostModel CM(SEL, L, PSE, LI, &LVL, *TTI, TLI, DB, AC, BFI,
-                                ORE, F, &Hints, IAI);
+  LoopVectorizationCostModel CM(LAP.get(), SEL, L, PSE, LI, &LVL, *TTI, TLI, DB,
+                                AC, ORE, F, &Hints, IAI);
   // Use the planner for vectorization.
   LoopVectorizationPlanner LVP(L, LI, TLI, TTI, &LVL, CM, IAI, PSE, Hints, ORE);
 
   // Get user vectorization factor and interleave count.
   ElementCount UserVF = Hints.getWidth();
   unsigned UserIC = Hints.getInterleave();
 
   // Plan how to best vectorize, return the best VF and its cost.
   std::optional<VectorizationFactor> MaybeVF = LVP.plan(UserVF, UserIC);
 
   VectorizationFactor VF = VectorizationFactor::Disabled();
   unsigned IC = 1;
 
   GeneratedRTChecks Checks(*PSE.getSE(), DT, LI, TTI,
                            F->getParent()->getDataLayout());
   if (MaybeVF) {
     VF = *MaybeVF;
     // Select the interleave count.
     IC = CM.selectInterleaveCount(VF.Width, VF.Cost);
 
     unsigned SelectedIC = std::max(IC, UserIC);
     //  Optimistically generate runtime checks if they are needed. Drop them if
     //  they turn out to not be profitable.
     if (VF.Width.isVector() || SelectedIC > 1)
-      Checks.Create(L, *LVL.getLAI(), PSE.getPredicate(), VF.Width, SelectedIC);
+      if (Checks.Create(L, *LVL.getLAI(), PSE.getPredicate(), VF.Width,
+                        SelectedIC)) {
+        // Request dummy 'ShouldRunExtraVectorPasses' analysis to indicate
+        // that runtime checks has been generated.
+        LAP->enable<ShouldRunExtraVectorPasses>(true);
+      }
 
     // Check if it is profitable to vectorize with runtime checks.
     bool ForceVectorization =
         Hints.getForce() == LoopVectorizeHints::FK_Enabled;
     if (!ForceVectorization &&
         !areRuntimeChecksProfitable(Checks, VF, CM.getVScaleForTuning(), L,
                                     *PSE.getSE())) {
       ORE->emit([&]() {
         return OptimizationRemarkAnalysisAliasing(
                    DEBUG_TYPE, "CantReorderMemOps", L->getStartLoc(),
                    L->getHeader())
                << "loop not vectorized: cannot prove it is safe to reorder "
                   "memory operations";
       });
       LLVM_DEBUG(dbgs() << "LV: Too many memory checks needed.\n");
       Hints.emitRemarkWithHints();
-      return false;
+      return;
     }
   }
 
   // Identify the diagnostic messages that should be produced.
   std::pair<StringRef, std::string> VecDiagMsg, IntDiagMsg;
   bool VectorizeLoop = true, InterleaveLoop = true;
   if (VF.Width.isScalar()) {
     LLVM_DEBUG(dbgs() << "LV: Vectorization is possible but not beneficial.\n");
ORE->emit([&]() {
                                       L->getStartLoc(), L->getHeader())
              << VecDiagMsg.second;
     });
     ORE->emit([&]() {
       return OptimizationRemarkMissed(LV_NAME, IntDiagMsg.first,
                                       L->getStartLoc(), L->getHeader())
              << IntDiagMsg.second;
     });
-    return false;
+    return;
   } else if (!VectorizeLoop && InterleaveLoop) {
     LLVM_DEBUG(dbgs() << "LV: Interleave Count is " << IC << '\n');
     ORE->emit([&]() {
       return OptimizationRemarkAnalysis(VAPassName, VecDiagMsg.first,
                                         L->getStartLoc(), L->getHeader())
              << VecDiagMsg.second;
     });
   } else if (VectorizeLoop && !InterleaveLoop) {
#endif /* NDEBUG */
   MDNode *OrigLoopID = L->getLoopID();
   {
     using namespace ore;
     if (!VectorizeLoop) {
       assert(IC > 1 && "interleave count should not be 1 or 0");
       // If we decided that it is not legal to vectorize the loop, then
       // interleave it.
       InnerLoopUnroller Unroller(L, PSE, LI, DT, TLI, TTI, AC, ORE, IC, &LVL,
-                                 &CM, BFI, PSI, Checks);
+                                 &CM, LAP->getResult<BlockFrequencyAnalysis>(),
+                                 LAP->getResult<ProfileSummaryAnalysis>(),
+                                 Checks);
 
       VPlan &BestPlan = LVP.getBestPlanFor(VF.Width);
       LVP.executePlan(VF.Width, IC, BestPlan, Unroller, DT, false);
 
       ORE->emit([&]() {
         return OptimizationRemark(LV_NAME, "Interleaved", L->getStartLoc(),
                                   L->getHeader())
                << "interleaved loop (interleaved count: "
                << NV("InterleaveCount", IC) << ")";
       });
     } else {
       // If we decided that it is *legal* to vectorize the loop, then do it.
 
       // Consider vectorizing the epilogue too if it's profitable.
       VectorizationFactor EpilogueVF =
           CM.selectEpilogueVectorizationFactor(VF.Width, LVP);
       if (EpilogueVF.Width.isVector()) {
 
         // The first pass vectorizes the main loop and creates a scalar epilogue
         // to be vectorized by executing the plan (potentially with a different
         // factor) again shortly afterwards.
         EpilogueLoopVectorizationInfo EPI(VF.Width, IC, EpilogueVF.Width, 1);
-        EpilogueVectorizerMainLoop MainILV(L, PSE, LI, DT, TLI, TTI, AC, ORE,
-                                           EPI, &LVL, &CM, BFI, PSI, Checks);
+        EpilogueVectorizerMainLoop MainILV(
+            L, PSE, LI, DT, TLI, TTI, AC, ORE, EPI, &LVL, &CM,
+            LAP->getResult<BlockFrequencyAnalysis>(),
+            LAP->getResult<ProfileSummaryAnalysis>(), Checks);
 
         VPlan &BestMainPlan = LVP.getBestPlanFor(EPI.MainLoopVF);
         LVP.executePlan(EPI.MainLoopVF, EPI.MainLoopUF, BestMainPlan, MainILV,
                         DT, true);
         ++LoopsVectorized;
 
         // Second pass vectorizes the epilogue and adjusts the control flow
         // edges from the first pass.
         EPI.MainLoopVF = EPI.EpilogueVF;
         EPI.MainLoopUF = EPI.EpilogueUF;
-        EpilogueVectorizerEpilogueLoop EpilogILV(L, PSE, LI, DT, TLI, TTI, AC,
-                                                 ORE, EPI, &LVL, &CM, BFI, PSI,
-                                                 Checks);
+        EpilogueVectorizerEpilogueLoop EpilogILV(
+            L, PSE, LI, DT, TLI, TTI, AC, ORE, EPI, &LVL, &CM,
+            LAP->getResult<BlockFrequencyAnalysis>(),
+            LAP->getResult<ProfileSummaryAnalysis>(), Checks);
 
         VPlan &BestEpiPlan = LVP.getBestPlanFor(EPI.EpilogueVF);
         VPRegionBlock *VectorLoop = BestEpiPlan.getVectorLoopRegion();
         VPBasicBlock *Header = VectorLoop->getEntryBasicBlock();
         Header->setName("vec.epilog.vector.body");
 
         // Re-use the trip count expanded for the main loop, as skeleton
         // creation needs it as a value that dominates both the scalar and
if (!VectorizeLoop) {
         LVP.executePlan(EPI.EpilogueVF, EPI.EpilogueUF, BestEpiPlan, EpilogILV,
                         DT, true);
         ++LoopsEpilogueVectorized;
 
         if (!MainILV.areSafetyChecksAdded())
           DisableRuntimeUnroll = true;
       } else {
         InnerLoopVectorizer LB(L, PSE, LI, DT, TLI, TTI, AC, ORE, VF.Width,
-                               VF.MinProfitableTripCount, IC, &LVL, &CM, BFI,
-                               PSI, Checks);
+                               VF.MinProfitableTripCount, IC, &LVL, &CM,
+                               LAP->getResult<BlockFrequencyAnalysis>(),
+                               LAP->getResult<ProfileSummaryAnalysis>(),
+                               Checks);
 
         VPlan &BestPlan = LVP.getBestPlanFor(VF.Width);
         LVP.executePlan(VF.Width, IC, BestPlan, LB, DT, false);
         ++LoopsVectorized;
 
         // Add metadata to disable runtime unrolling a scalar loop when there
         // are no runtime checks about strides and memory. A scalar loop that is
         // rarely used is not worth unrolling.
#endif /* NDEBUG */
   } else {
     if (DisableRuntimeUnroll)
       AddRuntimeUnrollDisableMetaData(L);
 
     // Mark the loop as already vectorized to avoid vectorizing again.
     Hints.setAlreadyVectorized();
   }
 
+  assert(!SE || SE == LAP->getResult<ScalarEvolutionAnalysis>());
+  assert(!DT || DT == LAP->getResult<DominatorTreeAnalysis>());
+  assert(!TTI || TTI == LAP->getResult<TargetIRAnalysis>());
+  assert(!TLI || TLI == LAP->getResult<TargetLibraryAnalysis>());
+  assert(!LAIs || LAIs == LAP->getResult<LoopAccessAnalysis>());
+  assert(!ORE || ORE == LAP->getResult<OptimizationRemarkEmitterAnalysis>());
+  assert(!DB || DB == LAP->getResult<DemandedBitsAnalysis>());
+  assert(!AC || AC == LAP->getResult<AssumptionAnalysis>());
+
   assert(!verifyFunction(*L->getHeader()->getParent(), &dbgs()));
-  return true;
+
+  using VecPA =
+      std::tuple<LoopAnalysis, DominatorTreeAnalysis, ScalarEvolutionAnalysis>;
+  LAP->invalidateExcept<VecPA>();
+
+#ifdef EXPENSIVE_CHECKS
+      SE.verify();
+#endif
+
+  return;
 }
 
-LoopVectorizeResult LoopVectorizePass::runImpl(
-    Function &F, ScalarEvolution &SE_, LoopInfo &LI_, TargetTransformInfo &TTI_,
-    DominatorTree &DT_, BlockFrequencyInfo *BFI_, TargetLibraryInfo *TLI_,
-    DemandedBits &DB_, AssumptionCache &AC_, LoopAccessInfoManager &LAIs_,
-    OptimizationRemarkEmitter &ORE_, ProfileSummaryInfo *PSI_) {
-  SE = &SE_;
-  LI = &LI_;
-  TTI = &TTI_;
-  DT = &DT_;
-  BFI = BFI_;
-  TLI = TLI_;
-  AC = &AC_;
-  LAIs = &LAIs_;
-  DB = &DB_;
-  ORE = &ORE_;
-  PSI = PSI_;
+PreservedAnalyses LoopVectorizePass::runImpl() {
+
+  assert(!LAP->getResult<ShouldRunExtraVectorPasses>() &&
+         "ShouldRunExtraVectorPasses analysis should be disabled on entry "
+         "(conditionally enabled if runtime checks are requested)");
+
+  LAP->enable<TargetIRAnalysis>(true);
 
   // Don't attempt if
   // 1. the target claims to have no vector registers, and
   // 2. interleaving won't help ILP.
   //
   // The second condition is necessary because, even if the target has no
   // vector registers, loop vectorization may still enable scalar
   // interleaving.
+  {
+    auto *TTI = LAP->getResult<TargetIRAnalysis>();
     if (!TTI->getNumberOfRegisters(TTI->getRegisterClassForType(true)) &&
         TTI->getMaxInterleaveFactor(ElementCount::getFixed(1)) < 2)
-    return LoopVectorizeResult(false, false);
+      return LAP->getPreservedAnalyses();
+  }
 
-  bool Changed = false, CFGChanged = false;
+  using SimplificationRA = std::tuple<LoopAnalysis>;
+  using SimplificationOA =
+      std::tuple<DominatorTreeAnalysis, ScalarEvolutionAnalysis,
+                 AssumptionAnalysis>;
+  LAP->enable<SimplificationRA, SimplificationOA>();
+  auto *LI = LAP->getResult<LoopAnalysis>();
 
   // The vectorizer requires loops to be in simplified form.
   // Since simplification may add new inner loops, it has to run before the
-  // legality and profitability checks. This means running the loop vectorizer
+  // legality and profitability checks. This means running the loop
+  // vectorizer
   // will simplify all loops, regardless of whether anything end up being
   // vectorized.
-  for (const auto &L : *LI)
-    Changed |= CFGChanged |=
+  bool IsAnyLoopSimplified = false;
+  for (const auto &L : *LI) {
+    auto *SE = LAP->getResult<ScalarEvolutionAnalysis>();
+    auto *DT = LAP->getResult<DominatorTreeAnalysis>();
+    auto *AC = LAP->getResult<AssumptionAnalysis>();
+    IsAnyLoopSimplified |=
         simplifyLoop(L, DT, LI, SE, AC, nullptr, false /* PreserveLCSSA */);
+  }
+
+  if (IsAnyLoopSimplified) {
+    using SimplificationPA = decltype(
+        std::tuple_cat(std::declval<SimplificationRA>(),
+                       std::declval<SimplificationOA>()));
+    LAP->invalidateExcept<SimplificationPA>();
+  }
 
   // Build up a worklist of inner-loops to vectorize. This is necessary as
   // the act of vectorizing or partially unrolling a loop creates new loops
   // and can invalidate iterators across the loops.
-  SmallVector<Loop *, 8> Worklist;
 
+
+  LI = LAP->getResult<LoopAnalysis>();
+  LAP->enable<OptimizationRemarkEmitterAnalysis>(true);
+  SmallVector<Loop *, 8> Worklist;
   for (Loop *L : *LI)
-    collectSupportedLoops(*L, LI, ORE, Worklist);
+    collectSupportedLoops(
+        *L, LI, LAP->getResult<OptimizationRemarkEmitterAnalysis>(), Worklist);
 
   LoopsAnalyzed += Worklist.size();
 
+
   // Now walk the identified inner loops.
   while (!Worklist.empty()) {
+    LAP->enable<DominatorTreeAnalysis>(true);
+    auto *DT = LAP->getResult<DominatorTreeAnalysis>();
     Loop *L = Worklist.pop_back_val();
 
     // For the inner loops we actually process, form LCSSA to simplify the
     // transform.
-    Changed |= formLCSSARecursively(*L, *DT, LI);
+    bool IsLoopLCSSAed = formLCSSARecursively(*L, *DT, LI);
 
-    Changed |= CFGChanged |= processLoop(L);
+    if (IsLoopLCSSAed) {
+      // TODO: Does 'formLCSSARecursively' preserves CFGAnalyses set?
+      LAP->invalidateExcept<std::tuple<DominatorTreeAnalysis, LoopAnalysis,
+                            ScalarEvolutionAnalysis>>();
+    }
+
+    // Make sure 'LI' hasn't changed between iterations as a result of potential
+    // invalidation. Even though it's not explicitly invalidated it may become
+    // invalid if any other analysis it depends is invalidated.
+    auto *tmpLI = LAP->getResult<LoopAnalysis>();
+    (void)tmpLI;
+    assert(LI == tmpLI && "LoopInfo is expected to survive invalidation");
 
-    if (Changed)
-      LAIs->clear();
+    processLoop(L);
   }
-
   // Process each loop nest in the function.
-  return LoopVectorizeResult(Changed, CFGChanged);
+  return LAP->getPreservedAnalyses();
 }
 
-PreservedAnalyses LoopVectorizePass::run(Function &F,
-                                         FunctionAnalysisManager &AM) {
-    auto &LI = AM.getResult<LoopAnalysis>(F);
+PreservedAnalyses LoopVectorizePass::run(Function &F_,
+                                         FunctionAnalysisManager &AM_) {
+    LAP = std::make_unique<VecAnalysesProviderT>(AM_, F_);
+    F = &F_;
+
+
     // There are no loops in the function. Return before computing other expensive
     // analyses.
-    if (LI.empty())
+    if (AM_.getResult<LoopAnalysis>(F_).empty())
       return PreservedAnalyses::all();
-    auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);
-    auto &TTI = AM.getResult<TargetIRAnalysis>(F);
-    auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
-    auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
-    auto &AC = AM.getResult<AssumptionAnalysis>(F);
-    auto &DB = AM.getResult<DemandedBitsAnalysis>(F);
-    auto &ORE = AM.getResult<OptimizationRemarkEmitterAnalysis>(F);
-
-    LoopAccessInfoManager &LAIs = AM.getResult<LoopAccessAnalysis>(F);
-    auto &MAMProxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
-    ProfileSummaryInfo *PSI =
-        MAMProxy.getCachedResult<ProfileSummaryAnalysis>(*F.getParent());
-    BlockFrequencyInfo *BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
-    LoopVectorizeResult Result =
-        runImpl(F, SE, LI, TTI, DT, BFI, &TLI, DB, AC, LAIs, ORE, PSI);
-    if (!Result.MadeAnyChange)
-      return PreservedAnalyses::all();
-    PreservedAnalyses PA;
-
-    if (isAssignmentTrackingEnabled(*F.getParent())) {
-      for (auto &BB : F)
-        RemoveRedundantDbgInstrs(&BB);
-    }
 
-    // We currently do not preserve loopinfo/dominator analyses with outer loop
-    // vectorization. Until this is addressed, mark these analyses as preserved
-    // only for non-VPlan-native path.
-    // TODO: Preserve Loop and Dominator analyses for VPlan-native path.
-    if (!EnableVPlanNativePath) {
-      PA.preserve<LoopAnalysis>();
-      PA.preserve<DominatorTreeAnalysis>();
-      PA.preserve<ScalarEvolutionAnalysis>();
+    PreservedAnalyses PA = runImpl();
+    if (PA.areAllPreserved())
+      return PA;
 
-#ifdef EXPENSIVE_CHECKS
-      SE.verify();
-#endif
+    if (isAssignmentTrackingEnabled(*F->getParent())) {
+      for (auto &BB : *F)
+        RemoveRedundantDbgInstrs(&BB);
     }
 
-    if (Result.MadeCFGChange) {
-      // Making CFG changes likely means a loop got vectorized. Indicate that
-      // extra simplification passes should be run.
-      // TODO: MadeCFGChanges is not a prefect proxy. Extra passes should only
-      // be run if runtime checks have been added.
-      AM.getResult<ShouldRunExtraVectorPasses>(F);
-      PA.preserve<ShouldRunExtraVectorPasses>();
-    } else {
-      PA.preserveSet<CFGAnalyses>();
-    }
     return PA;
 }
 
 void LoopVectorizePass::printPipeline(
     raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
   static_cast<PassInfoMixin<LoopVectorizePass> *>(this)->printPipeline(
       OS, MapClassName2PassName);
 
   OS << '<';
   OS << (InterleaveOnlyWhenForced ? "" : "no-") << "interleave-forced-only;";
   OS << (VectorizeOnlyWhenForced ? "" : "no-") << "vectorize-forced-only;";
   OS << '>';
 }

llvm/test/Other/new-pm-defaults.ll

 ; CHECK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-O-NEXT: Running pass: LoopRotatePass
 ; CHECK-O-NEXT: Running pass: LoopDeletionPass
 ; CHECK-O-NEXT: Running pass: LoopDistributePass
 ; CHECK-O-NEXT: Running analysis: LoopAccessAnalysis on foo
 ; CHECK-O-NEXT: Running pass: InjectTLIMappings
 ; CHECK-O-NEXT: Running pass: LoopVectorizePass
-; CHECK-O-NEXT: Running analysis: BlockFrequencyAnalysis
-; CHECK-O-NEXT: Running analysis: BranchProbabilityAnalysis
 ; CHECK-O-NEXT: Running pass: LoopLoadEliminationPass
 ; CHECK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-O2-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-O3-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-Os-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-O-NEXT: Running pass: VectorCombinePass
 ; CHECK-O-NEXT: Running pass: InstCombinePass

llvm/test/Other/new-pm-lto-defaults.ll

 ; CHECK-O23SZ-NEXT: Running pass: LCSSAPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: IndVarSimplifyPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: LoopDeletionPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: LoopFullUnrollPass on loop
 ; CHECK-O23SZ-NEXT: Running pass: LoopDistributePass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: LoopAccessAnalysis on foo
 ; CHECK-O23SZ-NEXT: Running pass: LoopVectorizePass on foo
 ; CHECK-O23SZ-NEXT: Running analysis: DemandedBitsAnalysis on foo
-; CHECK-O23SZ-NEXT: Running analysis: BlockFrequencyAnalysis
-; CHECK-O23SZ-NEXT: Running analysis: BranchProbabilityAnalysis
 ; CHECK-O23SZ-NEXT: Running pass: LoopUnrollPass on foo
 ; CHECK-O23SZ-NEXT: WarnMissedTransformationsPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: SROAPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O23SZ-NEXT: Running pass: SimplifyCFGPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: SCCPPass on foo
 ; CHECK-O23SZ-NEXT: Running pass: InstCombinePass on foo
 ; CHECK-O23SZ-NEXT: Running pass: BDCEPass on foo

llvm/test/Other/new-pm-thinlto-postlink-defaults.ll

 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopSimplifyPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LCSSAPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopRotatePass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopDeletionPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopDistributePass
 ; CHECK-POSTLINK-O-NEXT: Running analysis: LoopAccessAnalysis on foo
 ; CHECK-POSTLINK-O-NEXT: Running pass: InjectTLIMappings
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopVectorizePass
-; CHECK-POSTLINK-O-NEXT: Running analysis: BlockFrequencyAnalysis
-; CHECK-POSTLINK-O-NEXT: Running analysis: BranchProbabilityAnalysis
 ; CHECK-POSTLINK-O-NEXT: Running pass: LoopLoadEliminationPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: InstCombinePass
 ; CHECK-POSTLINK-O-NEXT: Running pass: SimplifyCFGPass
 ; CHECK-POSTLINK-O2-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-POSTLINK-O3-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-POSTLINK-Os-NEXT: Running pass: SLPVectorizerPass
 ; CHECK-POSTLINK-O-NEXT: Running pass: VectorCombinePass
 ; CHECK-POSTLINK-O-NEXT: Running pass: InstCombinePass

llvm/test/Transforms/LoopVectorize/icmp-uniforms.ll

 ; CHECK-NEXT: vector.ph:
 ; CHECK-NEXT: Successor(s): vector loop
 ; CHECK-EMPTY:
 ; CHECK-NEXT: <x1> vector loop: {
 ; CHECK-NEXT: vector.body:
 ; CHECK-NEXT:   EMIT vp<[[CAN_IV:%.+]]> = CANONICAL-INDUCTION
 ; CHECK-NEXT:   WIDEN-INDUCTION %iv = phi 0, %iv.next, ir<1>
 ; CHECK-NEXT:   EMIT vp<[[COND:%.+]]> = icmp ule ir<%iv> vp<[[BTC]]>
-; CHECK-NEXT:  Successor(s): pred.store
+; CHECK-NEXT: Successor(s): pred.store
 ; CHECK-EMPTY:
 ; CHECK-NEXT:  <xVFxUF> pred.store: {
 ; CHECK-NEXT:    pred.store.entry:
-; CHECK-NEXT:      BRANCH-ON-MASK vp<%5>
+; CHECK-NEXT:      BRANCH-ON-MASK vp<[[COND]]>
 ; CHECK-NEXT:    Successor(s): pred.store.if, pred.store.continue
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    pred.store.if:
-; CHECK-NEXT:      vp<%6>      = SCALAR-STEPS vp<%3>, ir<1>
-; CHECK-NEXT:      REPLICATE ir<%cond0> = icmp vp<%6>, ir<13>
-; CHECK-NEXT:      REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<%6>
+; CHECK-NEXT:      vp<[[STEPS:%.+]]> = SCALAR-STEPS vp<[[CAN_IV]]>, ir<1>
+; CHECK-NEXT:      REPLICATE ir<%cond0> = icmp vp<[[STEPS]]>, ir<13>
+; CHECK-NEXT:      REPLICATE ir<%gep> = getelementptr ir<%ptr>, vp<[[STEPS]]>
 ; CHECK-NEXT:      REPLICATE ir<%s> = select ir<%cond0>, ir<10>, ir<20>
 ; CHECK-NEXT:      REPLICATE store ir<%s>, ir<%gep>
 ; CHECK-NEXT:    Successor(s): pred.store.continue
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    pred.store.continue:
 ; CHECK-NEXT:    No successors
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Successor(s): loop.0
 ; CHECK-EMPTY:
-; CHECK-NEXT:  loop.0:
-; CHECK-NEXT:    EMIT vp<%11> = VF * UF +  vp<%3>
-; CHECK-NEXT:    EMIT branch-on-count  vp<%11> vp<%1>
-; CHECK-NEXT:  No successors
+; CHECK-NEXT: loop.0:
+; CHECK-NEXT:   EMIT vp<[[CAN_IV_NEXT:%.+]]> = VF * UF + vp<[[CAN_IV]]>
+; CHECK-NEXT:   EMIT branch-on-count vp<[[CAN_IV_NEXT]]> vp<[[VEC_TC]]>
+; CHECK-NEXT: No successors
 ; CHECK-NEXT:}
 
 
 
 define void @test(ptr %ptr) {
 entry:
   br label %loop