[llvm] [DA] Add option to enable specific dependence test only (PR #164245)
Ryotaro Kasuga via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 20 05:13:41 PDT 2025
https://github.com/kasuga-fj created https://github.com/llvm/llvm-project/pull/164245
None
>From c197ec7a269f52e54dd29d28663b53715fc5b5d6 Mon Sep 17 00:00:00 2001
From: Ryotaro Kasuga <kasuga.ryotaro at fujitsu.com>
Date: Fri, 17 Oct 2025 11:46:17 +0000
Subject: [PATCH] [DA] Add option to enable specific dependence test only
---
llvm/lib/Analysis/DependenceAnalysis.cpp | 82 ++++-
.../Analysis/DependenceAnalysis/ExactSIV.ll | 318 ------------------
.../DependenceAnalysis/exact-siv-overflow.ll | 124 +++++++
.../run-specific-dependence-test.ll | 73 ++++
4 files changed, 270 insertions(+), 327 deletions(-)
create mode 100644 llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll
create mode 100644 llvm/test/Analysis/DependenceAnalysis/run-specific-dependence-test.ll
diff --git a/llvm/lib/Analysis/DependenceAnalysis.cpp b/llvm/lib/Analysis/DependenceAnalysis.cpp
index 805b6820e1e1c..b155dd11066b8 100644
--- a/llvm/lib/Analysis/DependenceAnalysis.cpp
+++ b/llvm/lib/Analysis/DependenceAnalysis.cpp
@@ -122,11 +122,49 @@ static cl::opt<unsigned> MIVMaxLevelThreshold(
cl::desc("Maximum depth allowed for the recursive algorithm used to "
"explore MIV direction vectors."));
-static cl::opt<bool> RunSIVRoutinesOnly(
- "da-run-siv-routines-only", cl::init(false), cl::ReallyHidden,
- cl::desc("Run only SIV routines and disable others (ZIV, RDIV, and MIV). "
- "The purpose is mainly to exclude the influence of those routines "
- "in regression tests for SIV routines."));
+namespace {
+
+/// Types of dependence test routines.
+enum class DependenceTestType {
+ All,
+ StrongSIV,
+ WeakCrossingSIV,
+ ExactSIV,
+ WeakZeroSIV,
+ ExactRDIV,
+ SymbolicRDIV,
+ GCDMIV,
+ BanerjeeMIV,
+};
+
+} // anonymous namespace
+
+static cl::opt<DependenceTestType> EnableDependenceTest(
+ "da-enable-dependence-test", cl::init(DependenceTestType::All),
+ cl::ReallyHidden,
+ cl::desc("Run only specified dependence test routine and disable others. "
+ "The purpose is mainly to exclude the influence of other "
+ "dependence test routines in regression tests. If set to All, all "
+ "dependence test routines are enabled."),
+ cl::values(clEnumValN(DependenceTestType::All, "all",
+ "Enable all dependence test routines."),
+ clEnumValN(DependenceTestType::StrongSIV, "strong-siv",
+ "Enable only Strong SIV test."),
+ clEnumValN(DependenceTestType::WeakCrossingSIV,
+ "weak-crossing-siv",
+ "Enable only Weak-Crossing SIV test."),
+ clEnumValN(DependenceTestType::ExactSIV, "exact-siv",
+ "Enable only Exact SIV test."),
+ clEnumValN(DependenceTestType::WeakZeroSIV, "weak-zero-siv",
+ "Enable only Weak-Zero SIV test."),
+ clEnumValN(DependenceTestType::ExactRDIV, "exact-rdiv",
+ "Enable only Exact RDIV test."),
+ clEnumValN(DependenceTestType::SymbolicRDIV, "symbolic-rdiv",
+ "Enable only Symbolic RDIV test."),
+ clEnumValN(DependenceTestType::GCDMIV, "gcd-miv",
+ "Enable only GCD MIV test."),
+ clEnumValN(DependenceTestType::BanerjeeMIV, "banerjee-miv",
+ "Enable only Banerjee MIV test.")));
//===----------------------------------------------------------------------===//
// basics
@@ -1273,6 +1311,13 @@ static const SCEV *minusSCEVNoSignedOverflow(const SCEV *A, const SCEV *B,
return nullptr;
}
+/// Returns true iff \p Test is enabled.
+static bool isDependenceTestEnabled(DependenceTestType Test) {
+ if (EnableDependenceTest == DependenceTestType::All)
+ return true;
+ return EnableDependenceTest == Test;
+}
+
// testZIV -
// When we have a pair of subscripts of the form [c1] and [c2],
// where c1 and c2 are both loop invariant, we attack it using
@@ -1334,6 +1379,9 @@ bool DependenceInfo::strongSIVtest(const SCEV *Coeff, const SCEV *SrcConst,
const Loop *CurDstLoop, unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const {
+ if (!isDependenceTestEnabled(DependenceTestType::StrongSIV))
+ return false;
+
LLVM_DEBUG(dbgs() << "\tStrong SIV test\n");
LLVM_DEBUG(dbgs() << "\t Coeff = " << *Coeff);
LLVM_DEBUG(dbgs() << ", " << *Coeff->getType() << "\n");
@@ -1468,6 +1516,9 @@ bool DependenceInfo::weakCrossingSIVtest(
const Loop *CurSrcLoop, const Loop *CurDstLoop, unsigned Level,
FullDependence &Result, Constraint &NewConstraint,
const SCEV *&SplitIter) const {
+ if (!isDependenceTestEnabled(DependenceTestType::WeakCrossingSIV))
+ return false;
+
LLVM_DEBUG(dbgs() << "\tWeak-Crossing SIV test\n");
LLVM_DEBUG(dbgs() << "\t Coeff = " << *Coeff << "\n");
LLVM_DEBUG(dbgs() << "\t SrcConst = " << *SrcConst << "\n");
@@ -1726,6 +1777,9 @@ bool DependenceInfo::exactSIVtest(const SCEV *SrcCoeff, const SCEV *DstCoeff,
const Loop *CurDstLoop, unsigned Level,
FullDependence &Result,
Constraint &NewConstraint) const {
+ if (!isDependenceTestEnabled(DependenceTestType::ExactSIV))
+ return false;
+
LLVM_DEBUG(dbgs() << "\tExact SIV test\n");
LLVM_DEBUG(dbgs() << "\t SrcCoeff = " << *SrcCoeff << " = AM\n");
LLVM_DEBUG(dbgs() << "\t DstCoeff = " << *DstCoeff << " = BM\n");
@@ -1905,6 +1959,9 @@ bool DependenceInfo::weakZeroSrcSIVtest(
const SCEV *DstCoeff, const SCEV *SrcConst, const SCEV *DstConst,
const Loop *CurSrcLoop, const Loop *CurDstLoop, unsigned Level,
FullDependence &Result, Constraint &NewConstraint) const {
+ if (!isDependenceTestEnabled(DependenceTestType::WeakZeroSIV))
+ return false;
+
// For the WeakSIV test, it's possible the loop isn't common to
// the Src and Dst loops. If it isn't, then there's no need to
// record a direction.
@@ -2013,6 +2070,9 @@ bool DependenceInfo::weakZeroDstSIVtest(
const SCEV *SrcCoeff, const SCEV *SrcConst, const SCEV *DstConst,
const Loop *CurSrcLoop, const Loop *CurDstLoop, unsigned Level,
FullDependence &Result, Constraint &NewConstraint) const {
+ if (!isDependenceTestEnabled(DependenceTestType::WeakZeroSIV))
+ return false;
+
// For the WeakSIV test, it's possible the loop isn't common to the
// Src and Dst loops. If it isn't, then there's no need to record a direction.
LLVM_DEBUG(dbgs() << "\tWeak-Zero (dst) SIV test\n");
@@ -2096,8 +2156,9 @@ bool DependenceInfo::exactRDIVtest(const SCEV *SrcCoeff, const SCEV *DstCoeff,
const SCEV *SrcConst, const SCEV *DstConst,
const Loop *SrcLoop, const Loop *DstLoop,
FullDependence &Result) const {
- if (RunSIVRoutinesOnly)
+ if (!isDependenceTestEnabled(DependenceTestType::ExactRDIV))
return false;
+
LLVM_DEBUG(dbgs() << "\tExact RDIV test\n");
LLVM_DEBUG(dbgs() << "\t SrcCoeff = " << *SrcCoeff << " = AM\n");
LLVM_DEBUG(dbgs() << "\t DstCoeff = " << *DstCoeff << " = BM\n");
@@ -2242,8 +2303,9 @@ bool DependenceInfo::symbolicRDIVtest(const SCEV *A1, const SCEV *A2,
const SCEV *C1, const SCEV *C2,
const Loop *Loop1,
const Loop *Loop2) const {
- if (RunSIVRoutinesOnly)
+ if (!isDependenceTestEnabled(DependenceTestType::SymbolicRDIV))
return false;
+
++SymbolicRDIVapplications;
LLVM_DEBUG(dbgs() << "\ttry symbolic RDIV test\n");
LLVM_DEBUG(dbgs() << "\t A1 = " << *A1);
@@ -2557,8 +2619,9 @@ bool DependenceInfo::accumulateCoefficientsGCD(const SCEV *Expr,
// to "a common divisor".
bool DependenceInfo::gcdMIVtest(const SCEV *Src, const SCEV *Dst,
FullDependence &Result) const {
- if (RunSIVRoutinesOnly)
+ if (!isDependenceTestEnabled(DependenceTestType::GCDMIV))
return false;
+
LLVM_DEBUG(dbgs() << "starting gcd\n");
++GCDapplications;
unsigned BitWidth = SE->getTypeSizeInBits(Src->getType());
@@ -2725,8 +2788,9 @@ bool DependenceInfo::gcdMIVtest(const SCEV *Src, const SCEV *Dst,
bool DependenceInfo::banerjeeMIVtest(const SCEV *Src, const SCEV *Dst,
const SmallBitVector &Loops,
FullDependence &Result) const {
- if (RunSIVRoutinesOnly)
+ if (!isDependenceTestEnabled(DependenceTestType::BanerjeeMIV))
return false;
+
LLVM_DEBUG(dbgs() << "starting Banerjee\n");
++BanerjeeApplications;
LLVM_DEBUG(dbgs() << " Src = " << *Src << '\n');
diff --git a/llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll b/llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll
index e8e7cb11bb23e..b6b44ad4bfc53 100644
--- a/llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll
+++ b/llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll
@@ -1,8 +1,6 @@
; 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
-; RUN: opt < %s -disable-output "-passes=print<da>" -da-run-siv-routines-only 2>&1 \
-; RUN: | FileCheck %s --check-prefix=CHECK-SIV-ONLY
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.6.0"
@@ -27,20 +25,6 @@ define void @exact0(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact0'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [<=|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -85,20 +69,6 @@ define void @exact1(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact1'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: %0 = load i32, ptr %arrayidx3, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx3, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -144,20 +114,6 @@ define void @exact2(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact2'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -201,20 +157,6 @@ define void @exact3(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact3'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [>]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -258,20 +200,6 @@ define void @exact4(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact4'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [>]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -315,20 +243,6 @@ define void @exact5(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact5'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [=>|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -372,20 +286,6 @@ define void @exact6(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact6'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [=>|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -429,20 +329,6 @@ define void @exact7(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact7'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [*|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: %0 = load i32, ptr %arrayidx1, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx1, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -486,20 +372,6 @@ define void @exact8(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact8'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -543,20 +415,6 @@ define void @exact9(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact9'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [>]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -600,20 +458,6 @@ define void @exact10(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact10'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [>]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -657,20 +501,6 @@ define void @exact11(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact11'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [=>|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -714,20 +544,6 @@ define void @exact12(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact12'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [=>|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -771,20 +587,6 @@ define void @exact13(ptr %A, ptr %B) nounwind uwtable ssp {
; CHECK-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
; CHECK-NEXT: da analyze - none!
;
-; CHECK-SIV-ONLY-LABEL: 'exact13'
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %conv, ptr %arrayidx, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - flow [*|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %conv, ptr %arrayidx, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: %0 = load i32, ptr %arrayidx2, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: %0 = load i32, ptr %arrayidx2, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - confused!
-; CHECK-SIV-ONLY-NEXT: Src: store i32 %0, ptr %B.addr.01, align 4 --> Dst: store i32 %0, ptr %B.addr.01, align 4
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
entry:
br label %for.body
@@ -807,123 +609,3 @@ for.body: ; preds = %entry, %for.body
for.end: ; preds = %for.body
ret void
}
-
-;; max_i = INT64_MAX/6 // 1537228672809129301
-;; for (long long i = 0; i <= max_i; i++) {
-;; A[-6*i + INT64_MAX] = 0;
-;; if (i)
-;; A[3*i - 2] = 1;
-;; }
-;;
-;; FIXME: DependencyAnalsysis currently detects no dependency between
-;; `A[-6*i + INT64_MAX]` and `A[3*i - 2]`, but it does exist. For example,
-;;
-;; | memory location | -6*i + INT64_MAX | 3*i - 2
-;; |------------------------|------------------------|-----------
-;; | A[1] | i = max_i | i = 1
-;; | A[4611686018427387901] | i = 768614336404564651 | i = max_i
-;;
-;; Actually,
-;; * 1 = -6*max_i + INT64_MAX = 3*1 - 2
-;; * 4611686018427387901 = -6*768614336404564651 + INT64_MAX = 3*max_i - 2
-;;
-
-define void @exact14(ptr %A) {
-; CHECK-LABEL: 'exact14'
-; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
-; CHECK-NEXT: da analyze - none!
-; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-NEXT: da analyze - none!
-; CHECK-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-NEXT: da analyze - none!
-;
-; CHECK-SIV-ONLY-LABEL: 'exact14'
-; CHECK-SIV-ONLY-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - output [*|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
-entry:
- br label %loop.header
-
-loop.header:
- %i = phi i64 [ 0, %entry ], [ %i.inc, %loop.latch ]
- %subscript.0 = phi i64 [ 9223372036854775807, %entry ], [ %subscript.0.next, %loop.latch ]
- %subscript.1 = phi i64 [ -2, %entry ], [ %subscript.1.next, %loop.latch ]
- %idx.0 = getelementptr inbounds i8, ptr %A, i64 %subscript.0
- store i8 0, ptr %idx.0
- %cond.store = icmp ne i64 %i, 0
- br i1 %cond.store, label %if.store, label %loop.latch
-
-if.store:
- %idx.1 = getelementptr inbounds i8, ptr %A, i64 %subscript.1
- store i8 1, ptr %idx.1
- br label %loop.latch
-
-loop.latch:
- %i.inc = add nuw nsw i64 %i, 1
- %subscript.0.next = add nsw i64 %subscript.0, -6
- %subscript.1.next = add nsw i64 %subscript.1, 3
- %exitcond = icmp sgt i64 %i.inc, 1537228672809129301
- br i1 %exitcond, label %exit, label %loop.header
-
-exit:
- ret void
-}
-
-;; A generalized version of @exact14.
-;;
-;; for (long long i = 0; i <= n / 6; i++) {
-;; A[-6*i + n] = 0;
-;; if (i)
-;; A[3*i - 2] = 1;
-;; }
-
-define void @exact15(ptr %A, i64 %n) {
-; CHECK-LABEL: 'exact15'
-; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
-; CHECK-NEXT: da analyze - none!
-; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-NEXT: da analyze - output [*|<]!
-; CHECK-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-NEXT: da analyze - none!
-;
-; CHECK-SIV-ONLY-LABEL: 'exact15'
-; CHECK-SIV-ONLY-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-; CHECK-SIV-ONLY-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - output [*|<]!
-; CHECK-SIV-ONLY-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
-; CHECK-SIV-ONLY-NEXT: da analyze - none!
-;
-entry:
- %bound = sdiv i64 %n, 6
- %guard = icmp sgt i64 %n, 0
- br i1 %guard, label %loop.header, label %exit
-
-loop.header:
- %i = phi i64 [ 0, %entry ], [ %i.inc, %loop.latch ]
- %subscript.0 = phi i64 [ %n, %entry ], [ %subscript.0.next, %loop.latch ]
- %subscript.1 = phi i64 [ -2, %entry ], [ %subscript.1.next, %loop.latch ]
- %idx.0 = getelementptr inbounds i8, ptr %A, i64 %subscript.0
- store i8 0, ptr %idx.0
- %cond.store = icmp ne i64 %i, 0
- br i1 %cond.store, label %if.store, label %loop.latch
-
-if.store:
- %idx.1 = getelementptr inbounds i8, ptr %A, i64 %subscript.1
- store i8 1, ptr %idx.1
- br label %loop.latch
-
-loop.latch:
- %i.inc = add nuw nsw i64 %i, 1
- %subscript.0.next = add nsw i64 %subscript.0, -6
- %subscript.1.next = add nsw i64 %subscript.1, 3
- %exitcond = icmp sgt i64 %i.inc, %bound
- br i1 %exitcond, label %exit, label %loop.header
-
-exit:
- ret void
-}
diff --git a/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll b/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll
new file mode 100644
index 0000000000000..59e2ed3c7e35f
--- /dev/null
+++ b/llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll
@@ -0,0 +1,124 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -disable-output "-passes=print<da>" 2>&1 | FileCheck %s
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=exact-siv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-EXACT-SIV
+
+;; max_i = INT64_MAX/6 // 1537228672809129301
+;; for (long long i = 0; i <= max_i; i++) {
+;; A[-6*i + INT64_MAX] = 0;
+;; if (i)
+;; A[3*i - 2] = 1;
+;; }
+;;
+;; FIXME: DependencyAnalsysis currently detects no dependency between
+;; `A[-6*i + INT64_MAX]` and `A[3*i - 2]`, but it does exist. For example,
+;;
+;; | memory location | -6*i + INT64_MAX | 3*i - 2
+;; |------------------------|------------------------|-----------
+;; | A[1] | i = max_i | i = 1
+;; | A[4611686018427387901] | i = 768614336404564651 | i = max_i
+;;
+;; Actually,
+;; * 1 = -6*max_i + INT64_MAX = 3*1 - 2
+;; * 4611686018427387901 = -6*768614336404564651 + INT64_MAX = 3*max_i - 2
+;;
+
+define void @exactsiv_const_ovfl(ptr %A) {
+; CHECK-LABEL: 'exactsiv_const_ovfl'
+; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
+; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-NEXT: da analyze - none!
+;
+; CHECK-EXACT-SIV-LABEL: 'exactsiv_const_ovfl'
+; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]!
+; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - output [*|<]!
+; CHECK-EXACT-SIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]!
+;
+entry:
+ br label %loop.header
+
+loop.header:
+ %i = phi i64 [ 0, %entry ], [ %i.inc, %loop.latch ]
+ %subscript.0 = phi i64 [ 9223372036854775807, %entry ], [ %subscript.0.next, %loop.latch ]
+ %subscript.1 = phi i64 [ -2, %entry ], [ %subscript.1.next, %loop.latch ]
+ %idx.0 = getelementptr inbounds i8, ptr %A, i64 %subscript.0
+ store i8 0, ptr %idx.0
+ %cond.store = icmp ne i64 %i, 0
+ br i1 %cond.store, label %if.store, label %loop.latch
+
+if.store:
+ %idx.1 = getelementptr inbounds i8, ptr %A, i64 %subscript.1
+ store i8 1, ptr %idx.1
+ br label %loop.latch
+
+loop.latch:
+ %i.inc = add nuw nsw i64 %i, 1
+ %subscript.0.next = add nsw i64 %subscript.0, -6
+ %subscript.1.next = add nsw i64 %subscript.1, 3
+ %exitcond = icmp sgt i64 %i.inc, 1537228672809129301
+ br i1 %exitcond, label %exit, label %loop.header
+
+exit:
+ ret void
+}
+
+;; A generalized version of the above case.
+;;
+;; for (long long i = 0; i <= n / 6; i++) {
+;; A[-6*i + n] = 0;
+;; if (i)
+;; A[3*i - 2] = 1;
+;; }
+
+define void @exactsiv_param_ovfl(ptr %A, i64 %n) {
+; CHECK-LABEL: 'exactsiv_param_ovfl'
+; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
+; CHECK-NEXT: da analyze - none!
+; CHECK-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-NEXT: da analyze - output [*|<]!
+; CHECK-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-NEXT: da analyze - none!
+;
+; CHECK-EXACT-SIV-LABEL: 'exactsiv_param_ovfl'
+; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 0, ptr %idx.0, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]!
+; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %idx.0, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - output [*|<]!
+; CHECK-EXACT-SIV-NEXT: Src: store i8 1, ptr %idx.1, align 1 --> Dst: store i8 1, ptr %idx.1, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]!
+;
+entry:
+ %bound = sdiv i64 %n, 6
+ %guard = icmp sgt i64 %n, 0
+ br i1 %guard, label %loop.header, label %exit
+
+loop.header:
+ %i = phi i64 [ 0, %entry ], [ %i.inc, %loop.latch ]
+ %subscript.0 = phi i64 [ %n, %entry ], [ %subscript.0.next, %loop.latch ]
+ %subscript.1 = phi i64 [ -2, %entry ], [ %subscript.1.next, %loop.latch ]
+ %idx.0 = getelementptr inbounds i8, ptr %A, i64 %subscript.0
+ store i8 0, ptr %idx.0
+ %cond.store = icmp ne i64 %i, 0
+ br i1 %cond.store, label %if.store, label %loop.latch
+
+if.store:
+ %idx.1 = getelementptr inbounds i8, ptr %A, i64 %subscript.1
+ store i8 1, ptr %idx.1
+ br label %loop.latch
+
+loop.latch:
+ %i.inc = add nuw nsw i64 %i, 1
+ %subscript.0.next = add nsw i64 %subscript.0, -6
+ %subscript.1.next = add nsw i64 %subscript.1, 3
+ %exitcond = icmp sgt i64 %i.inc, %bound
+ br i1 %exitcond, label %exit, label %loop.header
+
+exit:
+ ret void
+}
diff --git a/llvm/test/Analysis/DependenceAnalysis/run-specific-dependence-test.ll b/llvm/test/Analysis/DependenceAnalysis/run-specific-dependence-test.ll
new file mode 100644
index 0000000000000..737359377c9bb
--- /dev/null
+++ b/llvm/test/Analysis/DependenceAnalysis/run-specific-dependence-test.ll
@@ -0,0 +1,73 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 6
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=all 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-ALL
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=strong-siv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-STRONG-SIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=weak-crossing-siv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-WEAK-CROSSING-SIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=exact-siv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-EXACT-SIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=weak-zero-siv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-WEAK-ZERO-SIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=exact-rdiv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-EXACT-RDIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=symbolic-rdiv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-SYMBOLIC-RDIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=gcd-miv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-GCD-MIV
+; RUN: opt < %s -disable-output "-passes=print<da>" -da-enable-dependence-test=banerjee-miv 2>&1 \
+; RUN: | FileCheck %s --check-prefix=CHECK-BANERJEE-MIV
+
+; for (i = 0; i < 10; i++)
+; a[i] = 0;
+define void @f(ptr %a) {
+; CHECK-ALL-LABEL: 'f'
+; CHECK-ALL-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-ALL-NEXT: da analyze - none!
+;
+; CHECK-STRONG-SIV-LABEL: 'f'
+; CHECK-STRONG-SIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-STRONG-SIV-NEXT: da analyze - none!
+;
+; CHECK-WEAK-CROSSING-SIV-LABEL: 'f'
+; CHECK-WEAK-CROSSING-SIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-WEAK-CROSSING-SIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-EXACT-SIV-LABEL: 'f'
+; CHECK-EXACT-SIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-EXACT-SIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-WEAK-ZERO-SIV-LABEL: 'f'
+; CHECK-WEAK-ZERO-SIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-WEAK-ZERO-SIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-EXACT-RDIV-LABEL: 'f'
+; CHECK-EXACT-RDIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-EXACT-RDIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-SYMBOLIC-RDIV-LABEL: 'f'
+; CHECK-SYMBOLIC-RDIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-SYMBOLIC-RDIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-GCD-MIV-LABEL: 'f'
+; CHECK-GCD-MIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-GCD-MIV-NEXT: da analyze - consistent output [*]!
+;
+; CHECK-BANERJEE-MIV-LABEL: 'f'
+; CHECK-BANERJEE-MIV-NEXT: Src: store i8 0, ptr %gep, align 1 --> Dst: store i8 0, ptr %gep, align 1
+; CHECK-BANERJEE-MIV-NEXT: da analyze - consistent output [*]!
+;
+entry:
+ br label %loop
+
+loop:
+ %i = phi i64 [ 0, %entry ], [ %i.inc, %loop ]
+ %gep = getelementptr inbounds nuw i8, ptr %a, i64 %i
+ store i8 0, ptr %gep
+ %i.inc = add nuw nsw i64 %i, 1
+ %ec = icmp eq i64 %i.inc, 10
+ br i1 %ec, label %exit, label %loop
+
+exit:
+ ret void
+}
More information about the llvm-commits
mailing list