[LoopVersion] Pass RuntimePointerChecking directly.

[fhahn]

Summary

This refactoring was suggested as follow up by @Ayal in D78460.

This requires changing the way some clients filter runtime checks.

Clients who want to filter out some runtime checks now have to create a
copy of RuntimePointerChecking and apply the filter to the runtime
checks. This seems reasonable to me, as it makes explicit that we
effectively create a subset of the pointer checking.

Passing RuntimePointerChecking also makes changes to addRuntimeChecks
easier, as RuntimePointerChecking should contain all information about
the checks.

[fhahn]

rebase & ping

[fhahn]

ping

[Meinersbur]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

342

Did you consider documenting the RtCheck parameter?

llvm/include/llvm/Transforms/Utils/LoopUtils.h

444

\p PointerChecks: needs to be updated

llvm/include/llvm/Transforms/Utils/LoopVersioning.h

48

Did you consider documenting what the RtPTrCheck argument is used for?

llvm/lib/Analysis/LoopAccessAnalysis.cpp

467

Is this any different to llvm::erase_if(Checks, Predicate)? This also looks like a dangerous game of iterator invalidation by the assignment-operator.

llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp

403

[style] Unnecessary auto. At least I would not have expected it to be a SmallVectorImpl.

525

[style] Unnecessary auto.

[Meinersbur]

what is the status of this?

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

struct RuntimeCheckingPtrGroup {
   /// pointer, with index \p Index in RtCheck.
   RuntimeCheckingPtrGroup(unsigned Index, RuntimePointerChecking &RtCheck);
 
   /// Tries to add the pointer recorded in RtCheck at index
   /// \p Index to this pointer checking group. We can only add a pointer
   /// to a checking group if we will still be able to get
   /// the upper and lower bounds of the check. Returns true in case
   /// of success, false otherwise.
-  bool addPointer(unsigned Index);
+  bool addPointer(unsigned Index, RuntimePointerChecking &RtCheck);
 
-  /// Constitutes the context of this pointer checking group. For each
-  /// pointer that is a member of this group we will retain the index
-  /// at which it appears in RtCheck.
-  RuntimePointerChecking &RtCheck;
   /// The SCEV expression which represents the upper bound of all the
   /// pointers in this group.
   const SCEV *High;
   /// The SCEV expression which represents the lower bound of all the
   /// pointers in this group.
   const SCEV *Low;
   /// Indices of all the pointers that constitute this grouping.
   SmallVector<unsigned, 2> Members;
public:
 
   /// Return PointerInfo for pointer at index \p PtrIdx.
   const PointerInfo &getPointerInfo(unsigned PtrIdx) const {
     return Pointers[PtrIdx];
   }
 
   ScalarEvolution *getSE() const { return SE; }
 
+  /// Remove all runtime checks that satisfy \p Predicate.
+  void
+  removeCheckIf(function_ref<bool(const RuntimePointerCheck &Check)> Predicate);
+
 private:
   /// Groups pointers such that a single memcheck is required
   /// between two different groups. This will clear the CheckingGroups vector
   /// and re-compute it. We will only group dependecies if \p UseDependencies
   /// is true, otherwise we will create a separate group for each pointer.
   void groupChecks(MemoryDepChecker::DepCandidates &DepCands,
                    bool UseDependencies);
 

llvm/include/llvm/Transforms/Utils/LoopUtils.h

 class TargetLibraryInfo;
 class TargetTransformInfo;
 class LPPassManager;
 class Instruction;
 struct RuntimeCheckingPtrGroup;
 typedef std::pair<const RuntimeCheckingPtrGroup *,
                   const RuntimeCheckingPtrGroup *>
     RuntimePointerCheck;
+class RuntimePointerChecking;
 
 template <typename T> class Optional;
 template <typename T, unsigned N> class SmallSetVector;
 template <typename T, unsigned N> class SmallVector;
 template <typename T> class SmallVectorImpl;
 template <typename T, unsigned N> class SmallPriorityWorklist;
 
 BasicBlock *InsertPreheaderForLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,

 /// FIXME: Consider changing the order in LoopInfo.
 void appendLoopsToWorklist(LoopInfo &, SmallPriorityWorklist<Loop *, 4> &);
 
 /// Recursively clone the specified loop and all of its children,
 /// mapping the blocks with the specified map.
 Loop *cloneLoop(Loop *L, Loop *PL, ValueToValueMapTy &VM,
                 LoopInfo *LI, LPPassManager *LPM);
 
 /// Add code that checks at runtime if the accessed arrays in \p PointerChecks
 /// overlap.
 ///
 /// Returns a pair of instructions where the first element is the first
 /// instruction generated in possibly a sequence of instructions and the
 /// second value is the final comparator value or NULL if no check is needed.
 std::pair<Instruction *, Instruction *>
 addRuntimeChecks(Instruction *Loc, Loop *TheLoop,
-                 const SmallVectorImpl<RuntimePointerCheck> &PointerChecks,
-                 ScalarEvolution *SE);
+                 const RuntimePointerChecking &RtPtrChecking);
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_UTILS_LOOPUTILS_H

llvm/include/llvm/Transforms/Utils/LoopVersioning.h

 class Loop;
 class LoopAccessInfo;
 class LoopInfo;
 class ScalarEvolution;
 struct RuntimeCheckingPtrGroup;
 typedef std::pair<const RuntimeCheckingPtrGroup *,
                   const RuntimeCheckingPtrGroup *>
     RuntimePointerCheck;
+class RuntimePointerChecking;
 
 template <typename T> class ArrayRef;
 
 /// This class emits a version of the loop where run-time checks ensure
 /// that may-alias pointers can't overlap.
 ///
 /// It currently only supports single-exit loops and assumes that the loop
 /// already has a preheader.
 class LoopVersioning {
 public:
   /// Expects LoopAccessInfo, Loop, LoopInfo, DominatorTree as input.
   /// It uses runtime check provided by the user. If \p UseLAIChecks is true,
   /// we will retain the default checks made by LAI. Otherwise, construct an
   /// object having no checks and we expect the user to add them.
-  LoopVersioning(const LoopAccessInfo &LAI,
-                 ArrayRef<RuntimePointerCheck> Checks, Loop *L, LoopInfo *LI,
+  LoopVersioning(const RuntimePointerChecking &RtPTrCheck,
+                 const SCEVUnionPredicate &Preds, Loop *L, LoopInfo *LI,
                  DominatorTree *DT, ScalarEvolution *SE);
 
   /// Performs the CFG manipulation part of versioning the loop including
   /// the DominatorTree and LoopInfo updates.
   ///
   /// The loop that was used to construct the class will be the "versioned" loop
   /// i.e. the loop that will receive control if all the memchecks pass.
   ///
public:
   /// loop may alias (i.e. one of the memchecks failed).
   Loop *getNonVersionedLoop() { return NonVersionedLoop; }
 
   /// Annotate memory instructions in the versioned loop with no-alias
   /// metadata based on the memchecks issued.
   ///
   /// This is just wrapper that calls prepareNoAliasMetadata and
   /// annotateInstWithNoAlias on the instructions of the versioned loop.
-  void annotateLoopWithNoAlias();
+  void annotateLoopWithNoAlias(const LoopAccessInfo &LAI);
 
   /// Set up the aliasing scopes based on the memchecks.  This needs to
   /// be called before the first call to annotateInstWithNoAlias.
   void prepareNoAliasMetadata();
 
   /// Add the noalias annotations to \p VersionedInst.
   ///
   /// \p OrigInst is the instruction corresponding to \p VersionedInst in the
private:
   /// The fall-back loop.  I.e. control flows here if pointers in the
   /// loop may alias (memchecks failed).
   Loop *NonVersionedLoop;
 
   /// This maps the instructions from VersionedLoop to their counterpart
   /// in NonVersionedLoop.
   ValueToValueMapTy VMap;
 
-  /// The set of alias checks that we are versioning for.
-  SmallVector<RuntimePointerCheck, 4> AliasChecks;
-
   /// The set of SCEV checks that we are versioning for.
   const SCEVUnionPredicate &Preds;
 
   /// Maps a pointer to the pointer checking group that the pointer
   /// belongs to.
   DenseMap<const Value *, const RuntimeCheckingPtrGroup *> PtrToGroup;
 
   /// The alias scope corresponding to a pointer checking group.
   DenseMap<const RuntimeCheckingPtrGroup *, MDNode *> GroupToScope;
 
   /// The list of alias scopes that a pointer checking group can't alias.
   DenseMap<const RuntimeCheckingPtrGroup *, MDNode *>
       GroupToNonAliasingScopeList;
 
   /// Analyses used.
-  const LoopAccessInfo &LAI;
+  const RuntimePointerChecking &RtPtrChecking;
   LoopInfo *LI;
   DominatorTree *DT;
   ScalarEvolution *SE;
 };
 
 /// Expose LoopVersioning as a pass.  Currently this is only used for
 /// unit-testing.  It adds all memchecks necessary to remove all may-aliasing
 /// array accesses from the loop.
 class LoopVersioningPass : public PassInfoMixin<LoopVersioningPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
 };
 }
 
 #endif

llvm/lib/Analysis/LoopAccessAnalysis.cpp

const SCEV *llvm::replaceSymbolicStrideSCEV(PredicatedScalarEvolution &PSE,
   }
 
   // Otherwise, just return the SCEV of the original pointer.
   return OrigSCEV;
 }
 
 RuntimeCheckingPtrGroup::RuntimeCheckingPtrGroup(
     unsigned Index, RuntimePointerChecking &RtCheck)
-    : RtCheck(RtCheck), High(RtCheck.Pointers[Index].End),
-      Low(RtCheck.Pointers[Index].Start) {
+    : High(RtCheck.Pointers[Index].End), Low(RtCheck.Pointers[Index].Start) {
   Members.push_back(Index);
 }
 
 /// Calculate Start and End points of memory access.
 /// Let's assume A is the first access and B is a memory access on N-th loop
 /// iteration. Then B is calculated as:
 ///   B = A + Step*N .
 /// Step value may be positive or negative.
static const SCEV *getMinFromExprs(const SCEV *I, const SCEV *J,
 
   if (!C)
     return nullptr;
   if (C->getValue()->isNegative())
     return J;
   return I;
 }
 
-bool RuntimeCheckingPtrGroup::addPointer(unsigned Index) {
+bool RuntimeCheckingPtrGroup::addPointer(unsigned Index,
+                                         RuntimePointerChecking &RtCheck) {
   const SCEV *Start = RtCheck.Pointers[Index].Start;
   const SCEV *End = RtCheck.Pointers[Index].End;
 
   // Compare the starts and ends with the known minimum and maximum
   // of this set. We need to know how we compare against the min/max
   // of the set in order to be able to emit memchecks.
   const SCEV *Min0 = getMinFromExprs(Start, Low, RtCheck.SE);
   if (!Min0)
for (auto MI = DepCands.member_begin(LeaderI), ME = DepCands.member_end();
         // This should limit the cost of grouping the pointers to something
         // reasonable.  If we do end up hitting this threshold, the algorithm
         // will create separate groups for all remaining pointers.
         if (TotalComparisons > MemoryCheckMergeThreshold)
           break;
 
         TotalComparisons++;
 
-        if (Group->addPointer(Pointer)) {
+        if (Group->addPointer(Pointer, *this)) {
           Merged = true;
           break;
         }
       }
 
       if (!Merged)
         // We couldn't add this pointer to any existing set or the threshold
         // for the number of comparisons has been reached. Create a new group
bool RuntimePointerChecking::needsChecking(unsigned I, unsigned J) const {
 
   // Only need to check pointers in the same alias set.
   if (PointerI.AliasSetId != PointerJ.AliasSetId)
     return false;
 
   return true;
 }
 
+void RuntimePointerChecking::removeCheckIf(
+    function_ref<bool(const RuntimePointerCheck &Check)> Predicate) {
+  Checks = {Checks.begin(), remove_if(Checks, Predicate)};
+}
+
 void RuntimePointerChecking::printChecks(
     raw_ostream &OS, const SmallVectorImpl<RuntimePointerCheck> &Checks,
     unsigned Depth) const {
   unsigned N = 0;
   for (const auto &Check : Checks) {
     const auto &First = Check.first->Members, &Second = Check.second->Members;
 
     OS.indent(Depth) << "Check " << N++ << ":\n";

llvm/lib/Transforms/Scalar/LoopDistribute.cpp

bool processLoop(std::function<const LoopAccessInfo &(Loop &)> &GetLAA) {
 
     LLVM_DEBUG(dbgs() << "\nDistributing loop: " << *L << "\n");
     // We're done forming the partitions set up the reverse mapping from
     // instructions to partitions.
     Partitions.setupPartitionIdOnInstructions();
 
     // If we need run-time checks, version the loop now.
     auto PtrToPartition = Partitions.computePartitionSetForPointers(*LAI);
-    const auto *RtPtrChecking = LAI->getRuntimePointerChecking();
-    const auto &AllChecks = RtPtrChecking->getChecks();
-    auto Checks = includeOnlyCrossPartitionChecks(AllChecks, PtrToPartition,
-                                                  RtPtrChecking);
+    RuntimePointerChecking RtPtrChecking = *LAI->getRuntimePointerChecking();
+    const auto &Checks =
+        includeOnlyCrossPartitionChecks(PtrToPartition, RtPtrChecking);
 
     if (LAI->hasConvergentOp() && !Checks.empty()) {
       return fail("RuntimeCheckWithConvergent",
                   "may not insert runtime check with convergent operation");
     }
 
     // To keep things simple have an empty preheader before we version or clone
     // the loop.  (Also split if this has no predecessor, i.e. entry, because we
     // rely on PH having a predecessor.)
     if (!PH->getSinglePredecessor() || &*PH->begin() != PH->getTerminator())
       SplitBlock(PH, PH->getTerminator(), DT, LI);
 
     if (!Pred.isAlwaysTrue() || !Checks.empty()) {
       assert(!LAI->hasConvergentOp() && "inserting illegal loop versioning");
 
       MDNode *OrigLoopID = L->getLoopID();
 
       LLVM_DEBUG(dbgs() << "\nPointers:\n");
       LLVM_DEBUG(LAI->getRuntimePointerChecking()->printChecks(dbgs(), Checks));
-      LoopVersioning LVer(*LAI, Checks, L, LI, DT, SE);
+      LoopVersioning LVer(RtPtrChecking, Pred, L, LI, DT, SE);
       LVer.versionLoop(DefsUsedOutside);
-      LVer.annotateLoopWithNoAlias();
+      LVer.annotateLoopWithNoAlias(*LAI);
 
       // The unversioned loop will not be changed, so we inherit all attributes
       // from the original loop, but remove the loop distribution metadata to
       // avoid to distribute it again.
       MDNode *UnversionedLoopID =
           makeFollowupLoopID(OrigLoopID,
                              {LLVMLoopDistributeFollowupAll,
                               LLVMLoopDistributeFollowupFallback},
public:
   const Optional<bool> &isForced() const { return IsForced; }
 
 private:
   /// Filter out checks between pointers from the same partition.
   ///
   /// \p PtrToPartition contains the partition number for pointers.  Partition
   /// number -1 means that the pointer is used in multiple partitions.  In this
   /// case we can't safely omit the check.
-  SmallVector<RuntimePointerCheck, 4> includeOnlyCrossPartitionChecks(
-      const SmallVectorImpl<RuntimePointerCheck> &AllChecks,
-      const SmallVectorImpl<int> &PtrToPartition,
-      const RuntimePointerChecking *RtPtrChecking) {
+  const SmallVectorImpl<RuntimePointerCheck> &
+  includeOnlyCrossPartitionChecks(const SmallVectorImpl<int> &PtrToPartition,
+                                  RuntimePointerChecking &RtPtrChecking) {
     SmallVector<RuntimePointerCheck, 4> Checks;
 
-    copy_if(AllChecks, std::back_inserter(Checks),
-            [&](const RuntimePointerCheck &Check) {
-              for (unsigned PtrIdx1 : Check.first->Members)
-                for (unsigned PtrIdx2 : Check.second->Members)
-                  // Only include this check if there is a pair of pointers
-                  // that require checking and the pointers fall into
-                  // separate partitions.
-                  //
-                  // (Note that we already know at this point that the two
-                  // pointer groups need checking but it doesn't follow
-                  // that each pair of pointers within the two groups need
-                  // checking as well.
-                  //
-                  // In other words we don't want to include a check just
-                  // because there is a pair of pointers between the two
-                  // pointer groups that require checks and a different
-                  // pair whose pointers fall into different partitions.)
-                  if (RtPtrChecking->needsChecking(PtrIdx1, PtrIdx2) &&
-                      !RuntimePointerChecking::arePointersInSamePartition(
-                          PtrToPartition, PtrIdx1, PtrIdx2))
-                    return true;
-              return false;
-            });
-
-    return Checks;
+    RtPtrChecking.removeCheckIf([&](const RuntimePointerCheck &Check) {
+          if (RtPtrChecking.needsChecking(PtrIdx1, PtrIdx2) &&
+      return true;
+    return RtPtrChecking.getChecks();
   }
 
   /// Check whether the loop metadata is forcing distribution to be
   /// enabled/disabled.
   void setForced() {
     Optional<const MDOperand *> Value =
         findStringMetadataForLoop(L, "llvm.loop.distribute.enable");
     if (!Value)

llvm/lib/Transforms/Scalar/LoopLoadElimination.cpp

SmallPtrSet<Value *, 4> findPointersWrittenOnForwardingPath(
     std::for_each(MemInstrs.begin(), &MemInstrs[getInstrIndex(LastLoad)],
                   InsertStorePtr);
 
     return PtrsWrittenOnFwdingPath;
   }
 
   /// Determine the pointer alias checks to prove that there are no
   /// intervening stores.
-  SmallVector<RuntimePointerCheck, 4> collectMemchecks(
-      const SmallVectorImpl<StoreToLoadForwardingCandidate> &Candidates) {
+  const SmallVectorImpl<RuntimePointerCheck> &filterMemchecks(
+      const SmallVectorImpl<StoreToLoadForwardingCandidate> &Candidates,
+      RuntimePointerChecking &RtPointerChecking) {
 
     SmallPtrSet<Value *, 4> PtrsWrittenOnFwdingPath =
         findPointersWrittenOnForwardingPath(Candidates);
 
     // Collect the pointers of the candidate loads.
     SmallPtrSet<Value *, 4> CandLoadPtrs;
     for (const auto &Candidate : Candidates)
       CandLoadPtrs.insert(Candidate.getLoadPtr());
 
-    const auto &AllChecks = LAI.getRuntimePointerChecking()->getChecks();
-    SmallVector<RuntimePointerCheck, 4> Checks;
-
-    copy_if(AllChecks, std::back_inserter(Checks),
-            [&](const RuntimePointerCheck &Check) {
-              for (auto PtrIdx1 : Check.first->Members)
-                for (auto PtrIdx2 : Check.second->Members)
-                  if (needsChecking(PtrIdx1, PtrIdx2, PtrsWrittenOnFwdingPath,
-                                    CandLoadPtrs))
-                    return true;
+    RtPointerChecking.removeCheckIf(
+        [this, &PtrsWrittenOnFwdingPath,
+         CandLoadPtrs](const RuntimePointerCheck &Check) {
                 return false;
-            });
+          return true;
 
+    auto &Checks = RtPointerChecking.getChecks();
     LLVM_DEBUG(dbgs() << "\nPointer Checks (count: " << Checks.size()
                       << "):\n");
-    LLVM_DEBUG(LAI.getRuntimePointerChecking()->printChecks(dbgs(), Checks));
-
+    LLVM_DEBUG(RtPointerChecking.printChecks(dbgs(), Checks));
     return Checks;
   }
 
   /// Perform the transformation for a candidate.
   void
   propagateStoredValueToLoadUsers(const StoreToLoadForwardingCandidate &Cand,
                                   SCEVExpander &SEE) {
     // loop:
for (const StoreToLoadForwardingCandidate &Cand : StoreToLoadDependences) {
           << Candidates.size()
           << ". Valid store-to-load forwarding across the loop backedge\n");
     }
     if (Candidates.empty())
       return false;
 
     // Check intervening may-alias stores.  These need runtime checks for alias
     // disambiguation.
-    SmallVector<RuntimePointerCheck, 4> Checks = collectMemchecks(Candidates);
+    RuntimePointerChecking RtPointerChecking = *LAI.getRuntimePointerChecking();
+    auto &Checks = filterMemchecks(Candidates, RtPointerChecking);
 
     // Too many checks are likely to outweigh the benefits of forwarding.
     if (Checks.size() > Candidates.size() * CheckPerElim) {
       LLVM_DEBUG(dbgs() << "Too many run-time checks needed.\n");
       return false;
     }
 
     if (LAI.getPSE().getUnionPredicate().getComplexity() >
if (!Checks.empty() || !LAI.getPSE().getUnionPredicate().isAlwaysTrue()) {
             dbgs() << "Versioning is needed but not allowed when optimizing "
                       "for size.\n");
         return false;
       }
 
       // Point of no-return, start the transformation.  First, version the loop
       // if necessary.
 
-      LoopVersioning LV(LAI, Checks, L, LI, DT, PSE.getSE());
+      LoopVersioning LV(RtPointerChecking, PSE.getUnionPredicate(), L, LI, DT,
+                        PSE.getSE());
       LV.versionLoop();
 
       // After versioning, some of the candidates' pointers could stop being
       // SCEVAddRecs. We need to filter them out.
       auto NoLongerGoodCandidate = [this](
           const StoreToLoadForwardingCandidate &Cand) {
         return !isa<SCEVAddRecExpr>(
                     PSE.getSCEV(Cand.Load->getPointerOperand())) ||

llvm/lib/Transforms/Scalar/LoopVersioningLICM.cpp

bool LoopVersioningLICM::runOnLoop(Loop *L, LPPassManager &LPM) {
   // Check feasiblity of LoopVersioningLICM.
   // If versioning found to be feasible and beneficial then proceed
   // else simply return, by cleaning up memory.
   if (isLegalForVersioning()) {
     // Do loop versioning.
     // Create memcheck for memory accessed inside loop.
     // Clone original loop, and set blocks properly.
     DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-    LoopVersioning LVer(*LAI, LAI->getRuntimePointerChecking()->getChecks(),
-                        CurLoop, LI, DT, SE);
+    LoopVersioning LVer(*LAI->getRuntimePointerChecking(),
+                        LAI->getPSE().getUnionPredicate(), CurLoop, LI, DT, SE);
     LVer.versionLoop();
     // Set Loop Versioning metaData for original loop.
     addStringMetadataToLoop(LVer.getNonVersionedLoop(), LICMVersioningMetaData);
     // Set Loop Versioning metaData for version loop.
     addStringMetadataToLoop(LVer.getVersionedLoop(), LICMVersioningMetaData);
     // Set "llvm.mem.parallel_loop_access" metaData to versioned loop.
     // FIXME: "llvm.mem.parallel_loop_access" annotates memory access
     // instructions, not loops.

llvm/lib/Transforms/Utils/LoopUtils.cpp

 struct PointerBounds {
   TrackingVH<Value> Start;
   TrackingVH<Value> End;
 };
 
 /// Expand code for the lower and upper bound of the pointer group \p CG
 /// in \p TheLoop.  \return the values for the bounds.
 static PointerBounds expandBounds(const RuntimeCheckingPtrGroup *CG,
+                                  const RuntimePointerChecking &RtPtrChecking,
                                   Loop *TheLoop, Instruction *Loc,
                                   SCEVExpander &Exp, ScalarEvolution *SE) {
   // TODO: Add helper to retrieve pointers to CG.
-  Value *Ptr = CG->RtCheck.Pointers[CG->Members[0]].PointerValue;
+  Value *Ptr = RtPtrChecking.Pointers[CG->Members[0]].PointerValue;
   const SCEV *Sc = SE->getSCEV(Ptr);
 
   unsigned AS = Ptr->getType()->getPointerAddressSpace();
   LLVMContext &Ctx = Loc->getContext();
 
   // Use this type for pointer arithmetic.
   Type *PtrArithTy = Type::getInt8PtrTy(Ctx, AS);
 
LLVM_DEBUG(dbgs() << "Start: " << *CG->Low << " End: " << *CG->High
                       << "\n");
     return {Start, End};
   }
 }
 
 /// Turns a collection of checks into a collection of expanded upper and
 /// lower bounds for both pointers in the check.
 static SmallVector<std::pair<PointerBounds, PointerBounds>, 4>
-expandBounds(const SmallVectorImpl<RuntimePointerCheck> &PointerChecks, Loop *L,
+expandBounds(const RuntimePointerChecking &RtPtrChecking, Loop *L,
              Instruction *Loc, ScalarEvolution *SE, SCEVExpander &Exp) {
   SmallVector<std::pair<PointerBounds, PointerBounds>, 4> ChecksWithBounds;
 
   // Here we're relying on the SCEV Expander's cache to only emit code for the
   // same bounds once.
-  transform(PointerChecks, std::back_inserter(ChecksWithBounds),
+  transform(RtPtrChecking.getChecks(), std::back_inserter(ChecksWithBounds),
             [&](const RuntimePointerCheck &Check) {
-              PointerBounds First = expandBounds(Check.first, L, Loc, Exp, SE),
-                            Second =
-                                expandBounds(Check.second, L, Loc, Exp, SE);
+              PointerBounds First = expandBounds(Check.first, RtPtrChecking, L,
+                                                 Loc, Exp, SE),
+                            Second = expandBounds(Check.second, RtPtrChecking,
+                                                  L, Loc, Exp, SE);
               return std::make_pair(First, Second);
             });
 
   return ChecksWithBounds;
 }
 
-std::pair<Instruction *, Instruction *> llvm::addRuntimeChecks(
-    Instruction *Loc, Loop *TheLoop,
-    const SmallVectorImpl<RuntimePointerCheck> &PointerChecks,
-    ScalarEvolution *SE) {
+std::pair<Instruction *, Instruction *>
+llvm::addRuntimeChecks(Instruction *Loc, Loop *TheLoop,
+                       const RuntimePointerChecking &RtPtrChecking) {
   // TODO: Move noalias annotation code from LoopVersioning here and share with LV if possible.
   // TODO: Pass  RtPtrChecking instead of PointerChecks and SE separately, if possible
   const DataLayout &DL = TheLoop->getHeader()->getModule()->getDataLayout();
+  ScalarEvolution *SE = RtPtrChecking.getSE();
   SCEVExpander Exp(*SE, DL, "induction");
-  auto ExpandedChecks = expandBounds(PointerChecks, TheLoop, Loc, SE, Exp);
+  auto ExpandedChecks = expandBounds(RtPtrChecking, TheLoop, Loc, SE, Exp);
 
   LLVMContext &Ctx = Loc->getContext();
   Instruction *FirstInst = nullptr;
   IRBuilder<> ChkBuilder(Loc);
   // Our instructions might fold to a constant.
   Value *MemoryRuntimeCheck = nullptr;
 
   // FIXME: this helper is currently a duplicate of the one in

llvm/lib/Transforms/Utils/LoopVersioning.cpp

 using namespace llvm;
 
 static cl::opt<bool>
     AnnotateNoAlias("loop-version-annotate-no-alias", cl::init(true),
                     cl::Hidden,
                     cl::desc("Add no-alias annotation for instructions that "
                              "are disambiguated by memchecks"));
 
-LoopVersioning::LoopVersioning(const LoopAccessInfo &LAI,
-                               ArrayRef<RuntimePointerCheck> Checks, Loop *L,
+LoopVersioning::LoopVersioning(const RuntimePointerChecking &RtPtrChecking,
+                               const SCEVUnionPredicate &Preds, Loop *L,
                                LoopInfo *LI, DominatorTree *DT,
                                ScalarEvolution *SE)
-    : VersionedLoop(L), NonVersionedLoop(nullptr),
-      AliasChecks(Checks.begin(), Checks.end()),
-      Preds(LAI.getPSE().getUnionPredicate()), LAI(LAI), LI(LI), DT(DT),
-      SE(SE) {
+    : VersionedLoop(L), NonVersionedLoop(nullptr), Preds(Preds),
+      RtPtrChecking(RtPtrChecking), LI(LI), DT(DT), SE(SE) {
   assert(L->getExitBlock() && "No single exit block");
   assert(L->isLoopSimplifyForm() && "Loop is not in loop-simplify form");
 }
 
 void LoopVersioning::versionLoop(
     const SmallVectorImpl<Instruction *> &DefsUsedOutside) {
   Instruction *FirstCheckInst;
   Instruction *MemRuntimeCheck;
   Value *SCEVRuntimeCheck;
   Value *RuntimeCheck = nullptr;
 
   // Add the memcheck in the original preheader (this is empty initially).
   BasicBlock *RuntimeCheckBB = VersionedLoop->getLoopPreheader();
-  const auto &RtPtrChecking = *LAI.getRuntimePointerChecking();
-  std::tie(FirstCheckInst, MemRuntimeCheck) =
-      addRuntimeChecks(RuntimeCheckBB->getTerminator(), VersionedLoop,
-                       AliasChecks, RtPtrChecking.getSE());
+  std::tie(FirstCheckInst, MemRuntimeCheck) = addRuntimeChecks(
+      RuntimeCheckBB->getTerminator(), VersionedLoop, RtPtrChecking);
 
   SCEVExpander Exp(*SE, RuntimeCheckBB->getModule()->getDataLayout(),
                    "scev.check");
   SCEVRuntimeCheck =
       Exp.expandCodeForPredicate(&Preds, RuntimeCheckBB->getTerminator());
   auto *CI = dyn_cast<ConstantInt>(SCEVRuntimeCheck);
 
   // Discard the SCEV runtime check if it is always true.

 void LoopVersioning::prepareNoAliasMetadata() {
   // We need to turn the no-alias relation between pointer checking groups into
   // no-aliasing annotations between instructions.
   //
   // We accomplish this by mapping each pointer checking group (a set of
   // pointers memchecked together) to an alias scope and then also mapping each
   // group to the list of scopes it can't alias.
 
-  const RuntimePointerChecking *RtPtrChecking = LAI.getRuntimePointerChecking();
   LLVMContext &Context = VersionedLoop->getHeader()->getContext();
 
   // First allocate an aliasing scope for each pointer checking group.
   //
   // While traversing through the checking groups in the loop, also create a
   // reverse map from pointers to the pointer checking group they were assigned
   // to.
   MDBuilder MDB(Context);
   MDNode *Domain = MDB.createAnonymousAliasScopeDomain("LVerDomain");
 
-  for (const auto &Group : RtPtrChecking->CheckingGroups) {
+  for (const auto &Group : RtPtrChecking.CheckingGroups) {
     GroupToScope[&*Group] = MDB.createAnonymousAliasScope(Domain);
 
     for (unsigned PtrIdx : Group->Members)
-      PtrToGroup[RtPtrChecking->getPointerInfo(PtrIdx).PointerValue] = &*Group;
+      PtrToGroup[RtPtrChecking.getPointerInfo(PtrIdx).PointerValue] = &*Group;
   }
 
   // Go through the checks and for each pointer group, collect the scopes for
   // each non-aliasing pointer group.
   DenseMap<const RuntimeCheckingPtrGroup *, SmallVector<Metadata *, 4>>
       GroupToNonAliasingScopes;
 
-  for (const auto &Check : AliasChecks)
+  for (const auto &Check : RtPtrChecking.getChecks())
     GroupToNonAliasingScopes[Check.first].push_back(GroupToScope[Check.second]);
 
   // Finally, transform the above to actually map to scope list which is what
   // the metadata uses.
 
   for (auto Pair : GroupToNonAliasingScopes)
     GroupToNonAliasingScopeList[Pair.first] = MDNode::get(Context, Pair.second);
 }
 
-void LoopVersioning::annotateLoopWithNoAlias() {
+void LoopVersioning::annotateLoopWithNoAlias(const LoopAccessInfo &LAI) {
   if (!AnnotateNoAlias)
     return;
 
   // First prepare the maps.
   prepareNoAliasMetadata();
 
   // Add the scope and no-alias metadata to the instructions.
   for (Instruction *I : LAI.getDepChecker().getMemoryInstructions()) {
bool runImpl(LoopInfo *LI, function_ref<const LoopAccessInfo &(Loop &)> GetLAA,
 
   // Now walk the identified inner loops.
   bool Changed = false;
   for (Loop *L : Worklist) {
     const LoopAccessInfo &LAI = GetLAA(*L);
     if (L->isLoopSimplifyForm() && !LAI.hasConvergentOp() &&
         (LAI.getNumRuntimePointerChecks() ||
          !LAI.getPSE().getUnionPredicate().isAlwaysTrue())) {
-      LoopVersioning LVer(LAI, LAI.getRuntimePointerChecking()->getChecks(), L,
-                          LI, DT, SE);
+      LoopVersioning LVer(*LAI.getRuntimePointerChecking(),
+                          LAI.getPSE().getUnionPredicate(), L, LI, DT, SE);
       LVer.versionLoop();
-      LVer.annotateLoopWithNoAlias();
+      LVer.annotateLoopWithNoAlias(LAI);
       Changed = true;
     }
   }
 
   return Changed;
 }
 
 /// Also expose this is a pass.  Currently this is only used for

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

void InnerLoopVectorizer::emitMemRuntimeChecks(Loop *L, BasicBlock *Bypass) {
   if (LoopBypassBlocks.empty()) {
     DT->changeImmediateDominator(Bypass, MemCheckBlock);
     DT->changeImmediateDominator(LoopExitBlock, MemCheckBlock);
   }
 
   Instruction *FirstCheckInst;
   Instruction *MemRuntimeCheck;
   std::tie(FirstCheckInst, MemRuntimeCheck) =
-      addRuntimeChecks(MemCheckBlock->getTerminator(), OrigLoop,
-                       RtPtrChecking.getChecks(), RtPtrChecking.getSE());
+      addRuntimeChecks(MemCheckBlock->getTerminator(), OrigLoop, RtPtrChecking);
   assert(MemRuntimeCheck && "no RT checks generated although RtPtrChecking "
                             "claimed checks are required");
   CondBranch->setCondition(MemRuntimeCheck);
 
   // We currently don't use LoopVersioning for the actual loop cloning but we
   // still use it to add the noalias metadata.
-  LVer = std::make_unique<LoopVersioning>(
-      *Legal->getLAI(),
-      Legal->getLAI()->getRuntimePointerChecking()->getChecks(), OrigLoop, LI,
-      DT, PSE.getSE());
+  LVer = std::make_unique<LoopVersioning>(*LAI->getRuntimePointerChecking(),
+                                          LAI->getPSE().getUnionPredicate(),
+                                          OrigLoop, LI, DT, PSE.getSE());
   LVer->prepareNoAliasMetadata();
 }
 
 Value *InnerLoopVectorizer::emitTransformedIndex(
     IRBuilder<> &B, Value *Index, ScalarEvolution *SE, const DataLayout &DL,
     const InductionDescriptor &ID) const {
 
   SCEVExpander Exp(*SE, DL, "induction");