Remove the Forward Control Flow Integrity pass and its dependencies.

[oota-llvm.git] / include / llvm / Analysis / LoopAccessAnalysis.h

diff --git a/include/llvm/Analysis/LoopAccessAnalysis.h b/include/llvm/Analysis/LoopAccessAnalysis.h
index b54279aa1b6fedba3ac962b449b61dc7a44bfb3d..323af980ddc7c551d80fbf9cd1ea845419faaee3 100644 (file)
--- a/include/llvm/Analysis/LoopAccessAnalysis.h
+++ b/include/llvm/Analysis/LoopAccessAnalysis.h
@@ -83,7 +83,7 @@ struct VectorizerParams {
 
   /// \\brief When performing memory disambiguation checks at runtime do not
   /// make more than this number of comparisons.
-  static const unsigned RuntimeMemoryCheckThreshold;
+  static unsigned RuntimeMemoryCheckThreshold;
 };
 
 /// \brief Drive the analysis of memory accesses in the loop
@@ -120,7 +120,8 @@ public:
 
     /// 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);
+                unsigned DepSetId, unsigned ASId,
+                const ValueToValueMap &Strides);
 
     /// \brief No run-time memory checking is necessary.
     bool empty() const { return Pointers.empty(); }
@@ -151,13 +152,15 @@ public:
 
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout *DL,
                  const TargetLibraryInfo *TLI, AliasAnalysis *AA,
-                 DominatorTree *DT, ValueToValueMap &Strides);
+                 DominatorTree *DT, const ValueToValueMap &Strides);
 
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.
-  bool canVectorizeMemory() { return CanVecMem; }
+  bool canVectorizeMemory() const { return CanVecMem; }
 
-  RuntimePointerCheck *getRuntimePointerCheck() { return &PtrRtCheck; }
+  const RuntimePointerCheck *getRuntimePointerCheck() const {
+    return &PtrRtCheck;
+  }
 
   /// Return true if the block BB needs to be predicated in order for the loop
   /// to be vectorized.
@@ -165,7 +168,7 @@ public:
                                     DominatorTree *DT);
 
   /// Returns true if the value V is uniform within the loop.
-  bool isUniform(Value *V);
+  bool isUniform(Value *V) const;
 
   unsigned getMaxSafeDepDistBytes() const { return MaxSafeDepDistBytes; }
   unsigned getNumStores() const { return NumStores; }
@@ -176,23 +179,24 @@ public:
   /// 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 *> addRuntimeCheck(Instruction *Loc);
+  std::pair<Instruction *, Instruction *>
+    addRuntimeCheck(Instruction *Loc) const;
 
   /// \brief The diagnostics report generated for the analysis.  E.g. why we
   /// couldn't analyze the loop.
-  Optional<LoopAccessReport> &getReport() { return Report; }
+  const Optional<LoopAccessReport> &getReport() const { return Report; }
 
   /// \brief Print the information about the memory accesses in the loop.
   void print(raw_ostream &OS, unsigned Depth = 0) const;
 
   /// \brief Used to ensure that if the analysis was run with speculating the
   /// value of symbolic strides, the client queries it with the same assumption.
-  /// Only used in DEBUG build but we don't want NDEBUG-depedent ABI.
+  /// Only used in DEBUG build but we don't want NDEBUG-dependent ABI.
   unsigned NumSymbolicStrides;
 
 private:
   /// \brief Analyze the loop.  Substitute symbolic strides using Strides.
-  void analyzeLoop(ValueToValueMap &Strides);
+  void analyzeLoop(const ValueToValueMap &Strides);
 
   /// \brief Check if the structure of the loop allows it to be analyzed by this
   /// pass.
@@ -232,7 +236,7 @@ Value *stripIntegerCast(Value *V);
 /// Ptr.  \p PtrToStride provides the mapping between the pointer value and its
 /// stride as collected by LoopVectorizationLegality::collectStridedAccess.
 const SCEV *replaceSymbolicStrideSCEV(ScalarEvolution *SE,
-                                      ValueToValueMap &PtrToStride,
+                                      const ValueToValueMap &PtrToStride,
                                       Value *Ptr, Value *OrigPtr = nullptr);
 
 /// \brief This analysis provides dependence information for the memory accesses
@@ -260,7 +264,7 @@ public:
   /// of symbolic strides, \p Strides provides the mapping (see
   /// replaceSymbolicStrideSCEV).  If there is no cached result available run
   /// the analysis.
-  LoopAccessInfo &getInfo(Loop *L, ValueToValueMap &Strides);
+  const LoopAccessInfo &getInfo(Loop *L, const ValueToValueMap &Strides);
 
   void releaseMemory() override {
     // Invalidate the cache when the pass is freed.