[Reland][InstCombine] Iterative replacement in PtrReplacer #145410
Merged
+175
−69
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
backend:AMDGPU
llvm:instcombine
|
@llvm/pr-subscribers-llvm-transforms @llvm/pr-subscribers-backend-amdgpu Author: Anshil Gandhi (gandhi56) ChangesThis patch enhances the PtrReplacer as follows:
This patch specifically fixes the case when an incoming value of a PHI is addrspacecasted. This reland PR includes a fix for an assertion failure caused by #137215, which was reverted. The failing test involved a phi and gep depending on each other, in which case the PtrReplacer did not order them correctly for replacement. This patch fixes it by adding a check during the definition of Full diff: https://github.com/llvm/llvm-project/pull/145410.diff 2 Files Affected:
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
index a9751ab03e20e..bcf52f7e31a9b 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
@@ -243,11 +243,10 @@ class PointerReplacer {
void replacePointer(Value *V);
private:
- bool collectUsersRecursive(Instruction &I);
void replace(Instruction *I);
- Value *getReplacement(Value *I);
+ Value *getReplacement(Value *V) const { return WorkMap.lookup(V); }
bool isAvailable(Instruction *I) const {
- return I == &Root || Worklist.contains(I);
+ return I == &Root || UsersToReplace.contains(I);
}
bool isEqualOrValidAddrSpaceCast(const Instruction *I,
@@ -259,8 +258,7 @@ class PointerReplacer {
return (FromAS == ToAS) || IC.isValidAddrSpaceCast(FromAS, ToAS);
}
- SmallPtrSet<Instruction *, 32> ValuesToRevisit;
- SmallSetVector<Instruction *, 4> Worklist;
+ SmallSetVector<Instruction *, 32> UsersToReplace;
MapVector<Value *, Value *> WorkMap;
InstCombinerImpl &IC;
Instruction &Root;
@@ -269,72 +267,79 @@ class PointerReplacer {
} // end anonymous namespace
bool PointerReplacer::collectUsers() {
- if (!collectUsersRecursive(Root))
- return false;
-
- // Ensure that all outstanding (indirect) users of I
- // are inserted into the Worklist. Return false
- // otherwise.
- return llvm::set_is_subset(ValuesToRevisit, Worklist);
-}
+ SmallVector<Instruction *> Worklist;
+ SmallSetVector<Instruction *, 32> ValuesToRevisit;
+
+ auto PushUsersToWorklist = [&](Instruction *Inst) {
+ for (auto *U : Inst->users())
+ if (auto *I = dyn_cast<Instruction>(U))
+ if (!isAvailable(I) && !ValuesToRevisit.contains(I))
+ Worklist.emplace_back(I);
+ };
-bool PointerReplacer::collectUsersRecursive(Instruction &I) {
- for (auto *U : I.users()) {
- auto *Inst = cast<Instruction>(&*U);
+ PushUsersToWorklist(&Root);
+ while (!Worklist.empty()) {
+ Instruction *Inst = Worklist.pop_back_val();
if (auto *Load = dyn_cast<LoadInst>(Inst)) {
if (Load->isVolatile())
return false;
- Worklist.insert(Load);
+ UsersToReplace.insert(Load);
} else if (auto *PHI = dyn_cast<PHINode>(Inst)) {
- // All incoming values must be instructions for replacability
- if (any_of(PHI->incoming_values(),
- [](Value *V) { return !isa<Instruction>(V); }))
- return false;
-
- // If at least one incoming value of the PHI is not in Worklist,
- // store the PHI for revisiting and skip this iteration of the
- // loop.
- if (any_of(PHI->incoming_values(), [this](Value *V) {
- return !isAvailable(cast<Instruction>(V));
+ /// TODO: Handle poison and null pointers for PHI and select.
+ // If all incoming values are available, mark this PHI as
+ // replacable and push it's users into the worklist.
+ bool IsReplacable = true;
+ if (all_of(PHI->incoming_values(), [&](Value *V) {
+ if (!isa<Instruction>(V))
+ return IsReplacable = false;
+ return isAvailable(cast<Instruction>(V));
})) {
- ValuesToRevisit.insert(Inst);
+ UsersToReplace.insert(PHI);
+ PushUsersToWorklist(PHI);
continue;
}
- Worklist.insert(PHI);
- if (!collectUsersRecursive(*PHI))
- return false;
- } else if (auto *SI = dyn_cast<SelectInst>(Inst)) {
- if (!isa<Instruction>(SI->getTrueValue()) ||
- !isa<Instruction>(SI->getFalseValue()))
+ // Either an incoming value is not an instruction or not all
+ // incoming values are available. If this PHI was already
+ // visited prior to this iteration, return false.
+ if (!IsReplacable || !ValuesToRevisit.insert(PHI))
return false;
- if (!isAvailable(cast<Instruction>(SI->getTrueValue())) ||
- !isAvailable(cast<Instruction>(SI->getFalseValue()))) {
- ValuesToRevisit.insert(Inst);
- continue;
+ // Push PHI back into the stack, followed by unavailable
+ // incoming values.
+ Worklist.emplace_back(PHI);
+ for (unsigned Idx = 0; Idx < PHI->getNumIncomingValues(); ++Idx) {
+ auto *IncomingValue = cast<Instruction>(PHI->getIncomingValue(Idx));
+ if (UsersToReplace.contains(IncomingValue))
+ continue;
+ if (!ValuesToRevisit.insert(IncomingValue))
+ return false;
+ Worklist.emplace_back(IncomingValue);
}
- Worklist.insert(SI);
- if (!collectUsersRecursive(*SI))
- return false;
- } else if (isa<GetElementPtrInst>(Inst)) {
- Worklist.insert(Inst);
- if (!collectUsersRecursive(*Inst))
+ } else if (auto *SI = dyn_cast<SelectInst>(Inst)) {
+ auto *TrueInst = dyn_cast<Instruction>(SI->getTrueValue());
+ auto *FalseInst = dyn_cast<Instruction>(SI->getFalseValue());
+ if (!TrueInst || !FalseInst)
return false;
+
+ UsersToReplace.insert(SI);
+ PushUsersToWorklist(SI);
+ } else if (auto *GEP = dyn_cast<GetElementPtrInst>(Inst)) {
+ UsersToReplace.insert(GEP);
+ PushUsersToWorklist(GEP);
} else if (auto *MI = dyn_cast<MemTransferInst>(Inst)) {
if (MI->isVolatile())
return false;
- Worklist.insert(Inst);
+ UsersToReplace.insert(Inst);
} else if (isEqualOrValidAddrSpaceCast(Inst, FromAS)) {
- Worklist.insert(Inst);
- if (!collectUsersRecursive(*Inst))
- return false;
+ UsersToReplace.insert(Inst);
+ PushUsersToWorklist(Inst);
} else if (Inst->isLifetimeStartOrEnd()) {
continue;
} else {
// TODO: For arbitrary uses with address space mismatches, should we check
// if we can introduce a valid addrspacecast?
- LLVM_DEBUG(dbgs() << "Cannot handle pointer user: " << *U << '\n');
+ LLVM_DEBUG(dbgs() << "Cannot handle pointer user: " << *Inst << '\n');
return false;
}
}
@@ -342,7 +347,39 @@ bool PointerReplacer::collectUsersRecursive(Instruction &I) {
return true;
}
-Value *PointerReplacer::getReplacement(Value *V) { return WorkMap.lookup(V); }
+void PointerReplacer::replacePointer(Value *V) {
+ assert(cast<PointerType>(Root.getType()) != cast<PointerType>(V->getType()) &&
+ "Invalid usage");
+ WorkMap[&Root] = V;
+ SmallVector<Instruction *> Worklist;
+ SetVector<Instruction *> PostOrderWorklist;
+ SmallPtrSet<Instruction *, 32> Visited;
+
+ // Perform a postorder traversal of the users of Root.
+ Worklist.push_back(&Root);
+ while (!Worklist.empty()) {
+ Instruction *I = Worklist.back();
+
+ // If I has not been processed before, push each of its
+ // replacable users into the worklist.
+ if (Visited.insert(I).second) {
+ for (auto *U : I->users()) {
+ auto *UserInst = cast<Instruction>(U);
+ if (UsersToReplace.contains(UserInst) && !Visited.contains(UserInst))
+ Worklist.push_back(UserInst);
+ }
+ // Otherwise, users of I have already been pushed into
+ // the PostOrderWorklist. Push I as well.
+ } else {
+ PostOrderWorklist.insert(I);
+ Worklist.pop_back();
+ }
+ }
+
+ // Replace pointers in reverse-postorder.
+ for (Instruction *I : reverse(PostOrderWorklist))
+ replace(I);
+}
void PointerReplacer::replace(Instruction *I) {
if (getReplacement(I))
@@ -364,13 +401,15 @@ void PointerReplacer::replace(Instruction *I) {
// replacement (new value).
WorkMap[NewI] = NewI;
} else if (auto *PHI = dyn_cast<PHINode>(I)) {
- Type *NewTy = getReplacement(PHI->getIncomingValue(0))->getType();
- auto *NewPHI = PHINode::Create(NewTy, PHI->getNumIncomingValues(),
- PHI->getName(), PHI->getIterator());
- for (unsigned int I = 0; I < PHI->getNumIncomingValues(); ++I)
- NewPHI->addIncoming(getReplacement(PHI->getIncomingValue(I)),
- PHI->getIncomingBlock(I));
- WorkMap[PHI] = NewPHI;
+ // Create a new PHI by replacing any incoming value that is a user of the
+ // root pointer and has a replacement.
+ Value *V = WorkMap.lookup(PHI->getIncomingValue(0));
+ PHI->mutateType(V ? V->getType() : PHI->getIncomingValue(0)->getType());
+ for (unsigned int I = 0; I < PHI->getNumIncomingValues(); ++I) {
+ Value *V = WorkMap.lookup(PHI->getIncomingValue(I));
+ PHI->setIncomingValue(I, V ? V : PHI->getIncomingValue(I));
+ }
+ WorkMap[PHI] = PHI;
} else if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
auto *V = getReplacement(GEP->getPointerOperand());
assert(V && "Operand not replaced");
@@ -434,18 +473,6 @@ void PointerReplacer::replace(Instruction *I) {
}
}
-void PointerReplacer::replacePointer(Value *V) {
-#ifndef NDEBUG
- auto *PT = cast<PointerType>(Root.getType());
- auto *NT = cast<PointerType>(V->getType());
- assert(PT != NT && "Invalid usage");
-#endif
- WorkMap[&Root] = V;
-
- for (Instruction *Workitem : Worklist)
- replace(Workitem);
-}
-
Instruction *InstCombinerImpl::visitAllocaInst(AllocaInst &AI) {
if (auto *I = simplifyAllocaArraySize(*this, AI, DT))
return I;
diff --git a/llvm/test/Transforms/InstCombine/AMDGPU/ptr-replace-alloca.ll b/llvm/test/Transforms/InstCombine/AMDGPU/ptr-replace-alloca.ll
new file mode 100644
index 0000000000000..538cc19f9722e
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/AMDGPU/ptr-replace-alloca.ll
@@ -0,0 +1,79 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
+; RUN: opt -mtriple=amdgcn-amd-amdhsa -passes=instcombine -S < %s | FileCheck %s
+
+%struct.type = type { [256 x <2 x i64>] }
+@g1 = external hidden addrspace(3) global %struct.type, align 16
+
+; This test requires the PtrReplacer to replace users in an RPO traversal.
+; Furthermore, %ptr.else need not to be replaced so it must be retained in
+; %ptr.sink.
+define <2 x i64> @func(ptr addrspace(4) byref(%struct.type) align 16 %0, i1 %cmp.0) {
+; CHECK-LABEL: define <2 x i64> @func(
+; CHECK-SAME: ptr addrspace(4) byref([[STRUCT_TYPE:%.*]]) align 16 [[TMP0:%.*]], i1 [[CMP_0:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*:]]
+; CHECK-NEXT: br i1 [[CMP_0]], label %[[IF_THEN:.*]], label %[[IF_ELSE:.*]]
+; CHECK: [[IF_THEN]]:
+; CHECK-NEXT: [[VAL_THEN:%.*]] = addrspacecast ptr addrspace(4) [[TMP0]] to ptr
+; CHECK-NEXT: br label %[[SINK:.*]]
+; CHECK: [[IF_ELSE]]:
+; CHECK-NEXT: [[PTR_ELSE:%.*]] = load ptr, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @g1, i32 32), align 16
+; CHECK-NEXT: br label %[[SINK]]
+; CHECK: [[SINK]]:
+; CHECK-NEXT: [[PTR_SINK:%.*]] = phi ptr [ [[PTR_ELSE]], %[[IF_ELSE]] ], [ [[VAL_THEN]], %[[IF_THEN]] ]
+; CHECK-NEXT: [[VAL_SINK:%.*]] = load <2 x i64>, ptr [[PTR_SINK]], align 16
+; CHECK-NEXT: ret <2 x i64> [[VAL_SINK]]
+;
+entry:
+ %coerce = alloca %struct.type, align 16, addrspace(5)
+ call void @llvm.memcpy.p5.p4.i64(ptr addrspace(5) align 16 %coerce, ptr addrspace(4) align 16 %0, i64 4096, i1 false)
+ br i1 %cmp.0, label %if.then, label %if.else
+
+if.then: ; preds = %entry
+ %ptr.then = getelementptr inbounds i8, ptr addrspace(5) %coerce, i64 0
+ %val.then = addrspacecast ptr addrspace(5) %ptr.then to ptr
+ br label %sink
+
+if.else: ; preds = %entry
+ %ptr.else = load ptr, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @g1, i32 32), align 16
+ %val.else = getelementptr inbounds nuw i8, ptr %ptr.else, i64 0
+ br label %sink
+
+sink:
+ %ptr.sink = phi ptr [ %val.else, %if.else ], [ %val.then, %if.then ]
+ %val.sink = load <2 x i64>, ptr %ptr.sink, align 16
+ ret <2 x i64> %val.sink
+}
+
+define <2 x i64> @func_phi_loop(ptr addrspace(4) byref(%struct.type) align 16 %0, i1 %cmp.0) {
+; CHECK-LABEL: define <2 x i64> @func_phi_loop(
+; CHECK-SAME: ptr addrspace(4) byref([[STRUCT_TYPE:%.*]]) align 16 [[TMP0:%.*]], i1 [[CMP_0:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[VAL_0:%.*]] = addrspacecast ptr addrspace(4) [[TMP0]] to ptr
+; CHECK-NEXT: br label %[[LOOP:.*]]
+; CHECK: [[LOOP]]:
+; CHECK-NEXT: [[PTR_PHI_R:%.*]] = phi ptr [ [[PTR_1:%.*]], %[[LOOP]] ], [ [[VAL_0]], %[[ENTRY]] ]
+; CHECK-NEXT: [[PTR_1]] = load ptr, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @g1, i32 32), align 16
+; CHECK-NEXT: br i1 [[CMP_0]], label %[[LOOP]], label %[[SINK:.*]]
+; CHECK: [[SINK]]:
+; CHECK-NEXT: [[VAL_SINK:%.*]] = load <2 x i64>, ptr [[PTR_PHI_R]], align 16
+; CHECK-NEXT: ret <2 x i64> [[VAL_SINK]]
+;
+entry:
+ %coerce = alloca %struct.type, align 16, addrspace(5)
+ call void @llvm.memcpy.p5.p4.i64(ptr addrspace(5) align 16 %coerce, ptr addrspace(4) align 16 %0, i64 4096, i1 false)
+ %ptr.0 = getelementptr inbounds i8, ptr addrspace(5) %coerce, i64 0
+ %val.0 = addrspacecast ptr addrspace(5) %ptr.0 to ptr
+ br label %loop
+
+loop:
+ %ptr.phi = phi ptr [ %val.1, %loop ], [ %val.0, %entry ]
+ %ptr.1 = load ptr, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @g1, i32 32), align 16
+ %val.1 = getelementptr inbounds nuw i8, ptr %ptr.1, i64 0
+ br i1 %cmp.0, label %loop, label %sink
+
+sink:
+ %val.sink = load <2 x i64>, ptr %ptr.phi, align 16
+ ret <2 x i64> %val.sink
+}
+
+declare void @llvm.memcpy.p5.p4.i64(ptr addrspace(5) noalias writeonly captures(none), ptr addrspace(4) noalias readonly captures(none), i64, i1 immarg) #0
|
There was a problem hiding this comment.
Pull Request Overview
This PR refactors PointerReplacer to collect users iteratively, perform replacements in reverse-postorder, and improve PHI handling by keeping incoming values when no replacement is available. It also adds tests to cover cases with addrspacecasted PHI incoming values and cyclical PHI/GEP dependencies.
- Switch from recursive user collection to an explicit worklist and
UsersToReplaceset. - Introduce a postorder traversal for safe reverse-postorder replacement.
- Update PHI replacement to mutate types in place and preserve original incoming values if no replacement exists.
Reviewed Changes
Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.
| File | Description |
|---|---|
| llvm/test/Transforms/InstCombine/AMDGPU/ptr-replace-alloca.ll | New LLVM IR tests verifying RPO-based pointer replacement and PHI loops. |
| llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp | Refactored PointerReplacer: iterative collection, postorder worklist, PHI logic. |
Comments suppressed due to low confidence (3)
llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp:291
- [nitpick] The variable name
IsReplacableis misspelled; the correct spelling isIsReplaceable.
bool IsReplacable = true;
llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp:269
- The
collectUsersmethod lacks a return statement at the end, leading to undefined behavior when it’s called. It should returntrue(orfalseon failure) after the worklist loop completes.
bool PointerReplacer::collectUsers() {
llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp:305
- This condition always returns false on first encounter when
IsReplacableisfalse, preventing any revisits. It should only check whetherValuesToRevisit.insert(PHI)failed, notIsReplacable, to enable correct retry logic.
if (!IsReplacable || !ValuesToRevisit.insert(PHI))
shiltian
approved these changes
Jun 23, 2025
gandhi56
force-pushed
the
ptrreplacer-fix
branch
from
1ccca0b to
afea5be
Compare
This patch enhances the PtrReplacer as follows: 1. Users are now collected iteratively to be generous on the stack. In the case of PHIs with incoming values which have not yet been visited, they are pushed back into the stack for reconsideration. 2. Replace users of the pointer root in a reverse-postorder traversal, instead of a simple traversal over the collected users. This reordering ensures that the uses of an instruction are replaced before replacing the instruction itself. 3. During the replacement of PHI, use the same incoming value if it does not have a replacement. This patch specifically fixes the case when an incoming value of a PHI is addrspacecasted. This reland PR includes a fix for an assertion failure caused by llvm#137215, which was reverted. The failing test involved a phi and gep depending on each other, in which case the PtrReplacer did not order them correctly for replacement. This patch fixes it by adding a check during the population of PostOrderWorklist.
gandhi56
force-pushed
the
ptrreplacer-fix
branch
from
afea5be to
2fa5ff1
Compare
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/138/builds/15010 Here is the relevant piece of the build log for the reference |
DrSergei
pushed a commit
to DrSergei/llvm-project
that referenced
this pull request
Jun 24, 2025
This patch enhances the PtrReplacer as follows: 1. Users are now collected iteratively to be generous on the stack. In the case of PHIs with incoming values which have not yet been visited, they are pushed back into the stack for reconsideration. 2. Replace users of the pointer root in a reverse-postorder traversal, instead of a simple traversal over the collected users. This reordering ensures that the uses of an instruction are replaced before replacing the instruction itself. 3. During the replacement of PHI, use the same incoming value if it does not have a replacement. This patch specifically fixes the case when an incoming value of a PHI is addrspacecasted. This reland PR includes a fix for an assertion failure caused by llvm#137215, which was reverted. The failing test involved a phi and gep depending on each other, in which case the PtrReplacer did not order them correctly for replacement. This patch fixes it by adding a check during the definition of `PostOrderWorklist`.
anthonyhatran
pushed a commit
to anthonyhatran/llvm-project
that referenced
this pull request
Jun 26, 2025
This patch enhances the PtrReplacer as follows: 1. Users are now collected iteratively to be generous on the stack. In the case of PHIs with incoming values which have not yet been visited, they are pushed back into the stack for reconsideration. 2. Replace users of the pointer root in a reverse-postorder traversal, instead of a simple traversal over the collected users. This reordering ensures that the uses of an instruction are replaced before replacing the instruction itself. 3. During the replacement of PHI, use the same incoming value if it does not have a replacement. This patch specifically fixes the case when an incoming value of a PHI is addrspacecasted. This reland PR includes a fix for an assertion failure caused by llvm#137215, which was reverted. The failing test involved a phi and gep depending on each other, in which case the PtrReplacer did not order them correctly for replacement. This patch fixes it by adding a check during the definition of `PostOrderWorklist`.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This patch enhances the PtrReplacer as follows:
This patch specifically fixes the case when an incoming value of a PHI is addrspacecasted.
This reland PR includes a fix for an assertion failure caused by #137215, which was reverted. The failing test involved a phi and gep depending on each other, in which case the PtrReplacer did not order them correctly for replacement. This patch fixes it by adding a check during the definition of
PostOrderWorklist.