[DA] check memory offsets are multiples of elements size

Check that the offsets from memory base address are multiples of the array
element size for a pair of memory accesses in a dependence test.

The patch adds a testcase that cannot be disambiguated by the DA.

Author: sebpop

llvm/lib/Analysis/DependenceAnalysis.cpp

@@ -3634,7 +3634,9 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst) {
   const SCEV *DstSCEV = SE->getSCEV(DstPtr);
   LLVM_DEBUG(dbgs() << "    SrcSCEV = " << *SrcSCEV << "\n");
   LLVM_DEBUG(dbgs() << "    DstSCEV = " << *DstSCEV << "\n");
-  if (SE->getPointerBase(SrcSCEV) != SE->getPointerBase(DstSCEV)) {
+  const SCEV *SrcBase = SE->getPointerBase(SrcSCEV);
+  const SCEV *DstBase = SE->getPointerBase(DstSCEV);
+  if (SrcBase != DstBase) {
     // If two pointers have different bases, trying to analyze indexes won't
     // work; we can't compare them to each other. This can happen, for example,
     // if one is produced by an LCSSA PHI node.
@@ -3645,6 +3647,100 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst) {
     return std::make_unique<Dependence>(Src, Dst);
   }
 
+  auto EltSize = SrcLoc.Size.toRaw();
+  assert(EltSize == DstLoc.Size.toRaw() && "Array element size differ");
+
+  // Check that memory access offsets in V are multiples of array EltSize.
+  std::function<bool(const SCEV *, const SCEV *&)> checkOffsets =
+      [&](const SCEV *V, const SCEV *&Param) -> bool {
+    if (auto *AddRec = dyn_cast<SCEVAddRecExpr>(V)) {
+      if (!checkOffsets(AddRec->getStart(), Param))
+        return false;
+      return checkOffsets(AddRec->getStepRecurrence(*SE), Param);
+    }
+    if (auto *Cst = dyn_cast<SCEVConstant>(V)) {
+      APInt C = Cst->getAPInt();
+      return C.srem(EltSize) == 0;
+    }
+
+    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;
+
+      // Check whether "(Param - V) % Size == 0".
+      const SCEV *Diff = SE->getMinusSCEV(Param, V);
+      if (const SCEVConstant *Cst = dyn_cast<SCEVConstant>(Diff)) {
+        APInt Val = Cst->getAPInt();
+        if (Val.isZero())
+          return true;
+        auto Rem =
+            Val.srem(APInt(Val.getBitWidth(), EltSize, /*isSigned=*/true));
+        if (Rem.isZero())
+          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 = SE->getConstant(
+          APInt(Diff->getType()->getScalarSizeInBits(), EltSize));
+
+      // Check by using the remainder computation.
+      const SCEV *Remainder = SE->getURemExpr(Diff, Val);
+      if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Remainder))
+        if (C->getValue()->isZero())
+          return true;
+
+      // Check by using the division computation.
+      const SCEV *Q = SE->getUDivExpr(Diff, Val);
+      const SCEV *Product = SE->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");
+      return false;
+    };
+    // Expressions like "n".
+    if (isa<SCEVUnknown>(V))
+      return checkParamsMultipleOfSize(V, Param);
+    // Expressions like "n + 1".
+    if (isa<SCEVAddExpr>(V))
+      return !SCEVExprContains(V, [](const SCEV *S) {
+        return isa<SCEVUnknown>(S);
+      }) || checkParamsMultipleOfSize(V, Param);
+
+    if (isa<SCEVMulExpr>(V))
+      return !SCEVExprContains(V, [](const SCEV *S) {
+        return isa<SCEVUnknown>(S);
+      }) || checkParamsMultipleOfSize(V, Param);
+
+    LLVM_DEBUG(dbgs() << "SCEV node not handled yet: " << *V << "\n");
+    return false;
+  };
+
+  // Check that memory access offsets are multiples of element sizes.
+  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 (!checkOffsets(SrcEv, Param) || !checkOffsets(DstEv, Param)) {
+      LLVM_DEBUG(dbgs() << "can't analyze SCEV with different offsets\n");
+      return std::make_unique<Dependence>(Src, Dst);
+    }
+  }
+
   // establish loop nesting levels
   establishNestingLevels(Src, Dst);
   LLVM_DEBUG(dbgs() << "    common nesting levels = " << CommonLevels << "\n");

llvm/test/Analysis/DependenceAnalysis/DifferentOffsets.ll

@@ -0,0 +1,25 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -disable-output "-passes=print<da>" -aa-pipeline=basic-aa 2>&1 \
+; RUN: | FileCheck %s
+
+; The dependence test does not handle array accesses with difference between array accesses
+; is not a multiple of the array element size.
+
+; In this test, the element size is i32 = 4 bytes and the difference between the
+; load and the store is 2 bytes.
+
+define i32 @alias_with_different_offsets(ptr nocapture %A) {
+; CHECK-LABEL: 'alias_with_different_offsets'
+; 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 - confused!
+; CHECK-NEXT:  Src: %0 = load i32, ptr %A, align 1 --> Dst: %0 = load i32, ptr %A, align 1
+; CHECK-NEXT:    da analyze - none!
+;
+entry:
+  %arrayidx = getelementptr inbounds i8, ptr %A, i64 2
+  store i32 2, ptr %arrayidx, align 1
+  %0 = load i32, ptr %A, align 1
+  ret i32 %0
+}

llvm/test/Analysis/DependenceAnalysis/MIVCheckConst.ll

@@ -41,7 +41,7 @@ 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 - input [* S S|<]!
+; CHECK-NEXT:    da analyze - confused!
 ; 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]!
 ;