[TSAR, Memory] Extend private array analysis with non-constant loop bounds.

Author: yukatan1701

include/tsar/Analysis/Memory/MemoryLocationRange.h

@@ -29,6 +29,7 @@
 #include <llvm/ADT/BitmaskEnum.h>
 #include <llvm/Analysis/MemoryLocation.h>
 #include <llvm/Analysis/ScalarEvolution.h>
+#include <llvm/Analysis/ScalarEvolutionExpressions.h>
 
 namespace tsar {
 
@@ -61,6 +62,32 @@ struct MemoryLocationRange {
       return Start == Other.Start && End == Other.End && Step == Other.Step &&
              DimSize == Other.DimSize;
     }
+    inline void print(llvm::raw_ostream &OS, bool IsDebug = false) const {
+      auto PrintSCEV = [](const llvm::SCEV *Expr, llvm::raw_ostream &OS) {
+        if (!Expr)
+          OS << "(nullptr)";
+        else
+          Expr->print(OS);
+      };
+      if (IsDebug) {
+        OS << "{Start: ";
+        PrintSCEV(Start, OS);
+        OS << ", End: ";
+        PrintSCEV(End, OS);
+        OS << ", Step: ";
+        PrintSCEV(Step, OS);
+        OS << ", DimSize: " << DimSize << "}";
+      } else {
+        OS << "[";
+        PrintSCEV(Start, OS);
+        OS << ":";
+        PrintSCEV(End, OS);
+        OS << ":";
+        PrintSCEV(Step, OS);
+        OS << "," << DimSize;
+        OS << "]";
+      }
+    }
   };
 
   const llvm::Value * Ptr;
@@ -227,6 +254,18 @@ llvm::Optional<MemoryLocationRange> intersect(
     llvm::SmallVectorImpl<MemoryLocationRange> *LC = nullptr,
     llvm::SmallVectorImpl<MemoryLocationRange> *RC = nullptr,
     unsigned Threshold = 10);
+
+/// TODO: description.
+/// Returns distance between LHS and RHS.
+inline llvm::Optional<int64_t> compareSCEVs(const llvm::SCEV *LHS,
+                                            const llvm::SCEV *RHS,
+                                            llvm::ScalarEvolution *SE) {
+  assert(SE && "ScalarEvolution must be specified!");
+  assert(LHS && RHS && "SCEV must be specified!");
+  if (auto Const = llvm::dyn_cast<llvm::SCEVConstant>(SE->getMinusSCEV(LHS, RHS)))
+    return Const->getAPInt().getSExtValue();
+  return llvm::None;
+}
 }
 
 namespace llvm {

include/tsar/Analysis/Memory/MemorySetInfo.h

@@ -28,6 +28,11 @@
 #include "tsar/Analysis/Memory/MemoryLocationRange.h"
 #include <llvm/Analysis/ScalarEvolutionExpressions.h>
 
+using llvm::cast;
+using llvm::dyn_cast;
+using llvm::isa;
+using llvm::SCEVConstant;
+
 namespace tsar {
 /// Provide traits for objects stored in a MemorySet.
 ///
@@ -238,22 +243,30 @@ template<> struct MemorySetInfo<MemoryLocationRange> {
       auto &Right = RHS.DimList[I];
       if (Left == Right)
         continue;
-      auto LeftStartConst = llvm::dyn_cast<llvm::SCEVConstant>(Left.Start);
-      auto LeftEndConst = llvm::dyn_cast<llvm::SCEVConstant>(Left.End);
-      auto LeftStepConst = llvm::dyn_cast<llvm::SCEVConstant>(Left.Step);
-      auto RightStartConst = llvm::dyn_cast<llvm::SCEVConstant>(Right.Start);
-      auto RightEndConst = llvm::dyn_cast<llvm::SCEVConstant>(Right.End);
-      auto RightStepConst = llvm::dyn_cast<llvm::SCEVConstant>(Right.Step);
-      assert(LeftStepConst && RightStepConst &&
+      assert(isa<SCEVConstant>(Left.Step) && isa<SCEVConstant>(Right.Step) &&
           "Dimension step must be constant!");
-      assert(LeftStartConst && LeftEndConst && RightStartConst &&
-           RightEndConst && "Dimension bounds must be constant!");
-      auto LeftStart = LeftStartConst->getValue()->getZExtValue();
-      auto LeftEnd = LeftEndConst->getValue()->getZExtValue();
-      auto LeftStep = LeftStepConst->getValue()->getZExtValue();
-      auto RightStart = RightStartConst->getValue()->getZExtValue();
-      auto RightEnd = RightEndConst->getValue()->getZExtValue();
-      auto RightStep = RightStepConst->getValue()->getZExtValue();
+      if (!isa<SCEVConstant>(Left.Start) || !isa<SCEVConstant>(Left.End) ||
+          !isa<SCEVConstant>(Right.Start) || !isa<SCEVConstant>(Right.End)) {
+        auto CmpLeftStartRightEnd = compareSCEVs(Left.Start, Right.End, SE);
+        auto CmpRightStartLeftEnd = compareSCEVs(Right.Start, Left.End, SE);
+        if (CmpLeftStartRightEnd && (*CmpLeftStartRightEnd == 0 || *CmpLeftStartRightEnd == 1) ||
+            CmpRightStartLeftEnd && (*CmpRightStartLeftEnd == 0 || *CmpRightStartLeftEnd == 1))
+          ++JoinableDimCount;
+        else
+          return false;
+      }
+      auto LeftStart = cast<SCEVConstant>(Left.Start)->
+                       getValue()->getZExtValue();
+      auto LeftEnd = cast<SCEVConstant>(Left.End)->
+                     getValue()->getZExtValue();
+      auto LeftStep = cast<SCEVConstant>(Left.Step)->
+                      getValue()->getZExtValue();
+      auto RightStart = cast<SCEVConstant>(Right.Start)->
+                        getValue()->getZExtValue();
+      auto RightEnd = cast<SCEVConstant>(Right.End)->
+                        getValue()->getZExtValue();
+      auto RightStep = cast<SCEVConstant>(Right.Step)->
+                       getValue()->getZExtValue();
       assert(LeftStart <= LeftEnd && RightStart <= RightEnd &&
           "Start of dimension must be less or equal than End.");
       if (LeftStep != RightStep ||
@@ -285,20 +298,34 @@ template<> struct MemorySetInfo<MemoryLocationRange> {
         IsChanged = true;
       }
     } else {
+      auto SE = What.SE;
+      assert(SE && "ScalarEvolution must be specified!");
       for (size_t I = 0; I < To.DimList.size(); I++) {
         auto &DimTo = To.DimList[I];
         auto &DimFrom = What.DimList[I];
-        auto Diff = llvm::dyn_cast<llvm::SCEVConstant>(
-            What.SE->getMinusSCEV(DimTo.Start, DimFrom.Start));
-        assert(Diff && "Difference must be constant!");
-        if (Diff->getValue()->getSExtValue() > 0) {
+        if (!isa<SCEVConstant>(DimTo.Start) || !isa<SCEVConstant>(DimTo.End) ||
+            !isa<SCEVConstant>(DimFrom.Start) || !isa<SCEVConstant>(DimFrom.End)) {
+          auto CmpFromEndToStart = compareSCEVs(DimTo.Start, DimFrom.End, SE);
+          auto CmpToEndFromStart = compareSCEVs(DimFrom.Start, DimTo.End, SE);
+          if (CmpFromEndToStart && (*CmpFromEndToStart == 0 || *CmpFromEndToStart == 1)) {
+            DimTo.Start = DimFrom.Start;
+            IsChanged = true;
+          }
+          if (CmpToEndFromStart && (*CmpToEndFromStart == 0 || *CmpToEndFromStart == 1)) {
+            DimTo.End = DimFrom.End;
+            IsChanged = true;
+          }
+          continue;
+        }
+        auto DiffStart = compareSCEVs(DimTo.Start, DimFrom.Start, SE);
+        assert(DiffStart && "Difference must be constant!");
+        if (*DiffStart > 0) {
           DimTo.Start = DimFrom.Start;
           IsChanged = true;
         }
-        Diff = llvm::dyn_cast<llvm::SCEVConstant>(
-              What.SE->getMinusSCEV(DimFrom.End, DimTo.End));
-        assert(Diff && "Difference must be constant!");
-        if (Diff->getValue()->getSExtValue() > 0) {
+        auto DiffEnd = compareSCEVs(DimFrom.End, DimTo.End, SE);
+        assert(DiffEnd && "Difference must be constant!");
+        if (*DiffEnd > 0) {
           DimTo.End = DimFrom.End;
           IsChanged = true;
         }

lib/Analysis/Memory/DefinedMemory.cpp

@@ -250,6 +250,7 @@ std::pair<MemoryLocationRange, bool> aggregate(
     DFRegion *R, const MemoryLocationRange &Loc, const ReachDFFwk *Fwk) {
   typedef MemoryLocationRange::Dimension Dimension;
   typedef MemoryLocationRange::LocKind LocKind;
+  typedef ICmpInst::Predicate Predicate;
   assert(Fwk && "Data-flow framework must not be null");
   assert(!(Loc.Kind & LocKind::Collapsed) || Loc.DimList.size() > 0 &&
       "Collapsed array location must not be empty!");
@@ -351,28 +352,113 @@ std::pair<MemoryLocationRange, bool> aggregate(
         LLVM_DEBUG(dbgs() << "[AGGREGATE] Non-constant step.\n");
         break;
       }
+      auto AddRecStep = cast<SCEVConstant>(StepSCEV)->getAPInt().getSExtValue();
       auto TripCount = SE->getSmallConstantTripCount(C->getLoop());
-      if (TripCount <= 1) {
-        LLVM_DEBUG(dbgs() << "[AGGREGATE] Unknown or non-constant "
-                             "trip count.\n");
-        break;
-      }
-      auto StartValue = SE->getSignedRangeMin(SCEV).getSExtValue();
-      if (StartValue < 0) {
-        LLVM_DEBUG(dbgs() << "[AGGREGATE] Range bounds must be "
-                              "non-negative.\n");
+      if (TripCount > 1) {
+        LLVM_DEBUG(dbgs() << "[AGGREGATE] Aggregate constant range.\n");
+        int64_t SignedRangeMin = SE->getSignedRangeMin(SCEV).getSExtValue();
+        if (SignedRangeMin < 0) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Range bounds must be "
+                                "non-negative.\n");
+          break;
+        }
+        DimInfo.Start = SE->getConstant(Int64Ty, SignedRangeMin);
+        DimInfo.End = SE->getConstant(Int64Ty,
+            SignedRangeMin + std::abs(AddRecStep) * (TripCount - 2));
+      } else if (TripCount == 0) {
+        if (std::abs(AddRecStep) != 1)
+          break;
+        auto Bounds = C->getLoop()->getBounds(*SE);
+        if (!Bounds) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Failed to get loop bounds.\n");
+          break;
+        }
+        auto *InitValue = &Bounds->getInitialIVValue();
+        auto *FinalValue = &Bounds->getFinalIVValue();
+        if (!SE->isSCEVable(InitValue->getType()) ||
+            !SE->isSCEVable(FinalValue->getType())) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Loop bound is not SCEVable.\n");
+          break;
+        }
+        if (!InitValue->getType()->isIntegerTy() ||
+            !FinalValue->getType()->isIntegerTy()) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Non-integer loop bound.\n");
+          break;
+        }
+        auto Predicate = Bounds->getCanonicalPredicate();
+        if (!ICmpInst::isRelational(Predicate)) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Bad predicate.\n");
+          break;
+        }
+        if (Bounds->getDirection() == Loop::LoopBounds::Direction::Unknown) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Unknown direction.\n");
+          break;
+        }
+        auto LoopStep = cast<SCEVConstant>(
+            SE->getSCEV(Bounds->getStepValue()))->getAPInt().getSExtValue();
+        auto InitSCEV = SE->getSCEV(InitValue);
+        auto FinalSCEV = SE->getSCEV(FinalValue);
+        if (Bounds->getDirection() == Loop::LoopBounds::Direction::Increasing &&
+           (Predicate == Predicate::ICMP_SGT ||
+            Predicate == Predicate::ICMP_SGE ||
+            Predicate == Predicate::ICMP_UGT ||
+            Predicate == Predicate::ICMP_UGE) ||
+           (Bounds->getDirection() == Loop::LoopBounds::Direction::Decreasing &&
+           (Predicate == Predicate::ICMP_SLT ||
+            Predicate == Predicate::ICMP_SLE ||
+            Predicate == Predicate::ICMP_ULT ||
+            Predicate == Predicate::ICMP_ULE))) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Unpredictable predicate.\n");
+          break;
+        }
+        if (Bounds->getDirection() == Loop::LoopBounds::Direction::Increasing) {
+          if (Predicate == Predicate::ICMP_SLT ||
+              Predicate == Predicate::ICMP_ULT) {
+            FinalSCEV = SE->getMinusSCEV(FinalSCEV, SE->getOne(Int64Ty));
+          }
+        } else {
+          //std::swap(InitSCEV, FinalSCEV);
+          if (Predicate == Predicate::ICMP_SGT ||
+              Predicate == Predicate::ICMP_UGT) {
+            FinalSCEV = SE->getAddExpr(SE->getOne(Int64Ty), FinalSCEV);
+          }
+        }
+        auto ZeroItr = C->evaluateAtIteration(SE->getZero(Int64Ty), *SE);
+        auto IdxExprStep = AddRecStep / LoopStep;
+        LLVM_DEBUG(dbgs() << "[AGGREGATE] LoopStep: " << LoopStep <<
+            ", IdxExprStep: " << IdxExprStep << "\n");
+        if (LoopStep > 0 && IdxExprStep > 0) {
+          DimInfo.Start = ZeroItr;
+          DimInfo.End = C->evaluateAtIteration(
+              SE->getMinusSCEV(FinalSCEV, InitSCEV), *SE);
+        } else if (LoopStep > 0 && IdxExprStep < 0) {
+          DimInfo.Start = C->evaluateAtIteration(
+              SE->getMinusSCEV(FinalSCEV, InitSCEV), *SE);
+          DimInfo.End = ZeroItr;
+        } else if (LoopStep < 0 && IdxExprStep > 0) {
+          DimInfo.Start = C->evaluateAtIteration(
+              SE->getMinusSCEV(InitSCEV, FinalSCEV), *SE);
+          DimInfo.End = ZeroItr;
+        } else {
+          DimInfo.Start = ZeroItr;
+          DimInfo.End = C->evaluateAtIteration(
+              SE->getMinusSCEV(InitSCEV, FinalSCEV), *SE);
+        }
+        auto CmpStartEnd = compareSCEVs(DimInfo.Start, DimInfo.End, SE);
+        if (CmpStartEnd && *CmpStartEnd > 0) {
+          LLVM_DEBUG(dbgs() << "[AGGREGATE] Incorrect bounds.\n");
+          break;
+        }
+      } else {
+        LLVM_DEBUG(dbgs() << "[AGGREGATE] Invalid trip count.\n");
         break;
       }
-      DimInfo.Start = SE->getConstant(Int64Ty, StartValue);
-      auto StepValue = std::abs(cast<SCEVConstant>(StepSCEV)->getAPInt().
-          getSExtValue());
-      DimInfo.Step = SE->getConstant(Int64Ty, StepValue);
-      DimInfo.End = SE->getConstant(Int64Ty,
-          StartValue + (TripCount - 2) * StepValue);
+      DimInfo.Step = SE->getConstant(Int64Ty, std::abs(AddRecStep));
       assert(DimInfo.Start && DimInfo.End && DimInfo.Step &&
           "Dimension bounds and step must be specified!");
-      if (StartValue + StepValue * (TripCount - 2) >= DimInfo.DimSize &&
-          DimensionN != 0) {
+      if (isa<SCEVConstant>(DimInfo.End) &&
+          cast<SCEVConstant>(DimInfo.End)->getAPInt().
+            getSExtValue() >= DimInfo.DimSize && DimensionN != 0) {
         LLVM_DEBUG(dbgs() << "[AGGREGATE] Array index out of bounds.");
         break;
       }