[StackSafety,NFC] Remove SCEVRewriteVisitor

[vitalybuka]

Summary

Depends on D80956.

[eugenis]

Do you have any data on what it does to the analysis quality?

[vitalybuka]

rebase

[vitalybuka]

Checked on clang binary. No difference, as expected.

[eugenis]

In D80976#2070844, @vitalybuka wrote:

Checked on clang binary. No difference, as expected.

Good. Do you mean that all safe/unsafe decisions went the same way, or that even all ranges are the same or better?

LGTM

[vitalybuka]

exactly 1899483 out of 2236573 are safe in both cases

In D80976#2072111, @eugenis wrote:

In D80976#2070844, @vitalybuka wrote:

Checked on clang binary. No difference, as expected.

Good. Do you mean that all safe/unsafe decisions went the same way, or that even all ranges are the same or better?

LGTM

llvm/lib/Analysis/StackSafetyAnalysis.cpp

 static cl::opt<int> StackSafetyMaxIterations("stack-safety-max-iterations",
                                              cl::init(20), cl::Hidden);
 
 static cl::opt<int> StackSafetyPrint("stack-safety-print", cl::init(0),
                                      cl::Hidden);
 
 namespace {
 
-/// Rewrite an SCEV expression for a memory access address to an expression that
-/// represents offset from the given alloca.
-class AllocaOffsetRewriter : public SCEVRewriteVisitor<AllocaOffsetRewriter> {
-  const Value *AllocaPtr;
-
-public:
-  AllocaOffsetRewriter(ScalarEvolution &SE, const Value *AllocaPtr)
-      : SCEVRewriteVisitor(SE), AllocaPtr(AllocaPtr) {}
-
-  const SCEV *visitUnknown(const SCEVUnknown *Expr) {
-    // FIXME: look through one or several levels of definitions?
-    // This can be inttoptr(AllocaPtr) and SCEV would not unwrap
-    // it for us.
-    if (Expr->getValue() == AllocaPtr)
-      return SE.getZero(Expr->getType());
-    return Expr;
-  }
-};
-
 /// Describes use of address in as a function call argument.
 template <typename CalleeTy> struct CallInfo {
   /// Function being called.
   const CalleeTy *Callee = nullptr;
   /// Index of argument which pass address.
   size_t ParamNo = 0;
   // Offset range of address from base address (alloca or calling function
   // argument).
StackSafetyLocalAnalysis(Function &F, ScalarEvolution &SE)
         PointerSize(DL.getPointerSizeInBits()),
         UnknownRange(PointerSize, true) {}
 
   // Run the transformation on the associated function.
   FunctionInfo<GlobalValue> run();
 };
 
 ConstantRange StackSafetyLocalAnalysis::offsetFrom(Value *Addr, Value *Base) {
-  if (!SE.isSCEVable(Addr->getType()))
+  if (!SE.isSCEVable(Addr->getType()) || !SE.isSCEVable(Base->getType()))
     return UnknownRange;
 
-  AllocaOffsetRewriter Rewriter(SE, Base);
-  const SCEV *Expr = Rewriter.visit(SE.getSCEV(Addr));
-  ConstantRange Offset = SE.getSignedRange(Expr);
+  auto *PtrTy = IntegerType::getInt8PtrTy(SE.getContext());
+  const SCEV *AddrExp = SE.getTruncateOrZeroExtend(SE.getSCEV(Addr), PtrTy);
+  const SCEV *BaseExp = SE.getTruncateOrZeroExtend(SE.getSCEV(Base), PtrTy);
+  const SCEV *Diff = SE.getMinusSCEV(AddrExp, BaseExp);
+
+  ConstantRange Offset = SE.getSignedRange(Diff);
   if (isUnsafe(Offset))
     return UnknownRange;
   return Offset.sextOrTrunc(PointerSize);
 }
 
 ConstantRange
 StackSafetyLocalAnalysis::getAccessRange(Value *Addr, Value *Base,
                                          ConstantRange SizeRange) {