[llvm] 2a607d9 - [Attributor] Delete stores only required for assumes (with the assumes)
Johannes Doerfert via llvm-commits
llvm-commits at lists.llvm.org
Wed Dec 7 22:26:52 PST 2022
Author: Johannes Doerfert
Date: 2022-12-07T22:26:11-08:00
New Revision: 2a607d912e04901cbbe6467a747aa4e55a271423
URL: https://github.com/llvm/llvm-project/commit/2a607d912e04901cbbe6467a747aa4e55a271423
DIFF: https://github.com/llvm/llvm-project/commit/2a607d912e04901cbbe6467a747aa4e55a271423.diff
LOG: [Attributor] Delete stores only required for assumes (with the assumes)
We keep loads if they feed into assumes but even if we cannot predict
their value we should delete them if the associated stores are deleted
as well. This is not perfect but prioritizes deleting stores now.
Added:
Modified:
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
llvm/test/Transforms/Attributor/value-simplify-assume.ll
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
index cac974ad19a17..061d226f3edb6 100644
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -2823,6 +2823,7 @@ void InformationCache::initializeInformationCache(const Function &CF,
// For `llvm.assume` calls we also fill the KnowledgeMap as we find them.
// For `must-tail` calls we remember the caller and callee.
if (auto *Assume = dyn_cast<AssumeInst>(&I)) {
+ AssumeOnlyValues.insert(Assume);
fillMapFromAssume(*Assume, KnowledgeMap);
AddToAssumeUsesMap(*Assume->getArgOperand(0));
} else if (cast<CallInst>(I).isMustTailCall()) {
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index 531b287550b1a..7039afc8dcd0a 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -3642,7 +3642,8 @@ struct AAIsDeadFloating : public AAIsDeadValueImpl {
}
}
- bool isDeadStore(Attributor &A, StoreInst &SI) {
+ bool isDeadStore(Attributor &A, StoreInst &SI,
+ SmallSetVector<Instruction *, 8> *AssumeOnlyInst = nullptr) {
// Lang ref now states volatile store is not UB/dead, let's skip them.
if (SI.isVolatile())
return false;
@@ -3658,10 +3659,23 @@ struct AAIsDeadFloating : public AAIsDeadValueImpl {
}
LLVM_DEBUG(dbgs() << "[AAIsDead] Store has " << PotentialCopies.size()
<< " potential copies.\n");
+
+ InformationCache &InfoCache = A.getInfoCache();
return llvm::all_of(PotentialCopies, [&](Value *V) {
if (A.isAssumedDead(IRPosition::value(*V), this, nullptr,
UsedAssumedInformation))
return true;
+ if (auto *LI = dyn_cast<LoadInst>(V)) {
+ if (llvm::all_of(LI->uses(), [&](const Use &U) {
+ return InfoCache.isOnlyUsedByAssume(
+ cast<Instruction>(*U.getUser())) ||
+ A.isAssumedDead(U, this, nullptr, UsedAssumedInformation);
+ })) {
+ if (AssumeOnlyInst)
+ AssumeOnlyInst->insert(LI);
+ return true;
+ }
+ }
LLVM_DEBUG(dbgs() << "[AAIsDead] Potential copy " << *V
<< " is assumed live!\n");
return false;
@@ -3704,8 +3718,20 @@ struct AAIsDeadFloating : public AAIsDeadValueImpl {
// isAssumedSideEffectFree returns true here again because it might not be
// the case and only the users are dead but the instruction (=call) is
// still needed.
- if (isa<StoreInst>(I) ||
- (isAssumedSideEffectFree(A, I) && !isa<InvokeInst>(I))) {
+ if (auto *SI = dyn_cast<StoreInst>(I)) {
+ SmallSetVector<Instruction *, 8> AssumeOnlyInst;
+ bool IsDead = isDeadStore(A, *SI, &AssumeOnlyInst);
+ assert(IsDead && "Store was assumed to be dead!");
+ A.deleteAfterManifest(*I);
+ for (size_t i = 0; i < AssumeOnlyInst.size(); ++i) {
+ Instruction *AOI = AssumeOnlyInst[i];
+ for (auto *Usr : AOI->users())
+ AssumeOnlyInst.insert(cast<Instruction>(Usr));
+ A.deleteAfterManifest(*AOI);
+ }
+ return ChangeStatus::CHANGED;
+ }
+ if (isAssumedSideEffectFree(A, I) && !isa<InvokeInst>(I)) {
A.deleteAfterManifest(*I);
return ChangeStatus::CHANGED;
}
diff --git a/llvm/test/Transforms/Attributor/value-simplify-assume.ll b/llvm/test/Transforms/Attributor/value-simplify-assume.ll
index 37c61bc1c5975..aaf63a4c8402a 100644
--- a/llvm/test/Transforms/Attributor/value-simplify-assume.ll
+++ b/llvm/test/Transforms/Attributor/value-simplify-assume.ll
@@ -316,35 +316,16 @@ m:
}
define void @assume_1b_nr(i1 %arg, i1 %cond) norecurse {
-; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; TUNIT-LABEL: define {{[^@]+}}@assume_1b_nr
-; TUNIT-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; TUNIT-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; TUNIT-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
-; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; TUNIT: t:
-; TUNIT-NEXT: br label [[M:%.*]]
-; TUNIT: f:
-; TUNIT-NEXT: br label [[M]]
-; TUNIT: m:
-; TUNIT-NEXT: ret void
-;
-; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; CGSCC-LABEL: define {{[^@]+}}@assume_1b_nr
-; CGSCC-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; CGSCC-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; CGSCC-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
-; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; CGSCC: t:
-; CGSCC-NEXT: br label [[M:%.*]]
-; CGSCC: f:
-; CGSCC-NEXT: br label [[M]]
-; CGSCC: m:
-; CGSCC-NEXT: ret void
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
+; CHECK-LABEL: define {{[^@]+}}@assume_1b_nr
+; CHECK-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3:[0-9]+]] {
+; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
+; CHECK: t:
+; CHECK-NEXT: br label [[M:%.*]]
+; CHECK: f:
+; CHECK-NEXT: br label [[M]]
+; CHECK: m:
+; CHECK-NEXT: ret void
;
%stack = alloca i1
store i1 %arg, i1* %stack
@@ -412,39 +393,16 @@ m:
}
define void @assume_2b_nr(i1 %arg, i1 %cond) norecurse {
-; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; TUNIT-LABEL: define {{[^@]+}}@assume_2b_nr
-; TUNIT-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; TUNIT-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; TUNIT: t:
-; TUNIT-NEXT: store i1 true, i1* [[STACK]], align 1
-; TUNIT-NEXT: br label [[M:%.*]]
-; TUNIT: f:
-; TUNIT-NEXT: store i1 false, i1* [[STACK]], align 1
-; TUNIT-NEXT: br label [[M]]
-; TUNIT: m:
-; TUNIT-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
-; TUNIT-NEXT: ret void
-;
-; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; CGSCC-LABEL: define {{[^@]+}}@assume_2b_nr
-; CGSCC-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; CGSCC-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; CGSCC: t:
-; CGSCC-NEXT: store i1 true, i1* [[STACK]], align 1
-; CGSCC-NEXT: br label [[M:%.*]]
-; CGSCC: f:
-; CGSCC-NEXT: store i1 false, i1* [[STACK]], align 1
-; CGSCC-NEXT: br label [[M]]
-; CGSCC: m:
-; CGSCC-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
-; CGSCC-NEXT: ret void
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
+; CHECK-LABEL: define {{[^@]+}}@assume_2b_nr
+; CHECK-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
+; CHECK: t:
+; CHECK-NEXT: br label [[M:%.*]]
+; CHECK: f:
+; CHECK-NEXT: br label [[M]]
+; CHECK: m:
+; CHECK-NEXT: ret void
;
%stack = alloca i1
store i1 %arg, i1* %stack
@@ -984,35 +942,16 @@ m:
}
define void @assume_1b(i1 %arg, i1 %cond) {
-; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; TUNIT-LABEL: define {{[^@]+}}@assume_1b
-; TUNIT-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; TUNIT-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; TUNIT-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
-; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; TUNIT: t:
-; TUNIT-NEXT: br label [[M:%.*]]
-; TUNIT: f:
-; TUNIT-NEXT: br label [[M]]
-; TUNIT: m:
-; TUNIT-NEXT: ret void
-;
-; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; CGSCC-LABEL: define {{[^@]+}}@assume_1b
-; CGSCC-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; CGSCC-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; CGSCC-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
-; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; CGSCC: t:
-; CGSCC-NEXT: br label [[M:%.*]]
-; CGSCC: f:
-; CGSCC-NEXT: br label [[M]]
-; CGSCC: m:
-; CGSCC-NEXT: ret void
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
+; CHECK-LABEL: define {{[^@]+}}@assume_1b
+; CHECK-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
+; CHECK: t:
+; CHECK-NEXT: br label [[M:%.*]]
+; CHECK: f:
+; CHECK-NEXT: br label [[M]]
+; CHECK: m:
+; CHECK-NEXT: ret void
;
%stack = alloca i1
store i1 %arg, i1* %stack
@@ -1080,39 +1019,16 @@ m:
}
define void @assume_2b(i1 %arg, i1 %cond) {
-; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; TUNIT-LABEL: define {{[^@]+}}@assume_2b
-; TUNIT-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; TUNIT-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; TUNIT-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; TUNIT-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; TUNIT: t:
-; TUNIT-NEXT: store i1 true, i1* [[STACK]], align 1
-; TUNIT-NEXT: br label [[M:%.*]]
-; TUNIT: f:
-; TUNIT-NEXT: store i1 false, i1* [[STACK]], align 1
-; TUNIT-NEXT: br label [[M]]
-; TUNIT: m:
-; TUNIT-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; TUNIT-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR6]]
-; TUNIT-NEXT: ret void
-;
-; CGSCC: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
-; CGSCC-LABEL: define {{[^@]+}}@assume_2b
-; CGSCC-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
-; CGSCC-NEXT: [[STACK:%.*]] = alloca i1, align 1
-; CGSCC-NEXT: store i1 [[ARG]], i1* [[STACK]], align 1
-; CGSCC-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
-; CGSCC: t:
-; CGSCC-NEXT: store i1 true, i1* [[STACK]], align 1
-; CGSCC-NEXT: br label [[M:%.*]]
-; CGSCC: f:
-; CGSCC-NEXT: store i1 false, i1* [[STACK]], align 1
-; CGSCC-NEXT: br label [[M]]
-; CGSCC: m:
-; CGSCC-NEXT: [[L:%.*]] = load i1, i1* [[STACK]], align 1
-; CGSCC-NEXT: call void @llvm.assume(i1 noundef [[L]]) #[[ATTR7]]
-; CGSCC-NEXT: ret void
+; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(inaccessiblemem: readwrite)
+; CHECK-LABEL: define {{[^@]+}}@assume_2b
+; CHECK-SAME: (i1 [[ARG:%.*]], i1 [[COND:%.*]]) #[[ATTR3]] {
+; CHECK-NEXT: br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
+; CHECK: t:
+; CHECK-NEXT: br label [[M:%.*]]
+; CHECK: f:
+; CHECK-NEXT: br label [[M]]
+; CHECK: m:
+; CHECK-NEXT: ret void
;
%stack = alloca i1
store i1 %arg, i1* %stack
More information about the llvm-commits
mailing list