This is an archive of the discontinued LLVM Phabricator instance.

Differential D98346

[DSE] Handle memmove with equal non-const sizes
ClosedPublic

Authored by xbolva00 on Mar 10 2021, 6:26 AM.

Details

Reviewers
fhahn
Commits
rGc68b560be381: [DSE] Handle memmove with equal non-const sizes
Summary

Follow up for fhahn's D98284. Also fixes a case from PR47644.

Diff Detail

Event Timeline

xbolva00 created this revision.Mar 10 2021, 6:26 AM
Herald added a subscriber: hiraditya. · View Herald TranscriptMar 10 2021, 6:26 AM
xbolva00 requested review of this revision.Mar 10 2021, 6:26 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 10 2021, 6:26 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
xbolva00 edited the summary of this revision. (Show Details)Mar 10 2021, 6:27 AM
nikic added a subscriber: nikic.Mar 10 2021, 6:35 AM
nikic added inline comments.
llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
375–376

Use dyn_cast<MemIntrinsic> + getLength() instead?

xbolva00 updated this revision to Diff 329679.Mar 10 2021, 8:30 AM

Updated, thanks @nikic

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
375–376

good idea!

fhahn accepted this revision.Mar 10 2021, 8:37 AM

Neat, LGTM, thanks!

This revision is now accepted and ready to land.Mar 10 2021, 8:37 AM
xbolva00 updated this revision to Diff 329682.Mar 10 2021, 8:50 AM

Added 2 tests for memcpy/memmove combo.

This revision was landed with ongoing or failed builds.Mar 10 2021, 8:52 AM
Closed by commit rGc68b560be381: [DSE] Handle memmove with equal non-const sizes (authored by xbolva00). · Explain Why
This revision was automatically updated to reflect the committed changes.
xbolva00 added a commit: rGc68b560be381: [DSE] Handle memmove with equal non-const sizes.
Harbormaster completed remote builds in B93083: Diff 329645.Mar 10 2021, 5:45 PM
Harbormaster completed remote builds in B93110: Diff 329679.Mar 10 2021, 8:06 PM
Harbormaster completed remote builds in B93114: Diff 329682.Mar 10 2021, 8:20 PM

Revision Contents

PathSize
llvm/
lib/
Transforms/
Scalar/
24 lines
test/
Transforms/
DeadStoreElimination/
150 lines

Diff 329682

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 366 Lines • ▼ Show 20 LinesisOverwrite(const Instruction *LaterI, const Instruction *EarlierI,
const MemoryLocation &Later, const MemoryLocation &Earlier, const MemoryLocation &Later, const MemoryLocation &Earlier,
const DataLayout &DL, const TargetLibraryInfo &TLI, const DataLayout &DL, const TargetLibraryInfo &TLI,
int64_t &EarlierOff, int64_t &LaterOff, BatchAAResults &AA, int64_t &EarlierOff, int64_t &LaterOff, BatchAAResults &AA,
const Function *F) { const Function *F) {
// FIXME: Vet that this works for size upper-bounds. Seems unlikely that we'll // FIXME: Vet that this works for size upper-bounds. Seems unlikely that we'll
// get imprecise values here, though (except for unknown sizes). // get imprecise values here, though (except for unknown sizes).
if (!Later.Size.isPrecise() || !Earlier.Size.isPrecise()) { if (!Later.Size.isPrecise() || !Earlier.Size.isPrecise()) {
// In case no constant size is known, try to an IR values for the number // In case no constant size is known, try to an IR values for the number
// of bytes written and check if they match. // of bytes written and check if they match.
auto GetSizeFromInstr = [](const Instruction *I) -> Value * { const auto *LaterMemI = dyn_cast<MemIntrinsic>(LaterI);
nikicUnsubmitted
Not Done
ReplyInline Actions

Use dyn_cast<MemIntrinsic> + getLength() instead?

nikic: Use `dyn_cast<MemIntrinsic>` + `getLength()` instead?
xbolva00AuthorUnsubmitted
Done
ReplyInline Actions

good idea!

xbolva00: good idea!
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) { const auto *EarlierMemI = dyn_cast<MemIntrinsic>(EarlierI);
switch (II->getIntrinsicID()) { if (LaterMemI && EarlierMemI) {
default: const Value *LaterV = LaterMemI->getLength();
return nullptr; const Value *EarlierV = EarlierMemI->getLength();
case Intrinsic::memcpy: if (LaterV == EarlierV && AA.isMustAlias(Earlier, Later))
case Intrinsic::memset:
return II->getArgOperand(2);
}
}
return nullptr;
};
Value *LaterV = GetSizeFromInstr(LaterI);
Value *EarlierV = GetSizeFromInstr(EarlierI);
if (LaterV && LaterV == EarlierV && AA.isMustAlias(Earlier, Later))
return OW_Complete; return OW_Complete;
}
// Masked stores have imprecise locations, but we can reason about them // Masked stores have imprecise locations, but we can reason about them
// to some extent. // to some extent.
return isMaskedStoreOverwrite(LaterI, EarlierI, AA); return isMaskedStoreOverwrite(LaterI, EarlierI, AA);
} }
const uint64_t LaterSize = Later.Size.getValue(); const uint64_t LaterSize = Later.Size.getValue();
const uint64_t EarlierSize = Earlier.Size.getValue(); const uint64_t EarlierSize = Earlier.Size.getValue();
▲ Show 20 Lines • Show All 1,700 Lines • Show Last 20 Lines

llvm/test/Transforms/DeadStoreElimination/memory-intrinsics-sizes.ll

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST]], i8 0, i64 [[LEN_1:%.*]], i1 false) ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST]], i8 0, i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.1, i1 false) call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.1, i1 false)
ret void ret void
} }
define void @memmove_equal_size_values(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memmove_equal_size_values(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
ret void
}
define void @memmove_different_size_values_1(i8* noalias %src, i8* noalias %dst, i64 %len.1, i64 %len.2) {
; CHECK-LABEL: @memmove_different_size_values_1(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC]], i64 [[LEN_2:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.1, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.2, i1 false)
ret void
}
define void @memmove_different_size_values_2(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memmove_different_size_values_2(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC]], i64 100, i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false)
ret void
}
define void @memmove_different_size_values_3(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memmove_different_size_values_3(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 100, i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
ret void
}
define void @memset_and_memmove_equal_size_values(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memset_and_memmove_equal_size_values(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
ret void
}
define void @memset_and_memmove_different_size_values_1(i8* noalias %src, i8* noalias %dst, i64 %len.1, i64 %len.2) {
; CHECK-LABEL: @memset_and_memmove_different_size_values_1(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST:%.*]], i8 0, i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC:%.*]], i64 [[LEN_2:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.1, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.2, i1 false)
ret void
}
define void @memset_and_memmove_different_size_values_2(i8* noalias %src, i8* noalias %dst, i64 %len.1) {
; CHECK-LABEL: @memset_and_memmove_different_size_values_2(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST:%.*]], i8 0, i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC:%.*]], i64 100, i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.1, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false)
ret void
}
define void @memset_and_memmove_different_size_values_3(i8* noalias %src, i8* noalias %dst, i64 %len.1) {
; CHECK-LABEL: @memset_and_memmove_different_size_values_3(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST:%.*]], i8 0, i64 100, i1 false)
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST]], i8* [[SRC:%.*]], i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 100, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.1, i1 false)
ret void
}
define void @memmove_and_memset_equal_size_values(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memmove_and_memset_equal_size_values(
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST:%.*]], i8 0, i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len, i1 false)
ret void
}
define void @memmove_and_memset_different_size_values_1(i8* noalias %src, i8* noalias %dst, i64 %len.1, i64 %len.2) {
; CHECK-LABEL: @memmove_and_memset_different_size_values_1(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST]], i8 0, i64 [[LEN_2:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.1, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.2, i1 false)
ret void
}
define void @memmove_and_memset_different_size_values_2(i8* noalias %src, i8* noalias %dst, i64 %len.1) {
; CHECK-LABEL: @memmove_and_memset_different_size_values_2(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST]], i8 0, i64 100, i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len.1, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 100, i1 false)
ret void
}
define void @memmove_and_memset_different_size_values_3(i8* noalias %src, i8* noalias %dst, i64 %len.1) {
; CHECK-LABEL: @memmove_and_memset_different_size_values_3(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 100, i1 false)
; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 [[DST]], i8 0, i64 [[LEN_1:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 100, i1 false)
call void @llvm.memset.p0i8.i64(i8* align 1 %dst, i8 0, i64 %len.1, i1 false)
ret void
}
define void @memmove_and_memcpy_equal_size_values(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memmove_and_memcpy_equal_size_values(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
ret void
}
define void @memcpy_and_memmove_equal_size_values(i8* noalias %src, i8* noalias %dst, i64 %len) {
; CHECK-LABEL: @memcpy_and_memmove_equal_size_values(
; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i64(i8* [[DST:%.*]], i8* [[SRC:%.*]], i64 [[LEN:%.*]], i1 false)
; CHECK-NEXT: ret void
;
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 %len, i1 false)
ret void
}
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)
declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)