Skip to content

Commit 72b2902

Browse files
kasuga-fjkasuga-fj
committed
Introduce NoSignedWrap to MonotonicityType
1 parent e93be2e commit 72b2902

17 files changed

+368
-143
lines changed

‎llvm/lib/Analysis/DependenceAnalysis.cpp

Lines changed: 116 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -3310,10 +3310,23 @@ void DependenceInfo::updateDirection(Dependence::DVEntry &Level,
33103310

33113311
namespace {
33123312

3313+
/// The type of signed monotonicity of a SCEV expression. This property is
3314+
/// defined with respect to the outermost loop that DA is analyzing. Invariant
3315+
/// and MultiMonotonic mutually exclusive, and both imply NoSignedWrap.
3316+
///
3317+
/// This is designed to classify the behavior of AddRec expressions, and does
3318+
/// not care about other SCEVs. For example, given the two loop invariants `A`
3319+
/// and `B`, `A + B` is treated as Invariant even if the addition may wrap. On
3320+
/// the other hand, if either `A` or `B` is an AddRec and we cannot prove the
3321+
/// addition doesn't wrap, the result is classified as Unknown.
33133322
enum class MonotonicityType {
3314-
Unknown, ///< The expression contains some non loop-invariant SCEVUnknown or
3315-
///< arithmetic operations that may cause signed wrap.
3316-
Invariant, ///< The expression is a loop-invariant.
3323+
Unknown, ///< The expression contains some non loop-invariant SCEVUnknown or
3324+
///< arithmetic operation that has some AddRec as its subexpression
3325+
///< and may cause signed wrap.
3326+
NoSignedWrap, ///< The expression doesn't contain any AddRecs that may wrap.
3327+
///< This is a weaker property than Invariant or MultiMonotonic.
3328+
///< Invariant and MultiMonotonic imply NoSignedWrap.
3329+
Invariant, ///< The expression is a loop-invariant.
33173330
MultiMonotonic, ///< The expression is monotonically increasing or decreasing
33183331
///< with respect to each loop. This is exclusive of
33193332
///< Invariant. That is, we say an SCEV is MultiMonotonic only
@@ -3385,11 +3398,10 @@ struct SCEVSignedMonotonicityChecker
33853398
private:
33863399
ScalarEvolution *SE;
33873400
const Loop *OutermostLoop;
3388-
const Value *Ptr = nullptr;
3401+
bool NoWrapFromGEP = false;
33893402

33903403
SCEVSignedMonotonicityChecker(ScalarEvolution *SE, const Loop *OutermostLoop,
3391-
const Value *Ptr)
3392-
: SE(SE), OutermostLoop(OutermostLoop), Ptr(Ptr) {}
3404+
const Value *Ptr);
33933405

33943406
MonotonicityType visitNAryHelper(const SCEVNAryExpr *Expr);
33953407
MonotonicityType unknownMonotonicity(const SCEV *Expr);
@@ -3398,21 +3410,54 @@ struct SCEVSignedMonotonicityChecker
33983410

33993411
} // anonymous namespace
34003412

3413+
SCEVSignedMonotonicityChecker::SCEVSignedMonotonicityChecker(
3414+
ScalarEvolution *SE, const Loop *OutermostLoop, const Value *Ptr)
3415+
: SE(SE), OutermostLoop(OutermostLoop) {
3416+
if (Ptr) {
3417+
// TODO: This seems incorrect. Maybe we should check the reachability from
3418+
// the GEP to the target instruction. E.g., in the following case, maybe
3419+
// no-wrap is not guaranteed:
3420+
//
3421+
// entry:
3422+
// ...
3423+
// %gep = getelementptr inbounds i32, ptr %ptr, i32 %addrec
3424+
// br i1 %cond, label %store, label %sink
3425+
//
3426+
// store:
3427+
// store i32 42, ptr %ptr
3428+
// br label %sink
3429+
//
3430+
// sink:
3431+
// ...
3432+
//
3433+
auto *GEP = dyn_cast<GetElementPtrInst>(Ptr);
3434+
if (GEP && GEP->hasNoUnsignedSignedWrap())
3435+
NoWrapFromGEP = true;
3436+
}
3437+
}
3438+
34013439
MonotonicityType SCEVSignedMonotonicityChecker::checkMonotonicity(
34023440
ScalarEvolution *SE, const SCEV *Expr, const Loop *OutermostLoop,
34033441
const Value *Ptr) {
34043442
SCEVSignedMonotonicityChecker Checker(SE, OutermostLoop, Ptr);
34053443
MonotonicityType MT = Checker.visit(Expr);
3444+
if (MT == MonotonicityType::Unknown && Checker.NoWrapFromGEP)
3445+
MT = MonotonicityType::NoSignedWrap;
34063446

34073447
#ifndef NDEBUG
34083448
switch (MT) {
34093449
case MonotonicityType::Unknown:
3450+
LLVM_DEBUG(dbgs() << "Monotonicity: Unknown expr: " << *Expr << "\n");
3451+
break;
3452+
case MonotonicityType::NoSignedWrap:
3453+
LLVM_DEBUG(dbgs() << "Monotonicity: No signed wrap expr: " << *Expr
3454+
<< "\n");
34103455
break;
34113456
case MonotonicityType::Invariant:
3412-
LLVM_DEBUG(dbgs() << "Invariant expr: " << *Expr << "\n");
3457+
LLVM_DEBUG(dbgs() << "Monotonicity: Invariant expr: " << *Expr << "\n");
34133458
break;
34143459
case MonotonicityType::MultiMonotonic:
3415-
LLVM_DEBUG(dbgs() << "Monotonic expr: " << *Expr << "\n");
3460+
LLVM_DEBUG(dbgs() << "Monotonicity: Monotonic expr: " << *Expr << "\n");
34163461
break;
34173462
}
34183463
#endif
@@ -3421,28 +3466,49 @@ MonotonicityType SCEVSignedMonotonicityChecker::checkMonotonicity(
34213466

34223467
MonotonicityType
34233468
SCEVSignedMonotonicityChecker::visitNAryHelper(const SCEVNAryExpr *Expr) {
3469+
assert((isa<SCEVAddExpr>(Expr) || isa<SCEVMulExpr>(Expr)) &&
3470+
"Unexpected SCEV");
3471+
34243472
if (isLoopInvariant(Expr))
34253473
return MonotonicityType::Invariant;
34263474

3427-
if (!Expr->hasNoSignedWrap())
3428-
return unknownMonotonicity(Expr);
3429-
34303475
MonotonicityType Result = MonotonicityType::Invariant;
34313476
for (const SCEV *Op : Expr->operands()) {
3477+
assert(Result != MonotonicityType::Unknown && "Unexpected state");
34323478
switch (visit(Op)) {
34333479
case MonotonicityType::Unknown:
34343480
return unknownMonotonicity(Expr);
3435-
case MonotonicityType::Invariant:
3481+
case MonotonicityType::NoSignedWrap:
3482+
Result = MonotonicityType::NoSignedWrap;
34363483
break;
3437-
case MonotonicityType::MultiMonotonic:
3438-
// Monotonic + Monotonic might be a loop invariant, e.g., {0,+,1}<%loop> +
3439-
// {0,+,-1}<%loop>.
3440-
// TODO: It would be better to record visited loops and return Unknown
3441-
// only when the same loop is visited multiple times.
3442-
if (Result == MonotonicityType::MultiMonotonic)
3443-
return unknownMonotonicity(Expr);
3444-
Result = MonotonicityType::MultiMonotonic;
3484+
case MonotonicityType::Invariant:
34453485
break;
3486+
case MonotonicityType::MultiMonotonic: {
3487+
switch (Result) {
3488+
case MonotonicityType::Unknown:
3489+
llvm_unreachable("should have been handled above");
3490+
case MonotonicityType::NoSignedWrap:
3491+
break;
3492+
case MonotonicityType::Invariant:
3493+
if (!Expr->hasNoSignedWrap())
3494+
return unknownMonotonicity(Expr);
3495+
Result = MonotonicityType::MultiMonotonic;
3496+
break;
3497+
case MonotonicityType::MultiMonotonic:
3498+
if (!Expr->hasNoSignedWrap())
3499+
return unknownMonotonicity(Expr);
3500+
if (!isa<SCEVAddExpr>(Expr))
3501+
return unknownMonotonicity(Expr);
3502+
// Monotonic + Monotonic might be a loop invariant, e.g., the following
3503+
// SCEV:
3504+
//
3505+
// {0,+,1}<%loop> + {0,+,-1}<%loop>
3506+
//
3507+
// In that case, relax the property to NoSignedWrap.
3508+
Result = MonotonicityType::NoSignedWrap;
3509+
break;
3510+
}
3511+
} break;
34463512
}
34473513
}
34483514
return Result;
@@ -3466,44 +3532,17 @@ SCEVSignedMonotonicityChecker::visitAddRecExpr(const SCEVAddRecExpr *Expr) {
34663532
const SCEV *Start = Expr->getStart();
34673533
const SCEV *Step = Expr->getStepRecurrence(*SE);
34683534

3535+
bool IsNSW = Expr->hasNoSignedWrap();
3536+
34693537
MonotonicityType StartRes = visit(Start);
34703538
if (StartRes == MonotonicityType::Unknown)
34713539
return unknownMonotonicity(Expr);
34723540

34733541
MonotonicityType StepRes = visit(Step);
3474-
if (StepRes != MonotonicityType::Invariant || !SE->isKnownNonZero(Step))
3542+
if (StepRes != MonotonicityType::Invariant)
34753543
return unknownMonotonicity(Expr);
34763544

3477-
bool IsNSW = [&] {
3478-
if (Expr->hasNoSignedWrap())
3479-
return true;
3480-
3481-
if (Ptr) {
3482-
// TODO: This seems incorrect. Maybe we should check the reachability from
3483-
// the GEP to the target instruction. E.g., in the following case, maybe
3484-
// no-wrap is not guaranteed:
3485-
//
3486-
// entry:
3487-
// ...
3488-
// %gep = getelementptr inbounds i32, ptr %ptr, i32 %addrec
3489-
// br i1 %cond, label %store, label %sink
3490-
//
3491-
// store:
3492-
// store i32 42, ptr %ptr
3493-
// br label %sink
3494-
//
3495-
// sink:
3496-
// ...
3497-
//
3498-
auto *GEP = dyn_cast<GetElementPtrInst>(Ptr);
3499-
if (GEP && GEP->hasNoUnsignedSignedWrap())
3500-
return true;
3501-
}
3502-
3503-
return false;
3504-
}();
3505-
3506-
// TODO: Is this additional check necessary?
3545+
// TODO: Enhance the inference here.
35073546
if (!IsNSW) {
35083547
if (!SE->isKnownNegative(Step))
35093548
// If the coefficient can be positive value, ensure that the AddRec is
@@ -3518,7 +3557,21 @@ SCEVSignedMonotonicityChecker::visitAddRecExpr(const SCEVAddRecExpr *Expr) {
35183557
return unknownMonotonicity(Expr);
35193558
}
35203559

3521-
return MonotonicityType::MultiMonotonic;
3560+
bool IsKnownNonZero = SE->isKnownNonZero(Step);
3561+
switch (StartRes) {
3562+
case MonotonicityType::Unknown:
3563+
llvm_unreachable("should have been handled above");
3564+
case MonotonicityType::NoSignedWrap:
3565+
return MonotonicityType::NoSignedWrap;
3566+
case MonotonicityType::Invariant:
3567+
return IsKnownNonZero ? MonotonicityType::MultiMonotonic
3568+
: MonotonicityType::NoSignedWrap;
3569+
case MonotonicityType::MultiMonotonic:
3570+
// TODO: Should handle SCEV like `{{0,+,-1}<%loop>,+,1}<%loop>`?
3571+
return IsKnownNonZero ? MonotonicityType::MultiMonotonic
3572+
: MonotonicityType::NoSignedWrap;
3573+
}
3574+
llvm_unreachable("unhandled MonotonicityType");
35223575
}
35233576

35243577
MonotonicityType SCEVSignedMonotonicityChecker::visitZeroExtendExpr(
@@ -3733,6 +3786,15 @@ bool DependenceInfo::tryDelinearizeParametricSize(
37333786
const Loop *OutermostLoop =
37343787
LI->getLoopFor(Src->getParent())->getOutermostLoop();
37353788

3789+
// TODO: In general, reasoning about monotonicity of a subscript from the
3790+
// base pointer would not be allowed. Probably we need to check the loops
3791+
// associated with this subscript are disjoint from those associated with
3792+
// the other subscripts. The validation would be something like:
3793+
//
3794+
// LoopsI = collectCommonLoops(SrcSubscripts[I])
3795+
// LoopsOthers = collectCommonLoops(SrcSCEV - SrcSubscripts[I])
3796+
// CanUsePtr = (LoopsI intersect LoopsOthers) is empty.
3797+
//
37363798
MonotonicityType SrcMonotonicity =
37373799
SCEVSignedMonotonicityChecker::checkMonotonicity(
37383800
SE, SrcSubscripts[I], OutermostLoop, SrcPtr);
@@ -3939,6 +4001,8 @@ DependenceInfo::depends(Instruction *Src, Instruction *Dst,
39394001
LLVM_DEBUG(dbgs() << " delinearized\n");
39404002
Pairs = Pair.size();
39414003
}
4004+
// TODO: Check that the original offsets are monotonic when delinearization
4005+
// fails.
39424006
}
39434007

39444008
for (unsigned P = 0; P < Pairs; ++P) {

‎llvm/test/Analysis/DependenceAnalysis/Banerjee.ll

Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ define void @banerjee0(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
2828
; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
2929
; CHECK-NEXT: da analyze - confused!
3030
; CHECK-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
31-
; CHECK-NEXT: da analyze - none!
31+
; CHECK-NEXT: da analyze - confused!
3232
;
3333
; NORMALIZE-LABEL: 'banerjee0'
3434
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -42,7 +42,7 @@ define void @banerjee0(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
4242
; NORMALIZE-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
4343
; NORMALIZE-NEXT: da analyze - confused!
4444
; NORMALIZE-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
45-
; NORMALIZE-NEXT: da analyze - none!
45+
; NORMALIZE-NEXT: da analyze - confused!
4646
;
4747
; DELIN-LABEL: 'banerjee0'
4848
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -56,7 +56,7 @@ define void @banerjee0(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
5656
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
5757
; DELIN-NEXT: da analyze - confused!
5858
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
59-
; DELIN-NEXT: da analyze - none!
59+
; DELIN-NEXT: da analyze - confused!
6060
;
6161
entry:
6262
br label %for.cond1.preheader
@@ -810,7 +810,7 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
810810
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
811811
; CHECK-NEXT: da analyze - confused!
812812
; CHECK-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
813-
; CHECK-NEXT: da analyze - none!
813+
; CHECK-NEXT: da analyze - confused!
814814
;
815815
; NORMALIZE-LABEL: 'banerjee9'
816816
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -824,7 +824,7 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
824824
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
825825
; NORMALIZE-NEXT: da analyze - confused!
826826
; NORMALIZE-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
827-
; NORMALIZE-NEXT: da analyze - none!
827+
; NORMALIZE-NEXT: da analyze - confused!
828828
;
829829
; DELIN-LABEL: 'banerjee9'
830830
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -838,7 +838,7 @@ define void @banerjee9(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
838838
; DELIN-NEXT: Src: %1 = load i64, ptr %arrayidx7, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
839839
; DELIN-NEXT: da analyze - confused!
840840
; DELIN-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
841-
; DELIN-NEXT: da analyze - none!
841+
; DELIN-NEXT: da analyze - confused!
842842
;
843843
entry:
844844
br label %for.cond1.preheader
@@ -896,7 +896,7 @@ define void @banerjee10(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
896896
; CHECK-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
897897
; CHECK-NEXT: da analyze - confused!
898898
; CHECK-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
899-
; CHECK-NEXT: da analyze - none!
899+
; CHECK-NEXT: da analyze - confused!
900900
;
901901
; NORMALIZE-LABEL: 'banerjee10'
902902
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -910,7 +910,7 @@ define void @banerjee10(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
910910
; NORMALIZE-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
911911
; NORMALIZE-NEXT: da analyze - confused!
912912
; NORMALIZE-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
913-
; NORMALIZE-NEXT: da analyze - none!
913+
; NORMALIZE-NEXT: da analyze - confused!
914914
;
915915
; DELIN-LABEL: 'banerjee10'
916916
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -924,7 +924,7 @@ define void @banerjee10(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
924924
; DELIN-NEXT: Src: %1 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
925925
; DELIN-NEXT: da analyze - confused!
926926
; DELIN-NEXT: Src: store i64 %1, ptr %B.addr.11, align 8 --> Dst: store i64 %1, ptr %B.addr.11, align 8
927-
; DELIN-NEXT: da analyze - none!
927+
; DELIN-NEXT: da analyze - confused!
928928
;
929929
entry:
930930
br label %for.cond1.preheader
@@ -981,7 +981,7 @@ define void @banerjee11(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
981981
; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
982982
; CHECK-NEXT: da analyze - confused!
983983
; CHECK-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
984-
; CHECK-NEXT: da analyze - none!
984+
; CHECK-NEXT: da analyze - confused!
985985
;
986986
; NORMALIZE-LABEL: 'banerjee11'
987987
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -995,7 +995,7 @@ define void @banerjee11(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
995995
; NORMALIZE-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
996996
; NORMALIZE-NEXT: da analyze - confused!
997997
; NORMALIZE-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
998-
; NORMALIZE-NEXT: da analyze - none!
998+
; NORMALIZE-NEXT: da analyze - confused!
999999
;
10001000
; DELIN-LABEL: 'banerjee11'
10011001
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -1009,7 +1009,7 @@ define void @banerjee11(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
10091009
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
10101010
; DELIN-NEXT: da analyze - confused!
10111011
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
1012-
; DELIN-NEXT: da analyze - none!
1012+
; DELIN-NEXT: da analyze - confused!
10131013
;
10141014
entry:
10151015
br label %for.cond1.preheader
@@ -1066,7 +1066,7 @@ define void @banerjee12(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
10661066
; CHECK-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
10671067
; CHECK-NEXT: da analyze - confused!
10681068
; CHECK-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
1069-
; CHECK-NEXT: da analyze - none!
1069+
; CHECK-NEXT: da analyze - confused!
10701070
;
10711071
; NORMALIZE-LABEL: 'banerjee12'
10721072
; NORMALIZE-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -1080,7 +1080,7 @@ define void @banerjee12(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
10801080
; NORMALIZE-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
10811081
; NORMALIZE-NEXT: da analyze - confused!
10821082
; NORMALIZE-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
1083-
; NORMALIZE-NEXT: da analyze - none!
1083+
; NORMALIZE-NEXT: da analyze - confused!
10841084
;
10851085
; DELIN-LABEL: 'banerjee12'
10861086
; DELIN-NEXT: Src: store i64 0, ptr %arrayidx, align 8 --> Dst: store i64 0, ptr %arrayidx, align 8
@@ -1094,7 +1094,7 @@ define void @banerjee12(ptr %A, ptr %B, i64 %m, i64 %n) nounwind uwtable ssp {
10941094
; DELIN-NEXT: Src: %0 = load i64, ptr %arrayidx6, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
10951095
; DELIN-NEXT: da analyze - confused!
10961096
; DELIN-NEXT: Src: store i64 %0, ptr %B.addr.11, align 8 --> Dst: store i64 %0, ptr %B.addr.11, align 8
1097-
; DELIN-NEXT: da analyze - none!
1097+
; DELIN-NEXT: da analyze - confused!
10981098
;
10991099
entry:
11001100
br label %for.cond1.preheader

0 commit comments

Comments
 (0)