[Loads] Respect UseDerefAtPointSemantics in isDerefAndAlignedPointer. #123196

fhahn · 2025-01-16T12:59:24Z

If a pointer gets freed, it may not be dereferenceable any longer, even though there is a dominating dereferenceable assumption. As first step, only consider assumptions if the pointer value cannot be freed if UseDerefAtPointSemantics is used.

llvmbot · 2025-01-16T12:59:58Z

@llvm/pr-subscribers-llvm-ir
@llvm/pr-subscribers-llvm-transforms

@llvm/pr-subscribers-llvm-analysis

Author: Florian Hahn (fhahn)

Changes

If a pointer gets freed, it may not be dereferenceable any longer, even though there is a dominating dereferenceable assumption. As first step, only consider assumptions if the function doesn't free memory if UseDerefAtPointSemantics is used.

Full diff: https://github.com/llvm/llvm-project/pull/123196.diff

3 Files Affected:

(modified) llvm/lib/Analysis/Loads.cpp (+4-1)
(modified) llvm/lib/IR/Value.cpp (+1-1)
(modified) llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll (+18-5)

diff --git a/llvm/lib/Analysis/Loads.cpp b/llvm/lib/Analysis/Loads.cpp
index 7bbd469bd035d3..4cc93a8daeb0f1 100644
--- a/llvm/lib/Analysis/Loads.cpp
+++ b/llvm/lib/Analysis/Loads.cpp
@@ -25,6 +25,8 @@
 
 using namespace llvm;
 
+extern cl::opt<unsigned> UseDerefAtPointSemantics;
+
 static bool isAligned(const Value *Base, Align Alignment,
                       const DataLayout &DL) {
   return Base->getPointerAlignment(DL) >= Alignment;
@@ -168,7 +170,8 @@ static bool isDereferenceableAndAlignedPointer(
                                               Size, DL, CtxI, AC, DT, TLI,
                                               Visited, MaxDepth);
 
-  if (CtxI) {
+  if (CtxI &&
+      (!UseDerefAtPointSemantics || CtxI->getFunction()->doesNotFreeMemory())) {
     /// Look through assumes to see if both dereferencability and alignment can
     /// be proven by an assume if needed.
     RetainedKnowledge AlignRK;
diff --git a/llvm/lib/IR/Value.cpp b/llvm/lib/IR/Value.cpp
index b2ee75811fbb7d..03961f34a18b8f 100644
--- a/llvm/lib/IR/Value.cpp
+++ b/llvm/lib/IR/Value.cpp
@@ -36,7 +36,7 @@
 
 using namespace llvm;
 
-static cl::opt<unsigned> UseDerefAtPointSemantics(
+cl::opt<unsigned> UseDerefAtPointSemantics(
     "use-dereferenceable-at-point-semantics", cl::Hidden, cl::init(false),
     cl::desc("Deref attributes and metadata infer facts at definition only"));
 
diff --git a/llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll b/llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll
index 572511a5ffb926..7b41c9b3197aa6 100644
--- a/llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll
+++ b/llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll
@@ -1411,7 +1411,7 @@ exit:
 }
 
 ; %a may be freeed between the dereferenceable assumption and accesses.
-; FIXME: It is not safe to use with -use-dereferenceable-at-point-semantics.
+; It is not safe to use with -use-dereferenceable-at-point-semantics.
 define void @may_free_align_deref_assumption_in_header_constant_trip_count_loop_invariant_ptr(ptr noalias %a, ptr noalias %b, ptr noalias %c) {
 ; CHECK-LABEL: define void @may_free_align_deref_assumption_in_header_constant_trip_count_loop_invariant_ptr(
 ; CHECK-SAME: ptr noalias [[A:%.*]], ptr noalias [[B:%.*]], ptr noalias [[C:%.*]]) {
@@ -1422,16 +1422,29 @@ define void @may_free_align_deref_assumption_in_header_constant_trip_count_loop_
 ; CHECK:       [[VECTOR_PH]]:
 ; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
 ; CHECK:       [[VECTOR_BODY]]:
-; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
+; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[PRED_LOAD_CONTINUE2:.*]] ]
 ; CHECK-NEXT:    [[TMP0:%.*]] = add i64 [[INDEX]], 0
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[TMP0]]
 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i32 0
 ; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP2]], align 4
 ; CHECK-NEXT:    [[TMP3:%.*]] = icmp sge <2 x i32> [[WIDE_LOAD]], zeroinitializer
-; CHECK-NEXT:    [[TMP5:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT:    [[TMP4:%.*]] = xor <2 x i1> [[TMP3]], splat (i1 true)
+; CHECK-NEXT:    [[TMP5:%.*]] = extractelement <2 x i1> [[TMP4]], i32 0
+; CHECK-NEXT:    br i1 [[TMP5]], label %[[PRED_LOAD_IF:.*]], label %[[PRED_LOAD_CONTINUE:.*]]
+; CHECK:       [[PRED_LOAD_IF]]:
 ; CHECK-NEXT:    [[TMP15:%.*]] = load i32, ptr [[A]], align 4
-; CHECK-NEXT:    [[TMP13:%.*]] = insertelement <2 x i32> poison, i32 [[TMP5]], i32 0
-; CHECK-NEXT:    [[TMP11:%.*]] = insertelement <2 x i32> [[TMP13]], i32 [[TMP15]], i32 1
+; CHECK-NEXT:    [[TMP7:%.*]] = insertelement <2 x i32> poison, i32 [[TMP15]], i32 0
+; CHECK-NEXT:    br label %[[PRED_LOAD_CONTINUE]]
+; CHECK:       [[PRED_LOAD_CONTINUE]]:
+; CHECK-NEXT:    [[TMP12:%.*]] = phi <2 x i32> [ poison, %[[VECTOR_BODY]] ], [ [[TMP7]], %[[PRED_LOAD_IF]] ]
+; CHECK-NEXT:    [[TMP13:%.*]] = extractelement <2 x i1> [[TMP4]], i32 1
+; CHECK-NEXT:    br i1 [[TMP13]], label %[[PRED_LOAD_IF1:.*]], label %[[PRED_LOAD_CONTINUE2]]
+; CHECK:       [[PRED_LOAD_IF1]]:
+; CHECK-NEXT:    [[TMP14:%.*]] = load i32, ptr [[A]], align 4
+; CHECK-NEXT:    [[TMP16:%.*]] = insertelement <2 x i32> [[TMP12]], i32 [[TMP14]], i32 1
+; CHECK-NEXT:    br label %[[PRED_LOAD_CONTINUE2]]
+; CHECK:       [[PRED_LOAD_CONTINUE2]]:
+; CHECK-NEXT:    [[TMP11:%.*]] = phi <2 x i32> [ [[TMP12]], %[[PRED_LOAD_CONTINUE]] ], [ [[TMP16]], %[[PRED_LOAD_IF1]] ]
 ; CHECK-NEXT:    [[PREDPHI:%.*]] = select <2 x i1> [[TMP3]], <2 x i32> [[WIDE_LOAD]], <2 x i32> [[TMP11]]
 ; CHECK-NEXT:    [[TMP8:%.*]] = getelementptr inbounds i32, ptr [[C]], i64 [[TMP0]]
 ; CHECK-NEXT:    [[TMP9:%.*]] = getelementptr inbounds i32, ptr [[TMP8]], i32 0

nikic

nofree on functions describes external effects. The function can still allocate and free memory internally. Value::canBeFreed() has some logic that supports this for function arguments, where the distinction doesn't matter.

nikic · 2025-01-16T16:03:30Z

llvm/lib/Analysis/Loads.cpp

@@ -168,7 +170,7 @@ static bool isDereferenceableAndAlignedPointer(
                                              Size, DL, CtxI, AC, DT, TLI,
                                              Visited, MaxDepth);

-  if (CtxI) {
+  if (CtxI && (!UseDerefAtPointSemantics || !V->canBeFreed())) {


Can we make this unconditional, regardless of the value of UseDerefAtPointSemantics? The way I'd view this is that UseDerefAtPointSemantics is for dereferenceable argument attributes. We can/should make assumptions always use at-point semantics.

My plan was first making things correct with the flag, then change the behavior for the attribute in assumes + langref change separately.

I can also pull it in here, although I still need to inspect the other uses of dereferenceable assumptions.

Okay, that's fin by me.

nikic · 2025-01-16T16:06:10Z

llvm/test/Transforms/LoopVectorize/dereferenceable-info-from-assumption-constant-size.ll

@@ -3,7 +3,7 @@

 declare void @llvm.assume(i1)

-define void @deref_assumption_in_header_constant_trip_count(ptr noalias %a, ptr noalias %b, ptr noalias %c) nofree {
+define void @deref_assumption_in_header_constant_trip_count(ptr noalias %a, ptr noalias %b, ptr noalias %c) nofree nosync{


FWIW, I consider this a bug in our nofree semantics, and a large part of the reason why this never made progress :)

Frontends often have knowledge that a certain pointer is not going to be freed in the function (including via synchronization), but they don't have knowledge about whether it may be involved in synchronization. The current semantics make it impossible to convey such facts.

nikic

LGTM

If a pointer gets freed, it may not be dereferenceable any longer, even though there is a dominating dereferenceable assumption. As first step, only consider assumptions if the function doesn't free memory if UseDerefAtPointSemantics is used.

…nedPointer. (#123196) If a pointer gets freed, it may not be dereferenceable any longer, even though there is a dominating dereferenceable assumption. As first step, only consider assumptions if the pointer value cannot be freed if UseDerefAtPointSemantics is used. PR: llvm/llvm-project#123196

#126117) Update LangRef and code using `Dereferenceable` in assume bundles to only use the information if it is safe at the point of use. `Dereferenceable` in an assume bundle is only guaranteed at the point of the assumption, but may not be guaranteed at later points, because the pointer may have been freed. Update code using `Dereferenceable` to only use it if the pointer cannot be freed. This can further be refined to check if the pointer could be freed between assume and use. This follows up on #123196. With that change, it should be safe to expose dereferenceable assumptions more widely as in #121789 PR: #126117

…s at assume. (#126117) Update LangRef and code using `Dereferenceable` in assume bundles to only use the information if it is safe at the point of use. `Dereferenceable` in an assume bundle is only guaranteed at the point of the assumption, but may not be guaranteed at later points, because the pointer may have been freed. Update code using `Dereferenceable` to only use it if the pointer cannot be freed. This can further be refined to check if the pointer could be freed between assume and use. This follows up on llvm/llvm-project#123196. With that change, it should be safe to expose dereferenceable assumptions more widely as in llvm/llvm-project#121789 PR: llvm/llvm-project#126117

llvm#126117) Update LangRef and code using `Dereferenceable` in assume bundles to only use the information if it is safe at the point of use. `Dereferenceable` in an assume bundle is only guaranteed at the point of the assumption, but may not be guaranteed at later points, because the pointer may have been freed. Update code using `Dereferenceable` to only use it if the pointer cannot be freed. This can further be refined to check if the pointer could be freed between assume and use. This follows up on llvm#123196. With that change, it should be safe to expose dereferenceable assumptions more widely as in llvm#121789 PR: llvm#126117

fhahn requested review from arsenm, nikic, preames and jdoerfert January 16, 2025 12:59

llvmbot added llvm:ir llvm:analysis Includes value tracking, cost tables and constant folding llvm:transforms labels Jan 16, 2025

fhahn mentioned this pull request Jan 16, 2025

[Loads] Check loop-varying pointer in isDereferenceableAndAlignedInLoop. #120962

Open

nikic requested changes Jan 16, 2025

View reviewed changes

fhahn force-pushed the respect-UseDerefAtPointSemantics-in-isDereferenceableAndAlignedPointer branch from 2eaae5d to 4a46cd0 Compare January 16, 2025 15:55

nikic reviewed Jan 16, 2025

View reviewed changes

nikic approved these changes Jan 16, 2025

View reviewed changes

fhahn added 3 commits January 17, 2025 11:32

!fixup use canBeFreed.

e601fcb

!fixup update after UseDeref.. to bool

1de8962

fhahn force-pushed the respect-UseDerefAtPointSemantics-in-isDereferenceableAndAlignedPointer branch from 4a46cd0 to 1de8962 Compare January 17, 2025 11:38

fhahn merged commit 22637a8 into llvm:main Jan 17, 2025
8 checks passed

fhahn deleted the respect-UseDerefAtPointSemantics-in-isDereferenceableAndAlignedPointer branch January 17, 2025 12:52

fhahn mentioned this pull request Feb 6, 2025

[AssumeBundles] Dereferenceable used in bundle only applies at assume. #126117

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[Loads] Respect UseDerefAtPointSemantics in isDerefAndAlignedPointer. #123196

[Loads] Respect UseDerefAtPointSemantics in isDerefAndAlignedPointer. #123196

Uh oh!

fhahn commented Jan 16, 2025 •

edited

Loading

Uh oh!

llvmbot commented Jan 16, 2025 •

edited

Loading

Uh oh!

nikic left a comment

Uh oh!

nikic Jan 16, 2025

Uh oh!

fhahn Jan 16, 2025

Uh oh!

nikic Jan 16, 2025

Uh oh!

nikic Jan 16, 2025

Uh oh!

nikic left a comment

Uh oh!

Uh oh!

Uh oh!

[Loads] Respect UseDerefAtPointSemantics in isDerefAndAlignedPointer. #123196

[Loads] Respect UseDerefAtPointSemantics in isDerefAndAlignedPointer. #123196

Uh oh!

Conversation

fhahn commented Jan 16, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

llvmbot commented Jan 16, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

nikic left a comment

Choose a reason for hiding this comment

Uh oh!

nikic Jan 16, 2025

Choose a reason for hiding this comment

Uh oh!

fhahn Jan 16, 2025

Choose a reason for hiding this comment

Uh oh!

nikic Jan 16, 2025

Choose a reason for hiding this comment

Uh oh!

nikic Jan 16, 2025

Choose a reason for hiding this comment

Uh oh!

nikic left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

fhahn commented Jan 16, 2025 •

edited

Loading

llvmbot commented Jan 16, 2025 •

edited

Loading