[llvm] [DeadStoreElimination] Optimize tautological assignments (PR #75744)
Shreyansh Chouhan via llvm-commits
llvm-commits at lists.llvm.org
Sat Jan 13 07:30:21 PST 2024
https://github.com/BK1603 updated https://github.com/llvm/llvm-project/pull/75744
>From 2c1b642848fa738305ba22cedd821f37a9f7a786 Mon Sep 17 00:00:00 2001
From: Shreyansh Chouhan <chouhan.shreyansh2702 at gmail.com>
Date: Sun, 17 Dec 2023 22:48:51 +0530
Subject: [PATCH] [DeadStoreElimination] Optimize tautological assignments
If a store is immediately dominated by a condition that ensures that the value
being stored in a memory location is already present at that memory location,
consider the store a noop.
Fixes #63419
---
.../Scalar/DeadStoreElimination.cpp | 48 +++
.../DeadStoreElimination/noop-stores.ll | 302 ++++++++++++++++++
2 files changed, 350 insertions(+)
diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
index 008dcc53fd44fc..ec18b78a993c42 100644
--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -1901,6 +1901,51 @@ struct DSEState {
return true;
}
+ // Check if there is a dominating condition, that implies that the value
+ // being stored in a ptr is already present in the ptr.
+ bool dominatingConditionImpliesValue(MemoryDef *Def) {
+ auto *StoreI = dyn_cast<StoreInst>(Def->getMemoryInst());
+ BasicBlock *StoreBB = StoreI->getParent();
+ Value *StorePtr = StoreI->getPointerOperand();
+ Value *StoreVal = StoreI->getValueOperand();
+
+ DomTreeNode *IDom = DT.getNode(StoreBB)->getIDom();
+ if (!IDom)
+ return false;
+
+ auto *BI = dyn_cast<BranchInst>(IDom->getBlock()->getTerminator());
+ if (!BI || !BI->isConditional())
+ return false;
+
+ // In case both blocks are the same, it is not possible to determine
+ // if optimization is possible. (We would not want to optimize a store
+ // in the FalseBB if condition is true and vice versa.)
+ if (BI->getSuccessor(0) == BI->getSuccessor(1))
+ return false;
+
+ Instruction *ICmpL;
+ ICmpInst::Predicate Pred;
+ if (!match(BI->getCondition(),
+ m_c_ICmp(Pred,
+ m_CombineAnd(m_Load(m_Specific(StorePtr)),
+ m_Instruction(ICmpL)),
+ m_Specific(StoreVal))) ||
+ !ICmpInst::isEquality(Pred))
+ return false;
+
+ if (Pred == ICmpInst::ICMP_EQ && StoreBB != BI->getSuccessor(0))
+ return false;
+
+ if (Pred == ICmpInst::ICMP_NE && StoreBB != BI->getSuccessor(1))
+ return false;
+
+ MemoryAccess *LoadAcc = MSSA.getMemoryAccess(ICmpL);
+ MemoryAccess *ClobAcc =
+ MSSA.getSkipSelfWalker()->getClobberingMemoryAccess(Def, BatchAA);
+
+ return MSSA.dominates(ClobAcc, LoadAcc);
+ }
+
/// \returns true if \p Def is a no-op store, either because it
/// directly stores back a loaded value or stores zero to a calloced object.
bool storeIsNoop(MemoryDef *Def, const Value *DefUO) {
@@ -1931,6 +1976,9 @@ struct DSEState {
if (!Store)
return false;
+ if (dominatingConditionImpliesValue(Def))
+ return true;
+
if (auto *LoadI = dyn_cast<LoadInst>(Store->getOperand(0))) {
if (LoadI->getPointerOperand() == Store->getOperand(1)) {
// Get the defining access for the load.
diff --git a/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll b/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll
index 3703b8d039ead0..2d6338f38593ed 100644
--- a/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll
+++ b/llvm/test/Transforms/DeadStoreElimination/noop-stores.ll
@@ -795,3 +795,305 @@ join:
store i8 %v, ptr %q, align 1
ret void
}
+
+; Dominating condition implies value already exists, optimize store
+define void @remove_tautological_store_eq(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_eq(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store i32 4, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+define void @remove_tautological_store_var(ptr %x, ptr %y) {
+; CHECK-LABEL: @remove_tautological_store_var(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VALX:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[VALY:%.*]] = load i32, ptr [[Y:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VALX]], [[VALY]]
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %valx = load i32, ptr %x, align 4
+ %valy = load i32, ptr %y, align 4
+ %cmp = icmp eq i32 %valx, %valy
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store i32 %valy, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+define void @remove_tautological_store_ne(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_ne(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_NE:%.*]], label [[END:%.*]]
+; CHECK: if.ne:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp ne i32 %val, 4
+ br i1 %cmp, label %if.ne, label %end
+
+if.ne:
+ br label %end
+
+end:
+ store i32 4, ptr %x, align 4
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+define void @remove_tautological_store_atomic(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_atomic(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store atomic i32 4, ptr %x unordered, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since the store is in incorrect branch
+define void @remove_tautological_store_eq_fail(ptr %x, ptr %y) {
+; CHECK-LABEL: @remove_tautological_store_eq_fail(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VALX:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[VALY:%.*]] = load i32, ptr [[Y:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VALX]], [[VALY]]
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: store i32 [[VALY]], ptr [[X]], align 4
+; CHECK-NEXT: ret void
+;
+entry:
+ %valx = load i32, ptr %x, align 4
+ %valy = load i32, ptr %y, align 4
+ %cmp = icmp eq i32 %valx, %valy
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ br label %end
+
+end:
+ store i32 %valy, ptr %x, align 4
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since the store is in incorrect branch
+define void @remove_tautological_store_ne_fail(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_ne_fail(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_NE:%.*]], label [[END:%.*]]
+; CHECK: if.ne:
+; CHECK-NEXT: store i32 4, ptr [[X]], align 4
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp ne i32 %val, 4
+ br i1 %cmp, label %if.ne, label %end
+
+if.ne:
+ store i32 4, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since we cannot determine if we should when both
+; branches are the same
+define void @remove_tautological_store_same_branch_fail(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_same_branch_fail(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[IF_EQ]]
+; CHECK: if.eq:
+; CHECK-NEXT: store i32 4, ptr [[X]], align 4
+; CHECK-NEXT: br label [[END:%.*]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %if.eq
+
+if.eq:
+ store i32 4, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since value being stored is different from cond check
+define void @remove_tautological_store_fail_diff_value(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_fail_diff_value(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: store i32 5, ptr [[X]], align 4
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store i32 5, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since there is a clobbering acc after load
+define void @remove_tautological_store_fail_clobber(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_fail_clobber(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: store i32 5, ptr [[X]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: store i32 4, ptr [[X]], align 4
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ store i32 5, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store i32 4, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize since the condition does not dominate the store
+define void @remove_tautological_store_fail_idom(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_fail_idom(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[IF_ELSE:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: br label [[END:%.*]]
+; CHECK: if.else:
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: store i32 4, ptr [[X]], align 4
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ store i32 5, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %if.else
+
+if.eq:
+ br label %end
+
+if.else:
+ br label %end
+
+end:
+ store i32 4, ptr %x, align 4
+ ret void
+}
+
+; Dominating condition implies value already exists, optimize store
+; Should not optimize volatile stores
+define void @remove_tautological_store_volatile(ptr %x) {
+; CHECK-LABEL: @remove_tautological_store_volatile(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: [[VAL:%.*]] = load i32, ptr [[X:%.*]], align 4
+; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[VAL]], 4
+; CHECK-NEXT: br i1 [[CMP]], label [[IF_EQ:%.*]], label [[END:%.*]]
+; CHECK: if.eq:
+; CHECK-NEXT: store volatile i32 4, ptr [[X]], align 4
+; CHECK-NEXT: br label [[END]]
+; CHECK: end:
+; CHECK-NEXT: ret void
+;
+entry:
+ %val = load i32, ptr %x, align 4
+ %cmp = icmp eq i32 %val, 4
+ br i1 %cmp, label %if.eq, label %end
+
+if.eq:
+ store volatile i32 4, ptr %x, align 4
+ br label %end
+
+end:
+ ret void
+}
More information about the llvm-commits
mailing list