record runtime assumptions for parametric expressions

Author: sebpop

llvm/include/llvm/Analysis/DependenceAnalysis.h

@@ -52,6 +52,8 @@ namespace llvm {
   class ScalarEvolution;
   class SCEV;
   class SCEVConstant;
+  class SCEVPredicate;
+  class SCEVUnionPredicate;
   class raw_ostream;
 
   /// Dependence - This class represents a dependence between two memory
@@ -349,12 +351,14 @@ namespace llvm {
     const SCEV *getSplitIteration(const Dependence &Dep, unsigned Level);
 
     Function *getFunction() const { return F; }
+    SCEVUnionPredicate getRuntimeAssumptions();
 
   private:
     AAResults *AA;
     ScalarEvolution *SE;
     LoopInfo *LI;
     Function *F;
+    SmallVector<const SCEVPredicate *, 4> Assumptions;
 
     /// Subscript - This private struct represents a pair of subscripts from
     /// a pair of potentially multi-dimensional array references. We use a

llvm/include/llvm/Analysis/ScalarEvolution.h

@@ -1044,12 +1044,10 @@ class ScalarEvolution {
   bool isKnownToBeAPowerOfTwo(const SCEV *S, bool OrZero = false,
                               bool OrNegative = false);
 
-  /// Check that memory access offsets in V are multiples of array element size
-  /// EltSize. Param records the first parametric expression. If the scalar
-  /// evolution V contains two or more parameters, we check that the subsequent
-  /// parametric expressions are multiples of the first parametric expression
-  /// Param.
-  bool isKnownMultipleOf(const SCEV *V, const SCEV *&Param, uint64_t EltSize);
+  /// Check that memory access offsets in S are multiples of M.  Assumptions
+  /// records the runtime predicates under which S is a multiple of M.
+  bool isKnownMultipleOf(const SCEV *S, uint64_t M,
+                         SmallVectorImpl<const SCEVPredicate *> &Assumptions);
 
   /// Splits SCEV expression \p S into two SCEVs. One of them is obtained from
   /// \p S by substitution of all AddRec sub-expression related to loop \p L

llvm/lib/Analysis/DependenceAnalysis.cpp

@@ -206,6 +206,11 @@ static void dumpExampleDependence(raw_ostream &OS, DependenceInfo *DA,
       }
     }
   }
+  SCEVUnionPredicate Assumptions = DA->getRuntimeAssumptions();
+  if (!Assumptions.isAlwaysTrue()) {
+    OS << "Runtime Assumptions:\n";
+    Assumptions.print(OS, 0);
+  }
 }
 
 void DependenceAnalysisWrapperPass::print(raw_ostream &OS,
@@ -3569,6 +3574,10 @@ bool DependenceInfo::invalidate(Function &F, const PreservedAnalyses &PA,
          Inv.invalidate<LoopAnalysis>(F, PA);
 }
 
+SCEVUnionPredicate DependenceInfo::getRuntimeAssumptions() {
+  return SCEVUnionPredicate(Assumptions, *SE);
+}
+
 // depends -
 // Returns NULL if there is no dependence.
 // Otherwise, return a Dependence with as many details as possible.
@@ -3644,12 +3653,11 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst) {
 
   const SCEV *SrcEv = SE->getMinusSCEV(SrcSCEV, SrcBase);
   const SCEV *DstEv = SE->getMinusSCEV(DstSCEV, DstBase);
-  const SCEV *Param = nullptr;
 
   if (Src != Dst) {
     // Check that memory access offsets are multiples of element sizes.
-    if (!SE->isKnownMultipleOf(SrcEv, Param, EltSize) ||
-        !SE->isKnownMultipleOf(DstEv, Param, EltSize)) {
+    if (!SE->isKnownMultipleOf(SrcEv, EltSize, Assumptions) ||
+        !SE->isKnownMultipleOf(DstEv, EltSize, Assumptions)) {
       LLVM_DEBUG(dbgs() << "can't analyze SCEV with different offsets\n");
       return std::make_unique<Dependence>(Src, Dst);
     }

llvm/lib/Analysis/ScalarEvolution.cpp

@@ -10971,107 +10971,64 @@ bool ScalarEvolution::isKnownToBeAPowerOfTwo(const SCEV *S, bool OrZero,
   return all_of(Mul->operands(), NonRecursive) && (OrZero || isKnownNonZero(S));
 }
 
-bool ScalarEvolution::isKnownMultipleOf(const SCEV *V, const SCEV *&Param,
-                                        uint64_t EltSize) {
-  if (auto *AddRec = dyn_cast<SCEVAddRecExpr>(V))
-    return isKnownMultipleOf(AddRec->getStart(), Param, EltSize) &&
-      isKnownMultipleOf(AddRec->getStepRecurrence(*this), Param, EltSize);
+bool ScalarEvolution::isKnownMultipleOf(
+    const SCEV *S, uint64_t M,
+    SmallVectorImpl<const SCEVPredicate *> &Assumptions) {
+  if (M == 0)
+    return false;
+  if (M == 1)
+    return true;
+
+  // Recursively check AddRec operands.
+  if (auto *AddRec = dyn_cast<SCEVAddRecExpr>(S))
+    return isKnownMultipleOf(AddRec->getStart(), M, Assumptions) &&
+           isKnownMultipleOf(AddRec->getStepRecurrence(*this), M, Assumptions);
 
-  if (auto *Cst = dyn_cast<SCEVConstant>(V)) {
+  // For a constant, check that "S % M == 0".
+  if (auto *Cst = dyn_cast<SCEVConstant>(S)) {
     APInt C = Cst->getAPInt();
-    // For example, alias_with_different_offsets in
-    // test/Analysis/DependenceAnalysis/DifferentOffsets.ll accesses "%A + 2":
-    //   %arrayidx = getelementptr inbounds i8, ptr %A, i64 2
-    //   store i32 42, ptr %arrayidx, align 1
-    // which is writing an i32, i.e., EltSize = 4 bytes, with an offset C = 2.
-    // isKnownMultipleOf returns false, as C=2 is not a multiple of 4.
-    return C.urem(EltSize) == 0;
-  }
-
-  // Use a lambda helper function to check V for parametric expressions.
-  // Param records the first parametric expression. If the scalar evolution V
-  // contains two or more parameters, we check that the subsequent parametric
-  // expressions are multiples of the first parametric expression Param.
-  auto checkParamsMultipleOfSize = [&](const SCEV *V,
-                                       const SCEV *&Param) -> bool {
-    if (EltSize == 1)
-      return true;
-    if (!Param) {
-      Param = V;
-      return true;
-    }
-    if (Param == V)
-      return true;
+    return C.urem(M) == 0;
+  }
 
-    // Check whether "(Param - V) % Size == 0".
-    const SCEV *Diff = getMinusSCEV(Param, V);
-    if (auto *Cst = dyn_cast<SCEVConstant>(Diff)) {
-      APInt Val = Cst->getAPInt();
-      if (Val.isZero())
-        return true;
-      APInt Rem = Val.urem(APInt(Val.getBitWidth(), EltSize, /*isSigned=*/true));
-      if (Rem.isZero())
-        // For example in test/Analysis/DependenceAnalysis/Preliminary.ll
-        // SrcSCEV = ((4 * (sext i8 %n to i64))<nsw> + %A)
-        // DstSCEV = (4 + (4 * (sext i8 %n to i64))<nsw> + %A)
-        // Param = (4 * (sext i8 %n to i64))<nsw>
-        // V = 4 + (4 * (sext i8 %n to i64))<nsw>
-        // Diff = -4, Rem = 0, and so all offsets are multiple of 4.
-        return true;
-      LLVM_DEBUG(dbgs() << "SCEV with different offsets: " << *Param << " - "
-                        << *V << " = " << *Diff << " % " << EltSize << " = "
-                        << Rem << " != 0\n");
-      return false;
-    }
-    // Check if the symbolic difference is a multiple of Size.
-    const SCEV *Val =
-        getConstant(APInt(Diff->getType()->getScalarSizeInBits(), EltSize));
-
-    // Check by using the remainder computation.
-    const SCEV *Remainder = getURemExpr(Diff, Val);
-    if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Remainder))
-      if (C->getValue()->isZero())
-        // For example test/Analysis/DependenceAnalysis/DADelin.ll
-        // SrcSCEV = {{{%A,+,(4 * %m * %o)}<%for.cond1.preheader>,+,(4 * %o)}
-        // DstSCEV = {{{%A,+,(4 * %m * %o)}<%for.cond1.preheader>,+,(4 * %o)}
-        // The strides '(4 * %m * %o)' and '(4 * %o)' are multiple of 4.
-        return true;
+  // Basic tests have failed.
+  // Record "S % M == 0" in the runtime Assumptions.
+  auto recordRuntimePredicate = [&](const SCEV *S) -> void {
+    auto *STy = dyn_cast<IntegerType>(S->getType());
+    const SCEV *SmodM =
+        getURemExpr(S, getConstant(ConstantInt::get(STy, M, false)));
+    const SCEV *Zero = getZero(STy);
 
-    // Check by using the division computation.
-    const SCEV *Q = getUDivExpr(Diff, Val);
-    const SCEV *Product = getMulExpr(Q, Val);
-    if (Diff == Product)
-      return true;
-    LLVM_DEBUG(dbgs() << "SCEV with different offsets:\n"
-                      << *Param << " - " << *V << " = " << *Diff << "\n"
-                      << "Remainder = " << *Remainder << "\n"
-                      << "Q = " << *Q << " Product = " << *Product << "\n");
-    // For example in test/Analysis/DependenceAnalysis/MIVCheckConst.ll
-    // SrcSCEV = {(80640 + (4 * (1 + %n) * %v1) + %A),+,(8 * %v1)}<%bb13>
-    // DstSCEV = {(126720 + (128 * %m) + %A),+,256}<%bb13>
-    // We fail to prove that the offsets 80640 + (4 * (1 + %n) * %v1) and
-    // (8 * %v1) are multiples of 128.
-    // Param = 80640 + (4 * (1 + %n) * %v1)
-    // (80640 + (4 * (1 + %n) * %v1)) - (8 * %v1) =
-    // (80640 + ((-4 + (4 * %n)) * %v1))
-    // Remainder = (zext i7 ((trunc i32 %v1 to i7) *
-    //                       (-4 + (4 * (trunc i32 %n to i7)))) to i32)
-    // Q = ((80640 + ((-4 + (4 * %n)) * %v1)) /u 128)
-    // Product = (128 * ((80640 + ((-4 + (4 * %n)) * %v1)) /u 128))<nuw>
-    return false;
+    // Check whether "S % M == 0" is known at compile time.
+    if (isKnownPredicate(ICmpInst::ICMP_EQ, SmodM, Zero))
+      return;
+
+    const SCEVPredicate *P =
+        getComparePredicate(ICmpInst::ICMP_EQ, SmodM, Zero);
+
+    // Detect redundant predicates.
+    for (auto *A : Assumptions)
+      if (A->implies(P, *this))
+        return;
+
+    Assumptions.push_back(P);
+    return;
   };
 
   // Expressions like "n".
-  if (isa<SCEVUnknown>(V))
-    return checkParamsMultipleOfSize(V, Param);
+  if (isa<SCEVUnknown>(S)) {
+    recordRuntimePredicate(S);
+    return true;
+  }
 
-  // Expressions like "n + 1".
-  if (isa<SCEVAddExpr>(V) || isa<SCEVMulExpr>(V))
-    return !SCEVExprContains(V, [](const SCEV *S) {
-      return isa<SCEVUnknown>(S);
-    }) || checkParamsMultipleOfSize(V, Param);
+  // Expressions like "n + 1" and "n * 3".
+  if (isa<SCEVAddExpr>(S) || isa<SCEVMulExpr>(S)) {
+    if (SCEVExprContains(S, [](const SCEV *X) { return isa<SCEVUnknown>(X); }))
+      recordRuntimePredicate(S);
+    return true;
+  }
 
-  LLVM_DEBUG(dbgs() << "SCEV node not handled yet: " << *V << "\n");
+  LLVM_DEBUG(dbgs() << "SCEV node not handled yet in isKnownMultipleOf: " << *S
+                    << "\n");
   return false;
 }
 

llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll

@@ -23,3 +23,45 @@ entry:
   %0 = load i32, ptr %A, align 1
   ret i32 %0
 }
+
+define i32 @alias_with_parametric_offset(ptr nocapture %A, i64 %n) {
+; CHECK-LABEL: 'alias_with_parametric_offset'
+; CHECK-NEXT:  Src: store i32 2, ptr %arrayidx, align 1 --> Dst: store i32 2, ptr %arrayidx, align 1
+; CHECK-NEXT:    da analyze - none!
+; CHECK-NEXT:  Src: store i32 2, ptr %arrayidx, align 1 --> Dst: %0 = load i32, ptr %A, align 1
+; CHECK-NEXT:    da analyze - flow [|<]!
+; CHECK-NEXT:  Src: %0 = load i32, ptr %A, align 1 --> Dst: %0 = load i32, ptr %A, align 1
+; CHECK-NEXT:    da analyze - none!
+; CHECK-NEXT:  Runtime Assumptions:
+; CHECK-NEXT:  Equal predicate: (zext i2 (trunc i64 %n to i2) to i64) == 0
+;
+entry:
+  %arrayidx = getelementptr inbounds i8, ptr %A, i64 %n
+  store i32 2, ptr %arrayidx, align 1
+  %0 = load i32, ptr %A, align 1
+  ret i32 %0
+}
+
+define i32 @alias_with_parametric_expr(ptr nocapture %A, i64 %n, i64 %m) {
+; CHECK-LABEL: 'alias_with_parametric_expr'
+; CHECK-NEXT:  Src: store i32 2, ptr %arrayidx, align 1 --> Dst: store i32 2, ptr %arrayidx, align 1
+; CHECK-NEXT:    da analyze - none!
+; CHECK-NEXT:  Src: store i32 2, ptr %arrayidx, align 1 --> Dst: %0 = load i32, ptr %arrayidx1, align 1
+; CHECK-NEXT:    da analyze - flow [|<]!
+; CHECK-NEXT:  Src: %0 = load i32, ptr %arrayidx1, align 1 --> Dst: %0 = load i32, ptr %arrayidx1, align 1
+; CHECK-NEXT:    da analyze - none!
+; CHECK-NEXT:  Runtime Assumptions:
+; CHECK-NEXT:  Equal predicate: (zext i2 ((trunc i64 %m to i2) + (-2 * (trunc i64 %n to i2))) to i64) == 0
+; CHECK-NEXT:  Equal predicate: (zext i2 (-2 + (trunc i64 %m to i2)) to i64) == 0
+;
+entry:
+  %mul = mul nsw i64 %n, 10
+  %add = add nsw i64 %mul, %m
+  %arrayidx = getelementptr inbounds i8, ptr %A, i64 %add
+  store i32 2, ptr %arrayidx, align 1
+
+  %add1 = add nsw i64 %m, 42
+  %arrayidx1 = getelementptr inbounds i8, ptr %A, i64 %add1
+  %0 = load i32, ptr %arrayidx1, align 1
+  ret i32 %0
+}

llvm/test/Analysis/DependenceAnalysis/MIVCheckConst.ll

@@ -41,9 +41,12 @@ define void @test(ptr %A, ptr %B, i1 %arg, i32 %n, i32 %m) #0 align 2 {
 ; CHECK-NEXT:  Src: %v27 = load <32 x i32>, ptr %v25, align 256 --> Dst: %v27 = load <32 x i32>, ptr %v25, align 256
 ; CHECK-NEXT:    da analyze - consistent input [0 S S]!
 ; CHECK-NEXT:  Src: %v27 = load <32 x i32>, ptr %v25, align 256 --> Dst: %v32 = load <32 x i32>, ptr %v30, align 128
-; CHECK-NEXT:    da analyze - confused!
+; CHECK-NEXT:    da analyze - input [* S S|<]!
 ; CHECK-NEXT:  Src: %v32 = load <32 x i32>, ptr %v30, align 128 --> Dst: %v32 = load <32 x i32>, ptr %v30, align 128
 ; CHECK-NEXT:    da analyze - consistent input [0 S S]!
+; CHECK-NEXT:  Runtime Assumptions:
+; CHECK-NEXT:  Equal predicate: (zext i7 (4 * (trunc i32 %v1 to i7) * (1 + (trunc i32 %n to i7))) to i32) == 0
+; CHECK-NEXT:  Equal predicate: (8 * (zext i4 (trunc i32 %v1 to i4) to i32))<nuw><nsw> == 0
 ;
 entry:
   %v1 = load i32, ptr %B, align 4