[SCEV][NFC] Mark methods related to Loop Disposition computation as const

[mkazantsev]

Summary

The only field they modify is the corresponding cache, which in this case
should be marked as mutable. This will allow us to verify loop disposition
which is not currently something that we do.

[nikic]

I'm not a fan of this -- I'd rather have the const_cast when you call this with UseCache=false. The thing is that SCEV caching is not at all transparent, it is order dependent and riddled with invalidation issues (as you know ^^), so pretending that that these are const does not feel right.

[mkazantsev]

const_cast may lead to UB unfortunately, and this is the type of bugs I don't want to deal with. :)

Because now verifier only calls it on a local object, I don't care enough if it goes or not. Let's just abandon it.

llvm/include/llvm/Analysis/ScalarEvolution.h

public:
   /// ICMP_EQ or ICMP_NE. ControllingFiniteLoop is set if this comparison
   /// controls the exit of a loop known to have a finite number of iterations.
   bool SimplifyICmpOperands(ICmpInst::Predicate &Pred, const SCEV *&LHS,
                             const SCEV *&RHS, unsigned Depth = 0,
                             bool ControllingFiniteLoop = false);
 
   /// Return the "disposition" of the given SCEV with respect to the given
   /// loop.
-  LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L);
+  LoopDisposition getLoopDisposition(const SCEV *S, const Loop *L) const;
 
   /// Return true if the value of the given SCEV is unchanging in the
   /// specified loop.
-  bool isLoopInvariant(const SCEV *S, const Loop *L);
+  bool isLoopInvariant(const SCEV *S, const Loop *L) const;
 
   /// Determine if the SCEV can be evaluated at loop's entry. It is true if it
   /// doesn't depend on a SCEVUnknown of an instruction which is dominated by
   /// the header of loop L.
   bool isAvailableAtLoopEntry(const SCEV *S, const Loop *L);
 
   /// Return true if the given SCEV changes value in a known way in the
   /// specified loop.  This property being true implies that the value is
   /// variant in the loop AND that we can emit an expression to compute the
   /// value of the expression at any particular loop iteration.
-  bool hasComputableLoopEvolution(const SCEV *S, const Loop *L);
+  bool hasComputableLoopEvolution(const SCEV *S, const Loop *L) const;
 
   /// Return the "disposition" of the given SCEV with respect to the given
   /// block.
   BlockDisposition getBlockDisposition(const SCEV *S, const BasicBlock *BB);
 
   /// Return true if elements that makes up the given SCEV dominate the
   /// specified basic block.
   bool dominates(const SCEV *S, const BasicBlock *BB);
DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
       ValuesAtScopes;
 
   /// Reverse map for invalidation purposes: Stores of which SCEV and which
   /// loop this is the value-at-scope of.
   DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
       ValuesAtScopesUsers;
 
   /// Memoized computeLoopDisposition results.
-  DenseMap<const SCEV *,
-           SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>>
-      LoopDispositions;
+  mutable DenseMap<const SCEV *,
+                   SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>,
+                               2> > LoopDispositions;
 
   struct LoopProperties {
     /// Set to true if the loop contains no instruction that can abnormally exit
     /// the loop (i.e. via throwing an exception, by terminating the thread
     /// cleanly or by infinite looping in a called function).  Strictly
     /// speaking, the last one is not leaving the loop, but is identical to
     /// leaving the loop for reasoning about undefined behavior.
     bool HasNoAbnormalExits;
private:
   /// Return a \c LoopProperties instance for \p L, creating one if necessary.
   LoopProperties getLoopProperties(const Loop *L);
 
   bool loopHasNoSideEffects(const Loop *L) {
     return getLoopProperties(L).HasNoSideEffects;
   }
 
   /// Compute a LoopDisposition value.
-  LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L);
+  LoopDisposition computeLoopDisposition(const SCEV *S, const Loop *L) const;
 
   /// Memoized computeBlockDisposition results.
   DenseMap<
       const SCEV *,
       SmallVector<PointerIntPair<const BasicBlock *, 2, BlockDisposition>, 2>>
       BlockDispositions;
 
   /// Compute a BlockDisposition value.

llvm/lib/Analysis/ScalarEvolution.cpp

void ScalarEvolution::print(raw_ostream &OS) const {
   OS << "Determining loop execution counts for: ";
   F.printAsOperand(OS, /*PrintType=*/false);
   OS << "\n";
   for (Loop *I : LI)
     PrintLoopInfo(OS, &SE, I);
 }
 
 ScalarEvolution::LoopDisposition
-ScalarEvolution::getLoopDisposition(const SCEV *S, const Loop *L) {
+ScalarEvolution::getLoopDisposition(const SCEV *S, const Loop *L) const {
   auto &Values = LoopDispositions[S];
   for (auto &V : Values) {
     if (V.getPointer() == L)
       return V.getInt();
   }
   Values.emplace_back(L, LoopVariant);
   LoopDisposition D = computeLoopDisposition(S, L);
   auto &Values2 = LoopDispositions[S];
   for (auto &V : llvm::reverse(Values2)) {
     if (V.getPointer() == L) {
       V.setInt(D);
       break;
     }
   }
   return D;
 }
 
 ScalarEvolution::LoopDisposition
-ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) {
+ScalarEvolution::computeLoopDisposition(const SCEV *S, const Loop *L) const {
   switch (S->getSCEVType()) {
   case scConstant:
     return LoopInvariant;
   case scPtrToInt:
   case scTruncate:
   case scZeroExtend:
   case scSignExtend:
     return getLoopDisposition(cast<SCEVCastExpr>(S)->getOperand(), L);
if (auto *I = dyn_cast<Instruction>(cast<SCEVUnknown>(S)->getValue()))
       return (L && !L->contains(I)) ? LoopInvariant : LoopVariant;
     return LoopInvariant;
   case scCouldNotCompute:
     llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
   }
   llvm_unreachable("Unknown SCEV kind!");
 }
 
-bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) {
+bool ScalarEvolution::isLoopInvariant(const SCEV *S, const Loop *L) const {
   return getLoopDisposition(S, L) == LoopInvariant;
 }
 
-bool ScalarEvolution::hasComputableLoopEvolution(const SCEV *S, const Loop *L) {
+bool ScalarEvolution::hasComputableLoopEvolution(const SCEV *S,
+                                                 const Loop *L) const {
   return getLoopDisposition(S, L) == LoopComputable;
 }
 
 ScalarEvolution::BlockDisposition
 ScalarEvolution::getBlockDisposition(const SCEV *S, const BasicBlock *BB) {
   auto &Values = BlockDispositions[S];
   for (auto &V : Values) {
     if (V.getPointer() == BB)