[NFC][SCEV] Changed the return type of some functions from ScalarEvolution

[dbakunevich]

Summary

The getConstant function and related functions have their return type changed from SCEV to SCEVConstant. Within the semantics of the getConstant function, it is correct to return the SCEVConstant type. The same applies to the getZero, getOne, getMinusOne and getPowerOfTwo functions. For some files, I had to connect a ScalarEvolutionExpressions file. This is necessary for implicit casting from SCEVConstant to SCEV.

[mkazantsev]

llvm/lib/Analysis/ScalarEvolution.cpp

489

cast

llvm/lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

63

????

[mkazantsev]

llvm/lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

63

Do I understand correctly that it's because auto resolve fails here?

[dbakunevich]

llvm/lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

63

Yes, you are right. I included this file so that automatic casting occurs.

[mkazantsev]

Let's not do it. Making everyone include this header just because of this reason is an overkill.

[dbakunevich]

In D145042#4191612, @mkazantsev wrote:

Let's not do it. Making everyone include this header just because of this reason is an overkill.

Why is this overkill? The ScalarEvolutionExpression class contains a SCEVConstant class definition that defines the SCEVConstant class as inherit of the SCEV class. This information allows us to cast. Without connecting a class, it is impossible to make a cast.

llvm/include/llvm/Analysis/LoopUnrollAnalyzer.h

private:
   ///
   /// In order to find the base pointer one needs to perform non-trivial
   /// traversal of the corresponding SCEV expression, so it's good to have the
   /// results saved.
   DenseMap<Value *, SimplifiedAddress> SimplifiedAddresses;
 
   /// SCEV expression corresponding to number of currently simulated
   /// iteration.
-  const SCEV *IterationNumber;
+  const SCEVConstant *IterationNumber;
 
   /// While we walk the loop instructions, we build up and maintain a mapping
   /// of simplified values specific to this iteration.  The idea is to propagate
   /// any special information we have about loads that can be replaced with
   /// constants after complete unrolling, and account for likely simplifications
   /// post-unrolling.
   DenseMap<Value *, Value *> &SimplifiedValues;
 

llvm/include/llvm/Analysis/ScalarEvolution.h

 class GEPOperator;
 class Instruction;
 class LLVMContext;
 class Loop;
 class LoopInfo;
 class raw_ostream;
 class ScalarEvolution;
 class SCEVAddRecExpr;
+class SCEVConstant;
 class SCEVUnknown;
 class StructType;
 class TargetLibraryInfo;
 class Type;
 class Value;
 enum SCEVTypes : unsigned short;
 
 extern bool VerifySCEV;
public:
   /// Return true if the SCEV expression contains a Value that has been
   /// optimised out and is now a nullptr.
   bool containsErasedValue(const SCEV *S) const;
 
   /// Return a SCEV expression for the full generality of the specified
   /// expression.
   const SCEV *getSCEV(Value *V);
 
-  const SCEV *getConstant(ConstantInt *V);
-  const SCEV *getConstant(const APInt &Val);
-  const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
+  const SCEVConstant *getConstant(ConstantInt *V);
+  const SCEVConstant *getConstant(const APInt &Val);
+  const SCEVConstant *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
   const SCEV *getLosslessPtrToIntExpr(const SCEV *Op, unsigned Depth = 0);
   const SCEV *getPtrToIntExpr(const SCEV *Op, Type *Ty);
   const SCEV *getTruncateExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getZeroExtendExprImpl(const SCEV *Op, Type *Ty,
                                     unsigned Depth = 0);
   const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
   const SCEV *getSignExtendExprImpl(const SCEV *Op, Type *Ty,
public:
   const SCEV *getUMinExpr(const SCEV *LHS, const SCEV *RHS,
                           bool Sequential = false);
   const SCEV *getUMinExpr(SmallVectorImpl<const SCEV *> &Operands,
                           bool Sequential = false);
   const SCEV *getUnknown(Value *V);
   const SCEV *getCouldNotCompute();
 
   /// Return a SCEV for the constant 0 of a specific type.
-  const SCEV *getZero(Type *Ty) { return getConstant(Ty, 0); }
+  const SCEVConstant *getZero(Type *Ty) { return getConstant(Ty, 0); }
 
   /// Return a SCEV for the constant 1 of a specific type.
-  const SCEV *getOne(Type *Ty) { return getConstant(Ty, 1); }
+  const SCEVConstant *getOne(Type *Ty) { return getConstant(Ty, 1); }
 
   /// Return a SCEV for the constant \p Power of two.
-  const SCEV *getPowerOfTwo(Type *Ty, unsigned Power) {
+  const SCEVConstant *getPowerOfTwo(Type *Ty, unsigned Power) {
     assert(Power < getTypeSizeInBits(Ty) && "Power out of range");
     return getConstant(APInt::getOneBitSet(getTypeSizeInBits(Ty), Power));
   }
 
   /// Return a SCEV for the constant -1 of a specific type.
-  const SCEV *getMinusOne(Type *Ty) {
+  const SCEVConstant *getMinusOne(Type *Ty) {
     return getConstant(Ty, -1, /*isSigned=*/true);
   }
 
   /// Return an expression for a TypeSize.
   const SCEV *getSizeOfExpr(Type *IntTy, TypeSize Size);
 
   /// Return an expression for the alloc size of AllocTy that is type IntTy
   const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);

llvm/lib/Analysis/ScalarEvolution.cpp

 
 SCEVCouldNotCompute::SCEVCouldNotCompute() :
   SCEV(FoldingSetNodeIDRef(), scCouldNotCompute, 0) {}
 
 bool SCEVCouldNotCompute::classof(const SCEV *S) {
   return S->getSCEVType() == scCouldNotCompute;
 }
 
-const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
+const SCEVConstant *ScalarEvolution::getConstant(ConstantInt *V) {
   FoldingSetNodeID ID;
   ID.AddInteger(scConstant);
   ID.AddPointer(V);
   void *IP = nullptr;
-  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP)) return S;
-  SCEV *S = new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
+  if (const SCEV *S = UniqueSCEVs.FindNodeOrInsertPos(ID, IP))
+    return cast<SCEVConstant>(S);
+  SCEVConstant *S =
+      new (SCEVAllocator) SCEVConstant(ID.Intern(SCEVAllocator), V);
   UniqueSCEVs.InsertNode(S, IP);
   return S;
 }
 
-const SCEV *ScalarEvolution::getConstant(const APInt &Val) {
+const SCEVConstant *ScalarEvolution::getConstant(const APInt &Val) {
   return getConstant(ConstantInt::get(getContext(), Val));
 }
 
-const SCEV *
-ScalarEvolution::getConstant(Type *Ty, uint64_t V, bool isSigned) {
+const SCEVConstant *ScalarEvolution::getConstant(Type *Ty, uint64_t V,
+                                                 bool isSigned) {
   IntegerType *ITy = cast<IntegerType>(getEffectiveSCEVType(Ty));
   return getConstant(ConstantInt::get(ITy, V, isSigned));
 }
 
 SCEVCastExpr::SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
                            const SCEV *op, Type *ty)
     : SCEV(ID, SCEVTy, computeExpressionSize(op)), Op(op), Ty(ty) {}
 

llvm/lib/Analysis/StackSafetyAnalysis.cpp

 
 #include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
 #include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/StackLifetime.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"

llvm/lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

 // - When (i' - i) is constant but i and i' are not, we could still perform
 //   SLSR.
 
 #include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/IRBuilder.h"

llvm/unittests/Analysis/DDGTest.cpp

 //===- DDGTest.cpp - DDGAnalysis unit tests -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/DDG.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;