[LoopVectorize] Move RuntimePointerCheck under LoopAccessAnalysis

[anemet]

Summary

This class needs to remain public because it's used by
LoopVectorizationLegality::addRuntimeCheck.

NFC. This is part of the patchset that splits out the memory dependence logic
from LoopVectorizationLegality into a new class LoopAccessAnalysis.
LoopAccessAnalysis will be used by the new Loop Distribution pass.

[hfinkel]

LGTM.

[anemet]

r227755

lib/Transforms/Vectorize/LoopVectorize.cpp

 /// \brief Propagate known metadata from one instruction to a vector of others.
 static void propagateMetadata(SmallVectorImpl<Value *> &To, const Instruction *From) {
   for (Value *V : To)
     if (Instruction *I = dyn_cast<Instruction>(V))
       propagateMetadata(I, From);
 }
 
 namespace {
-/// This struct holds information about the memory runtime legality
-/// check that a group of pointers do not overlap.
-struct RuntimePointerCheck {
-  RuntimePointerCheck() : Need(false) {}
-
-  /// Reset the state of the pointer runtime information.
-  void reset() {
-    Need = false;
-    Pointers.clear();
-    Starts.clear();
-    Ends.clear();
-    IsWritePtr.clear();
-    DependencySetId.clear();
-    AliasSetId.clear();
-  }
-
-  /// Insert a pointer and calculate the start and end SCEVs.
-  void insert(ScalarEvolution *SE, Loop *Lp, Value *Ptr, bool WritePtr,
-              unsigned DepSetId, unsigned ASId, ValueToValueMap &Strides);
-
-  /// This flag indicates if we need to add the runtime check.
-  bool Need;
-  /// Holds the pointers that we need to check.
-  SmallVector<TrackingVH<Value>, 2> Pointers;
-  /// Holds the pointer value at the beginning of the loop.
-  SmallVector<const SCEV*, 2> Starts;
-  /// Holds the pointer value at the end of the loop.
-  SmallVector<const SCEV*, 2> Ends;
-  /// Holds the information if this pointer is used for writing to memory.
-  SmallVector<bool, 2> IsWritePtr;
-  /// Holds the id of the set of pointers that could be dependent because of a
-  /// shared underlying object.
-  SmallVector<unsigned, 2> DependencySetId;
-  /// Holds the id of the disjoint alias set to which this pointer belongs.
-  SmallVector<unsigned, 2> AliasSetId;
-};
-
 /// \brief Drive the analysis of memory accesses in the loop
 ///
 /// This class is responsible for analyzing the memory accesses of a loop.  It
 /// collects the accesses and then its main helper the AccessAnalysis class
 /// finds and categorizes the dependences in buildDependenceSets.
 ///
 /// For memory dependences that can be analyzed at compile time, it determines
 /// whether the dependence is part of cycle inhibiting vectorization.  This work
VectorizerParams(unsigned MaxVectorWidth,
                      unsigned VectorizationInterleave,
                      unsigned RuntimeMemoryCheckThreshold) :
         MaxVectorWidth(MaxVectorWidth),
         VectorizationFactor(VectorizationFactor),
         VectorizationInterleave(VectorizationInterleave),
         RuntimeMemoryCheckThreshold(RuntimeMemoryCheckThreshold) {}
   };
 
+  /// This struct holds information about the memory runtime legality check that
+  /// a group of pointers do not overlap.
+  struct RuntimePointerCheck {
+    RuntimePointerCheck() : Need(false) {}
+
+    /// Reset the state of the pointer runtime information.
+    void reset() {
+      Need = false;
+      Pointers.clear();
+      Starts.clear();
+      Ends.clear();
+      IsWritePtr.clear();
+      DependencySetId.clear();
+      AliasSetId.clear();
+    }
+
+    /// Insert a pointer and calculate the start and end SCEVs.
+    void insert(ScalarEvolution *SE, Loop *Lp, Value *Ptr, bool WritePtr,
+                unsigned DepSetId, unsigned ASId, ValueToValueMap &Strides);
+
+    /// This flag indicates if we need to add the runtime check.
+    bool Need;
+    /// Holds the pointers that we need to check.
+    SmallVector<TrackingVH<Value>, 2> Pointers;
+    /// Holds the pointer value at the beginning of the loop.
+    SmallVector<const SCEV*, 2> Starts;
+    /// Holds the pointer value at the end of the loop.
+    SmallVector<const SCEV*, 2> Ends;
+    /// Holds the information if this pointer is used for writing to memory.
+    SmallVector<bool, 2> IsWritePtr;
+    /// Holds the id of the set of pointers that could be dependent because of a
+    /// shared underlying object.
+    SmallVector<unsigned, 2> DependencySetId;
+    /// Holds the id of the disjoint alias set to which this pointer belongs.
+    SmallVector<unsigned, 2> AliasSetId;
+  };
+
   LoopAccessAnalysis(Function *F, Loop *L, ScalarEvolution *SE,
                      const DataLayout *DL, const TargetLibraryInfo *TLI,
                      AliasAnalysis *AA, DominatorTree *DT,
                      const VectorizerParams &VectParams) :
       TheFunction(F), TheLoop(L), SE(SE), DL(DL), TLI(TLI), AA(AA), DT(DT),
       NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1U),
       VectParams(VectParams) {}
 
public:
 
   /// Returns true if the value V is uniform within the loop.
   bool isUniform(Value *V);
 
   /// Returns true if this instruction will remain scalar after vectorization.
   bool isUniformAfterVectorization(Instruction* I) { return Uniforms.count(I); }
 
   /// Returns the information that we collected about runtime memory check.
-  RuntimePointerCheck *getRuntimePointerCheck() {
+  LoopAccessAnalysis::RuntimePointerCheck *getRuntimePointerCheck() {
     return LAA.getRuntimePointerCheck();
   }
 
   /// This function returns the identity element (or neutral element) for
   /// the operation K.
   static Constant *getReductionIdentity(ReductionKind K, Type *Tp);
 
   unsigned getMaxSafeDepDistBytes() { return LAA.getMaxSafeDepDistBytes(); }
DEBUG(dbgs() << "LV: Replacing SCEV: " << *OrigSCEV << " by: " << *ByOne
                  << "\n");
     return ByOne;
   }
 
   // Otherwise, just return the SCEV of the original pointer.
   return SE->getSCEV(Ptr);
 }
 
-void RuntimePointerCheck::insert(ScalarEvolution *SE, Loop *Lp, Value *Ptr,
-                                 bool WritePtr, unsigned DepSetId,
-                                 unsigned ASId, ValueToValueMap &Strides) {
+void LoopAccessAnalysis::RuntimePointerCheck::insert(ScalarEvolution *SE,
+                                                     Loop *Lp, Value *Ptr,
+                                                     bool WritePtr,
+                                                     unsigned DepSetId,
+                                                     unsigned ASId,
+                                                     ValueToValueMap &Strides) {
   // Get the stride replaced scev.
   const SCEV *Sc = replaceSymbolicStrideSCEV(SE, Strides, Ptr);
   const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(Sc);
   assert(AR && "Invalid addrec expression");
   const SCEV *Ex = SE->getBackedgeTakenCount(Lp);
   const SCEV *ScEnd = AR->evaluateAtIteration(Ex, *SE);
   Pointers.push_back(Ptr);
   Starts.push_back(AR->getStart());
InnerLoopVectorizer::addStrideCheck(Instruction *Loc) {
   ChkBuilder.Insert(TheCheck, "stride.not.one");
   FirstInst = getFirstInst(FirstInst, TheCheck, Loc);
 
   return std::make_pair(FirstInst, TheCheck);
 }
 
 std::pair<Instruction *, Instruction *>
 InnerLoopVectorizer::addRuntimeCheck(Instruction *Loc) {
-  RuntimePointerCheck *PtrRtCheck = Legal->getRuntimePointerCheck();
+  LoopAccessAnalysis::RuntimePointerCheck *PtrRtCheck =
+    Legal->getRuntimePointerCheck();
 
   Instruction *tnullptr = nullptr;
   if (!PtrRtCheck->Need)
     return std::pair<Instruction *, Instruction *>(tnullptr, tnullptr);
 
   unsigned NumPointers = PtrRtCheck->Pointers.size();
   SmallVector<TrackingVH<Value> , 2> Starts;
   SmallVector<TrackingVH<Value> , 2> Ends;
public:
   void addStore(AliasAnalysis::Location &Loc) {
     Value *Ptr = const_cast<Value*>(Loc.Ptr);
     AST.add(Ptr, AliasAnalysis::UnknownSize, Loc.AATags);
     Accesses.insert(MemAccessInfo(Ptr, true));
   }
 
   /// \brief Check whether we can check the pointers at runtime for
   /// non-intersection.
-  bool canCheckPtrAtRT(RuntimePointerCheck &RtCheck, unsigned &NumComparisons,
+  bool canCheckPtrAtRT(LoopAccessAnalysis::RuntimePointerCheck &RtCheck,
+                       unsigned &NumComparisons,
                        ScalarEvolution *SE, Loop *TheLoop,
                        ValueToValueMap &Strides,
                        bool ShouldCheckStride = false);
 
   /// \brief Goes over all memory accesses, checks whether a RT check is needed
   /// and builds sets of dependent accesses.
   void buildDependenceSets() {
     processMemAccesses();

 }
 
 /// \brief Check the stride of the pointer and ensure that it does not wrap in
 /// the address space.
 static int isStridedPtr(ScalarEvolution *SE, const DataLayout *DL, Value *Ptr,
                         const Loop *Lp, ValueToValueMap &StridesMap);
 
 bool AccessAnalysis::canCheckPtrAtRT(
-    RuntimePointerCheck &RtCheck,
+    LoopAccessAnalysis::RuntimePointerCheck &RtCheck,
     unsigned &NumComparisons, ScalarEvolution *SE, Loop *TheLoop,
     ValueToValueMap &StridesMap, bool ShouldCheckStride) {
   // Find pointers with computable bounds. We are going to use this information
   // to place a runtime bound check.
   bool CanDoRT = true;
 
   bool IsDepCheckNeeded = isDependencyCheckNeeded();
   NumComparisons = 0;