[LAA] Lift RuntimePointerCheck out of LoopAccessInfo, NFC

I am planning to add more nested classes inside RuntimePointerCheck so
all these triple-nesting would be hard to follow.

Also rename it to RuntimePointerChecking (i.e. append 'ing').

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@242218 91177308-0d34-0410-b5e6-96231b3b80d8

Author: anemet

include/llvm/Analysis/LoopAccessAnalysis.h

@@ -292,6 +292,122 @@ class MemoryDepChecker {
   bool couldPreventStoreLoadForward(unsigned Distance, unsigned TypeByteSize);
 };
 
+/// This struct holds information about the memory runtime legality check that
+/// a group of pointers do not overlap.
+struct RuntimePointerChecking {
+  RuntimePointerChecking(ScalarEvolution *SE) : Need(false), SE(SE) {}
+
+  /// Reset the state of the pointer runtime information.
+  void reset() {
+    Need = false;
+    Pointers.clear();
+    Starts.clear();
+    Ends.clear();
+    IsWritePtr.clear();
+    DependencySetId.clear();
+    AliasSetId.clear();
+    Exprs.clear();
+  }
+
+  /// Insert a pointer and calculate the start and end SCEVs.
+  void insert(Loop *Lp, Value *Ptr, bool WritePtr, unsigned DepSetId,
+              unsigned ASId, const ValueToValueMap &Strides);
+
+  /// \brief No run-time memory checking is necessary.
+  bool empty() const { return Pointers.empty(); }
+
+  /// A grouping of pointers. A single memcheck is required between
+  /// two groups.
+  struct CheckingPtrGroup {
+    /// \brief Create a new pointer checking group containing a single
+    /// pointer, with index \p Index in RtCheck.
+    CheckingPtrGroup(unsigned Index, RuntimePointerChecking &RtCheck)
+        : RtCheck(RtCheck), High(RtCheck.Ends[Index]),
+          Low(RtCheck.Starts[Index]) {
+      Members.push_back(Index);
+    }
+
+    /// \brief 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);
+
+    /// 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;
+  };
+
+  /// \brief 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);
+
+  /// \brief Decide whether we need to issue a run-time check for pointer at
+  /// index \p I and \p J to prove their independence.
+  ///
+  /// If \p PtrPartition is set, it contains the partition number for
+  /// pointers (-1 if the pointer belongs to multiple partitions).  In this
+  /// case omit checks between pointers belonging to the same partition.
+  bool needsChecking(unsigned I, unsigned J,
+                     const SmallVectorImpl<int> *PtrPartition) const;
+
+  /// \brief Decide if we need to add a check between two groups of pointers,
+  /// according to needsChecking.
+  bool needsChecking(const CheckingPtrGroup &M, const CheckingPtrGroup &N,
+                     const SmallVectorImpl<int> *PtrPartition) const;
+
+  /// \brief Return true if any pointer requires run-time checking according
+  /// to needsChecking.
+  bool needsAnyChecking(const SmallVectorImpl<int> *PtrPartition) const;
+
+  /// \brief Returns the number of run-time checks required according to
+  /// needsChecking.
+  unsigned getNumberOfChecks(const SmallVectorImpl<int> *PtrPartition) const;
+
+  /// \brief Print the list run-time memory checks necessary.
+  ///
+  /// If \p PtrPartition is set, it contains the partition number for
+  /// pointers (-1 if the pointer belongs to multiple partitions).  In this
+  /// case omit checks between pointers belonging to the same partition.
+  void print(raw_ostream &OS, unsigned Depth = 0,
+             const SmallVectorImpl<int> *PtrPartition = nullptr) const;
+
+  /// 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;
+  /// Holds at position i the SCEV for the access i
+  SmallVector<const SCEV *, 2> Exprs;
+  /// Holds a partitioning of pointers into "check groups".
+  SmallVector<CheckingPtrGroup, 2> CheckingGroups;
+  /// Holds a pointer to the ScalarEvolution analysis.
+  ScalarEvolution *SE;
+};
+
 /// \brief Drive the analysis of memory accesses in the loop
 ///
 /// This class is responsible for analyzing the memory accesses of a loop.  It
@@ -308,123 +424,6 @@ class MemoryDepChecker {
 /// RuntimePointerCheck class.
 class LoopAccessInfo {
 public:
-  /// This struct holds information about the memory runtime legality check that
-  /// a group of pointers do not overlap.
-  struct RuntimePointerCheck {
-    RuntimePointerCheck(ScalarEvolution *SE) : Need(false), SE(SE) {}
-
-    /// Reset the state of the pointer runtime information.
-    void reset() {
-      Need = false;
-      Pointers.clear();
-      Starts.clear();
-      Ends.clear();
-      IsWritePtr.clear();
-      DependencySetId.clear();
-      AliasSetId.clear();
-      Exprs.clear();
-    }
-
-    /// Insert a pointer and calculate the start and end SCEVs.
-    void insert(Loop *Lp, Value *Ptr, bool WritePtr, unsigned DepSetId,
-                unsigned ASId, const ValueToValueMap &Strides);
-
-    /// \brief No run-time memory checking is necessary.
-    bool empty() const { return Pointers.empty(); }
-
-    /// A grouping of pointers. A single memcheck is required between
-    /// two groups.
-    struct CheckingPtrGroup {
-      /// \brief Create a new pointer checking group containing a single
-      /// pointer, with index \p Index in RtCheck.
-      CheckingPtrGroup(unsigned Index, RuntimePointerCheck &RtCheck)
-          : RtCheck(RtCheck), High(RtCheck.Ends[Index]),
-            Low(RtCheck.Starts[Index]) {
-        Members.push_back(Index);
-      }
-
-      /// \brief 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);
-
-      /// 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.
-      RuntimePointerCheck &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;
-    };
-
-    /// \brief 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);
-
-    /// \brief Decide whether we need to issue a run-time check for pointer at
-    /// index \p I and \p J to prove their independence.
-    ///
-    /// If \p PtrPartition is set, it contains the partition number for
-    /// pointers (-1 if the pointer belongs to multiple partitions).  In this
-    /// case omit checks between pointers belonging to the same partition.
-    bool needsChecking(unsigned I, unsigned J,
-                       const SmallVectorImpl<int> *PtrPartition) const;
-
-    /// \brief Decide if we need to add a check between two groups of pointers,
-    /// according to needsChecking.
-    bool needsChecking(const CheckingPtrGroup &M,
-                       const CheckingPtrGroup &N,
-                       const SmallVectorImpl<int> *PtrPartition) const;
-
-    /// \brief Return true if any pointer requires run-time checking according
-    /// to needsChecking.
-    bool needsAnyChecking(const SmallVectorImpl<int> *PtrPartition) const;
-
-    /// \brief Returns the number of run-time checks required according to
-    /// needsChecking.
-    unsigned getNumberOfChecks(const SmallVectorImpl<int> *PtrPartition) const;
-
-    /// \brief Print the list run-time memory checks necessary.
-    ///
-    /// If \p PtrPartition is set, it contains the partition number for
-    /// pointers (-1 if the pointer belongs to multiple partitions).  In this
-    /// case omit checks between pointers belonging to the same partition.
-    void print(raw_ostream &OS, unsigned Depth = 0,
-               const SmallVectorImpl<int> *PtrPartition = nullptr) const;
-
-    /// 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;
-    /// Holds at position i the SCEV for the access i
-    SmallVector<const SCEV *, 2> Exprs;
-    /// Holds a partitioning of pointers into "check groups".
-    SmallVector<CheckingPtrGroup, 2> CheckingGroups;
-    /// Holds a pointer to the ScalarEvolution analysis.
-    ScalarEvolution *SE;
-  };
-
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout &DL,
                  const TargetLibraryInfo *TLI, AliasAnalysis *AA,
                  DominatorTree *DT, LoopInfo *LI,
@@ -434,15 +433,15 @@ class LoopAccessInfo {
   /// no memory dependence cycles.
   bool canVectorizeMemory() const { return CanVecMem; }
 
-  const RuntimePointerCheck *getRuntimePointerCheck() const {
-    return &PtrRtCheck;
+  const RuntimePointerChecking *getRuntimePointerChecking() const {
+    return &PtrRtChecking;
   }
 
   /// \brief Number of memchecks required to prove independence of otherwise
   /// may-alias pointers.
   unsigned getNumRuntimePointerChecks(
     const SmallVectorImpl<int> *PtrPartition = nullptr) const {
-    return PtrRtCheck.getNumberOfChecks(PtrPartition);
+    return PtrRtChecking.getNumberOfChecks(PtrPartition);
   }
 
   /// Return true if the block BB needs to be predicated in order for the loop
@@ -512,7 +511,7 @@ class LoopAccessInfo {
 
   /// We need to check that all of the pointers in this list are disjoint
   /// at runtime.
-  RuntimePointerCheck PtrRtCheck;
+  RuntimePointerChecking PtrRtChecking;
 
   /// \brief the Memory Dependence Checker which can determine the
   /// loop-independent and loop-carried dependences between memory accesses.