[llvm] [DA] Add option to enable specific dependence test only (PR #164245)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Oct 20 05:39:41 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-analysis
Author: Ryotaro Kasuga (kasuga-fj)
<details>
<summary>Changes</summary>
PR #<!-- -->157084 added an option `da-run-siv-routines-only` to run only SIV routines in DA. This PR replaces that option with a more fine-grained one that allows to select other than SIV routines as well. This option is useful for regression testing of individual DA routines. This patch also reorganizes regression tests that use `da-run-siv-routines-only`.
---
Patch is 40.25 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/164245.diff
4 Files Affected:
- (modified) llvm/lib/Analysis/DependenceAnalysis.cpp (+73-9)
- (modified) llvm/test/Analysis/DependenceAnalysis/ExactSIV.ll (-318)
- (added) llvm/test/Analysis/DependenceAnalysis/exact-siv-overflow.ll (+124)
- (added) llvm/test/Analysis/DependenceAnalysis/run-specific-dependence-test.ll (+73)
``````````diff
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, p...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/164245
More information about the llvm-commits
mailing list