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
388

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
388

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/
1 line
test/
Transforms/
DeadStoreElimination/
130 lines

Diff 329645

llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp

Show First 20 Lines • Show All 373 Lines • ▼ Show 20 Lines 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 * { auto GetSizeFromInstr = [](const Instruction *I) -> Value * {
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) { if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
default: default:
return nullptr; return nullptr;
case Intrinsic::memcpy: case Intrinsic::memcpy:
case Intrinsic::memmove:
case Intrinsic::memset: case Intrinsic::memset:
return II->getArgOperand(2); return II->getArgOperand(2);
} }
} }
return nullptr; return nullptr;
}; };
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!
Value *LaterV = GetSizeFromInstr(LaterI); Value *LaterV = GetSizeFromInstr(LaterI);
Value *EarlierV = GetSizeFromInstr(EarlierI); Value *EarlierV = GetSizeFromInstr(EarlierI);
if (LaterV && LaterV == EarlierV && AA.isMustAlias(Earlier, Later)) 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);
▲ Show 20 Lines • Show All 1,704 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
}
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)