[llvm] [DA] do not handle array accesses of different offsets (PR #123436)

[Ryotaro Kasuga via llvm-commits]

================
@@ -10983,6 +10983,110 @@ 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);
+
+  if (auto *Cst = dyn_cast<SCEVConstant>(V)) {
+    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;
+
+    // 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.
----------------
kasuga-fj wrote:

```suggestion
    // Check if the symbolic difference is a multiple of EltSize.
```

https://github.com/llvm/llvm-project/pull/123436