[llvm] [globals-aa] Improved isNonEscapingGlobalNoAlias. (PR #127707)
Slava Zakharin via llvm-commits
llvm-commits at lists.llvm.org
Tue Feb 18 16:49:54 PST 2025
https://github.com/vzakhari updated https://github.com/llvm/llvm-project/pull/127707
>From 8552d769d55aee6c13d64c0071f138f5af2316a5 Mon Sep 17 00:00:00 2001
From: Slava Zakharin <szakharin at nvidia.com>
Date: Tue, 18 Feb 2025 14:19:49 -0800
Subject: [PATCH 1/2] [globals-aa] Improved isNonEscapingGlobalNoAlias.
A non-escaping global should never alias with non-pointer values
and `ptr null`. This should improve disambiguation of global
pointers with relation to Flang runtime calls (given that
`nosync nocallback` attributes are properly set).
It also seems to be an obvious improvement with little overhead.
---
llvm/include/llvm/Analysis/GlobalsModRef.h | 3 ++-
llvm/lib/Analysis/GlobalsModRef.cpp | 21 +++++++++++++++----
.../GlobalsModRef/nonescaping-noalias.ll | 21 +++++++++++++++++++
3 files changed, 40 insertions(+), 5 deletions(-)
diff --git a/llvm/include/llvm/Analysis/GlobalsModRef.h b/llvm/include/llvm/Analysis/GlobalsModRef.h
index ab8ab8295b556..36a95e095aaa5 100644
--- a/llvm/include/llvm/Analysis/GlobalsModRef.h
+++ b/llvm/include/llvm/Analysis/GlobalsModRef.h
@@ -118,7 +118,8 @@ class GlobalsAAResult : public AAResultBase {
bool AnalyzeIndirectGlobalMemory(GlobalVariable *GV);
void CollectSCCMembership(CallGraph &CG);
- bool isNonEscapingGlobalNoAlias(const GlobalValue *GV, const Value *V);
+ bool isNonEscapingGlobalNoAlias(const GlobalValue *GV, const Value *V,
+ const Instruction *CtxI);
ModRefInfo getModRefInfoForArgument(const CallBase *Call,
const GlobalValue *GV, AAQueryInfo &AAQI);
};
diff --git a/llvm/lib/Analysis/GlobalsModRef.cpp b/llvm/lib/Analysis/GlobalsModRef.cpp
index 1ceb1b2629418..ade9ffe333b2d 100644
--- a/llvm/lib/Analysis/GlobalsModRef.cpp
+++ b/llvm/lib/Analysis/GlobalsModRef.cpp
@@ -713,7 +713,8 @@ static bool isNonEscapingGlobalNoAliasWithLoad(const GlobalValue *GV,
// active, or to be forced to operate as a module pass that cannot co-exist
// with an alias analysis such as GMR.
bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
- const Value *V) {
+ const Value *V,
+ const Instruction *CtxI) {
// In order to know that the underlying object cannot alias the
// non-addr-taken global, we must know that it would have to be an escape.
// Thus if the underlying object is a function argument, a load from
@@ -762,6 +763,18 @@ bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
continue;
}
+ // A non-addr-taken global cannot alias with any non-pointer value.
+ if (!Input->getType()->isPointerTy())
+ continue;
+
+ if (CtxI) {
+ // Null pointer cannot alias with a non-addr-taken global.
+ const Function *F = CtxI->getFunction();
+ if (const ConstantPointerNull *CPN = dyn_cast<ConstantPointerNull>(Input))
+ if (!NullPointerIsDefined(F, CPN->getType()->getAddressSpace()))
+ continue;
+ }
+
// Recurse through a limited number of selects, loads and PHIs. This is an
// arbitrary depth of 4, lower numbers could be used to fix compile time
// issues if needed, but this is generally expected to be only be important
@@ -820,7 +833,7 @@ bool GlobalsAAResult::invalidate(Module &, const PreservedAnalyses &PA,
/// address of the global isn't taken.
AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
const MemoryLocation &LocB,
- AAQueryInfo &AAQI, const Instruction *) {
+ AAQueryInfo &AAQI, const Instruction *CtxI) {
// Get the base object these pointers point to.
const Value *UV1 =
getUnderlyingObject(LocA.Ptr->stripPointerCastsForAliasAnalysis());
@@ -856,7 +869,7 @@ AliasResult GlobalsAAResult::alias(const MemoryLocation &LocA,
if ((GV1 || GV2) && GV1 != GV2) {
const GlobalValue *GV = GV1 ? GV1 : GV2;
const Value *UV = GV1 ? UV2 : UV1;
- if (isNonEscapingGlobalNoAlias(GV, UV))
+ if (isNonEscapingGlobalNoAlias(GV, UV, CtxI))
return AliasResult::NoAlias;
}
@@ -920,7 +933,7 @@ ModRefInfo GlobalsAAResult::getModRefInfoForArgument(const CallBase *Call,
!all_of(Objects, [&](const Value *V) {
return this->alias(MemoryLocation::getBeforeOrAfter(V),
MemoryLocation::getBeforeOrAfter(GV), AAQI,
- nullptr) == AliasResult::NoAlias;
+ Call) == AliasResult::NoAlias;
}))
return ConservativeResult;
diff --git a/llvm/test/Analysis/GlobalsModRef/nonescaping-noalias.ll b/llvm/test/Analysis/GlobalsModRef/nonescaping-noalias.ll
index 4a2c10ca55cdc..eed93cf0df8ef 100644
--- a/llvm/test/Analysis/GlobalsModRef/nonescaping-noalias.ll
+++ b/llvm/test/Analysis/GlobalsModRef/nonescaping-noalias.ll
@@ -175,3 +175,24 @@ entry:
%v = load i32, ptr @g1
ret i32 %v
}
+
+define i32 @test6(ptr %param) {
+; Ensure that we can fold a store to a load of a global across a set of
+; calls that cannot use in any way a non-escaping global.
+;
+; CHECK-LABEL: @test6(
+; CHECK: store i32 42, ptr @g1
+; CHECK-NOT: load i32
+; CHECK: ret i32 42
+entry:
+ store i32 42, ptr @g1
+ %1 = call ptr @_FortranAioBeginExternalFormattedOutput(ptr null, i64 3, ptr null, i32 6, ptr null, i32 2)
+ %2 = call i1 @_FortranAioOutputAscii(ptr %1, ptr null, i64 4)
+ %3 = call i32 @_FortranAioEndIoStatement(ptr %1)
+ %v = load i32, ptr @g1
+ ret i32 %v
+}
+declare ptr @_FortranAioBeginExternalFormattedOutput(ptr, i64, ptr, i32, ptr, i32) #0
+declare zeroext i1 @_FortranAioOutputAscii(ptr, ptr, i64) #0
+declare i32 @_FortranAioEndIoStatement(ptr) #0
+attributes #0 = { nocallback nosync }
>From e01033741a4ccaab44aa18831a410da03c7185cc Mon Sep 17 00:00:00 2001
From: Slava Zakharin <szakharin at nvidia.com>
Date: Tue, 18 Feb 2025 16:49:03 -0800
Subject: [PATCH 2/2] Reordered declaration.
---
llvm/lib/Analysis/GlobalsModRef.cpp | 11 ++++++-----
1 file changed, 6 insertions(+), 5 deletions(-)
diff --git a/llvm/lib/Analysis/GlobalsModRef.cpp b/llvm/lib/Analysis/GlobalsModRef.cpp
index ade9ffe333b2d..ebcca376c0468 100644
--- a/llvm/lib/Analysis/GlobalsModRef.cpp
+++ b/llvm/lib/Analysis/GlobalsModRef.cpp
@@ -767,13 +767,14 @@ bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
if (!Input->getType()->isPointerTy())
continue;
- if (CtxI) {
- // Null pointer cannot alias with a non-addr-taken global.
- const Function *F = CtxI->getFunction();
- if (const ConstantPointerNull *CPN = dyn_cast<ConstantPointerNull>(Input))
+ if (CtxI)
+ if (const ConstantPointerNull *CPN =
+ dyn_cast<ConstantPointerNull>(Input)) {
+ // Null pointer cannot alias with a non-addr-taken global.
+ const Function *F = CtxI->getFunction();
if (!NullPointerIsDefined(F, CPN->getType()->getAddressSpace()))
continue;
- }
+ }
// Recurse through a limited number of selects, loads and PHIs. This is an
// arbitrary depth of 4, lower numbers could be used to fix compile time
More information about the llvm-commits
mailing list