maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[DSE] Revisit pointers that may no longer escape after removing another store 

In dependent-capture, previously we'd see that %tmp4 is captured due to
the first store. We'd cache this info in CapturedBeforeReturn and
InvisibleToCallerAfterRet. Then the first store is then removed, causing
the cached values to be wrong.

We also need to revisit everything because normally we work backwards
when removing stores at the end of the function, but in this case
removing an earlier store causes a later store to be removable.

No compile time impact:
https://llvm-compile-time-tracker.com/compare.php?from=56796ae1a8db4c85dada28676f8303a5a3609c63&to=21b7e5248ffc423cd36c9d4a020085e363451465&stat=instructions

Reviewed By: asbirlea

Differential Revision: https://reviews.llvm.org/D123686
This commit is contained in:
Arthur Eubanks 2022-04-12 16:22:49 -07:00
parent 3d6c10dcf3
commit 13aa2c1c3b
2 changed files with 39 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
View File

@ -776,6 +776,11 @@ struct DSEState {
// fall back to CFG scan starting from all non-unreachable roots.
bool AnyUnreachableExit;
// Whether or not we should iterate on removing dead stores at the end of the
// function due to removing a store causing a previously captured pointer to
// no longer be captured.
bool ShouldIterateEndOfFunctionDSE;
// Class contains self-reference, make sure it's not copied/moved.
DSEState(const DSEState &) = delete;
DSEState &operator=(const DSEState &) = delete;
@ -1598,6 +1603,14 @@ struct DSEState {
if (MemoryAccess *MA = MSSA.getMemoryAccess(DeadInst)) {
if (MemoryDef *MD = dyn_cast<MemoryDef>(MA)) {
SkipStores.insert(MD);
if (auto *SI = dyn_cast<StoreInst>(MD->getMemoryInst())) {
if (SI->getValueOperand()->getType()->isPointerTy()) {
const Value *UO = getUnderlyingObject(SI->getValueOperand());
if (CapturedBeforeReturn.erase(UO))
ShouldIterateEndOfFunctionDSE = true;
InvisibleToCallerAfterRet.erase(UO);
}
}
}
Updater.removeMemoryAccess(MA);
@ -1671,6 +1684,8 @@ struct DSEState {
LLVM_DEBUG(
dbgs()
<< "Trying to eliminate MemoryDefs at the end of the function\n");
do {
ShouldIterateEndOfFunctionDSE = false;
for (MemoryDef *Def : llvm::reverse(MemDefs)) {
if (SkipStores.contains(Def))
continue;
@ -1680,11 +1695,11 @@ struct DSEState {
if (!DefLoc || !isRemovable(DefI))
continue;
// NOTE: Currently eliminating writes at the end of a function is limited
// to MemoryDefs with a single underlying object, to save compile-time. In
// practice it appears the case with multiple underlying objects is very
// uncommon. If it turns out to be important, we can use
// getUnderlyingObjects here instead.
// NOTE: Currently eliminating writes at the end of a function is
// limited to MemoryDefs with a single underlying object, to save
// compile-time. In practice it appears the case with multiple
// underlying objects is very uncommon. If it turns out to be important,
// we can use getUnderlyingObjects here instead.
const Value *UO = getUnderlyingObject(DefLoc->Ptr);
if (!isInvisibleToCallerAfterRet(UO))
continue;
@ -1698,6 +1713,7 @@ struct DSEState {
MadeChange = true;
}
}
} while (ShouldIterateEndOfFunctionDSE);
return MadeChange;
}

1
llvm/test/Transforms/DeadStoreElimination/dependent-capture.ll
View File

@ -5,7 +5,6 @@ define void @f() {
; CHECK-LABEL: @f(
; CHECK-NEXT: [[TMP1:%.*]] = call noalias ptr @_Znwm()
; CHECK-NEXT: [[TMP4:%.*]] = call noalias ptr @_Znwm()
; CHECK-NEXT: store i8 0, ptr [[TMP4]], align 1
; CHECK-NEXT: ret void
;
%tmp1 = call noalias ptr @_Znwm()