From dce5bf8efc13896ebf0ababfda00393eaa5cc99d Mon Sep 17 00:00:00 2001 From: Florian Hahn Date: Thu, 3 Oct 2024 16:02:34 +0100 Subject: [PATCH] [ValueTracking] AllowEphemerals for alignment assumptions. (#108632) Allow AllowEphemerals in isValidAssumeForContext, as the CxtI might be the producer of the pointer in the bundle. At the moment, align assumptions aren't optimized away. This allows using the assumption in the computeKnownBits call in getConstantMultipleImpl. We could extend the computeKnownBits API to allow callers to specify if ephemerals are allowed, if the info from computeKnownBitsFromContext is used to remove alignment assumptions. PR: https://github.com/llvm/llvm-project/pull/108632 --- llvm/lib/Analysis/ValueTracking.cpp | 5 +- .../max-backedge-taken-count-guard-info.ll | 60 +++++-------------- 2 files changed, 20 insertions(+), 45 deletions(-) diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index 5dc07b6fb58f2..b70827cc6de62 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -828,9 +828,12 @@ void llvm::computeKnownBitsFromContext(const Value *V, KnownBits &Known, continue; if (RetainedKnowledge RK = getKnowledgeFromBundle( *I, I->bundle_op_info_begin()[Elem.Index])) { + // Allow AllowEphemerals in isValidAssumeForContext, as the CxtI might + // be the producer of the pointer in the bundle. At the moment, align + // assumptions aren't optimized away. if (RK.WasOn == V && RK.AttrKind == Attribute::Alignment && isPowerOf2_64(RK.ArgValue) && - isValidAssumeForContext(I, Q.CxtI, Q.DT)) + isValidAssumeForContext(I, Q.CxtI, Q.DT, /*AllowEphemerals*/ true)) Known.Zero.setLowBits(Log2_64(RK.ArgValue)); } continue; diff --git a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll index 42706df82f37c..30c3bbfb12e5d 100644 --- a/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll +++ b/llvm/test/Analysis/ScalarEvolution/max-backedge-taken-count-guard-info.ll @@ -1709,37 +1709,23 @@ define void @ptr_induction_early_exit_eq_1_align_assumption_1(ptr %a, ptr %b, pt ; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_1' ; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_1 ; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8 -; CHECK-NEXT: --> %a_ U: full-set S: full-set +; CHECK-NEXT: --> %a_ U: [0,-7) S: [-9223372036854775808,9223372036854775801) ; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8 -; CHECK-NEXT: --> %b_ U: full-set S: full-set +; CHECK-NEXT: --> %b_ U: [0,-7) S: [-9223372036854775808,9223372036854775801) ; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ] -; CHECK-NEXT: --> {%a_,+,8}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%a_,+,8}<%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8 ; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } ; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8 -; CHECK-NEXT: --> {(8 + %a_),+,8}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(8 + %a_),+,8}<%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_1 ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-EMPTY: -; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951 +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-EMPTY: -; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 2305843009213693951 -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) ; entry: %a_ = load ptr, ptr %a @@ -1768,37 +1754,23 @@ define void @ptr_induction_early_exit_eq_1_align_assumption_2(ptr %a, ptr %b, pt ; CHECK-LABEL: 'ptr_induction_early_exit_eq_1_align_assumption_2' ; CHECK-NEXT: Classifying expressions for: @ptr_induction_early_exit_eq_1_align_assumption_2 ; CHECK-NEXT: %a_ = load ptr, ptr %a, align 8 -; CHECK-NEXT: --> %a_ U: full-set S: full-set +; CHECK-NEXT: --> %a_ U: [0,-7) S: [-9223372036854775808,9223372036854775801) ; CHECK-NEXT: %b_ = load ptr, ptr %b, align 8 -; CHECK-NEXT: --> %b_ U: full-set S: full-set +; CHECK-NEXT: --> %b_ U: [0,-7) S: [-9223372036854775808,9223372036854775801) ; CHECK-NEXT: %ptr.iv = phi ptr [ %ptr.iv.next, %loop.inc ], [ %a_, %entry ] -; CHECK-NEXT: --> {%a_,+,8}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {%a_,+,8}<%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: %ld1 = load ptr, ptr %ptr.iv, align 8 ; CHECK-NEXT: --> %ld1 U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Variant } ; CHECK-NEXT: %ptr.iv.next = getelementptr inbounds i8, ptr %ptr.iv, i64 8 -; CHECK-NEXT: --> {(8 + %a_),+,8}<%loop> U: full-set S: full-set Exits: <> LoopDispositions: { %loop: Computable } +; CHECK-NEXT: --> {(8 + %a_),+,8}<%loop> U: [0,-7) S: [-9223372036854775808,9223372036854775801) Exits: <> LoopDispositions: { %loop: Computable } ; CHECK-NEXT: Determining loop execution counts for: @ptr_induction_early_exit_eq_1_align_assumption_2 ; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count. ; CHECK-NEXT: exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-EMPTY: -; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count. -; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count. +; CHECK-NEXT: exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) +; CHECK-NEXT: Loop %loop: constant max backedge-taken count is i64 2305843009213693951 +; CHECK-NEXT: Loop %loop: symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) ; CHECK-NEXT: symbolic max exit count for loop: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: symbolic max exit count for loop.inc: ***COULDNOTCOMPUTE*** -; CHECK-NEXT: predicated symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-EMPTY: -; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 2305843009213693951 -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 -; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) -; CHECK-NEXT: Predicates: -; CHECK-NEXT: Equal predicate: (zext i3 ((trunc i64 (ptrtoint ptr %b_ to i64) to i3) + (-1 * (trunc i64 (ptrtoint ptr %a_ to i64) to i3))) to i64) == 0 +; CHECK-NEXT: symbolic max exit count for loop.inc: ((-8 + (-1 * (ptrtoint ptr %a_ to i64)) + (ptrtoint ptr %b_ to i64)) /u 8) ; entry: %a_ = load ptr, ptr %a