This is an archive of the discontinued LLVM Phabricator instance.

Differential D152277

[MemCpyOpt] precommit tests to add single-BB stack-move optimization (NFC)
ClosedPublic

Authored by khei4 on Jun 6 2023, 8:13 AM.

Details

Reviewers
nikic
pcwalton
Commits
rG393215649bda: [MemCpyOpt] precommit test to add single BB stack-move optimization (NFC)
Summary

migration from @pcwalton 's stack-move optimization only focused on single BB cases.
original patch: https://reviews.llvm.org/D140089
functional patch: https://reviews.llvm.org/D153453

Diff Detail

Unit TestsFailed

TimeTest
0 msx64 debian > LLVM.Transforms/MemCpyOpt::stack-move.ll

Event Timeline

khei4 created this revision.Jun 6 2023, 8:13 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 6 2023, 8:13 AM
khei4 requested review of this revision.Jun 6 2023, 8:13 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 6 2023, 8:13 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
khei4 edited the summary of this revision. (Show Details)Jun 6 2023, 8:15 AM
khei4 retitled this revision from (WIP) [MemCpyOpt] precommit tes t to add inter-BB stack-move optimization to (WIP) [MemCpyOpt] precommit tests to add inter-BB stack-move optimization.Jun 6 2023, 8:23 AM
khei4 edited the summary of this revision. (Show Details)
Harbormaster completed remote builds in B236956: Diff 528872.Jun 6 2023, 8:56 AM
khei4 added a child revision: D150943: [SimplifyCFG] add nsw on BuildLookuptable LinearMap calculation.Jun 19 2023, 12:10 AM
khei4 removed a child revision: D150943: [SimplifyCFG] add nsw on BuildLookuptable LinearMap calculation.
khei4 added a child revision: D153453: [MemCpyOpt] implement single BB stack-move optimization which unify the static unescaped allocas .Jun 21 2023, 11:50 AM
khei4 updated this revision to Diff 534612.Jun 26 2023, 9:42 AM

add the case to write on dest before memcpy.
need to specify the expected transformation in liveness property.

khei4 updated this revision to Diff 538354.Jul 8 2023, 4:42 AM

add

  • mod on alias( TODO: but need to be changed to on src ptr)
  • inalloca

TODO: exhaustive mod/ref after copy

Harbormaster completed remote builds in B243924: Diff 538354.Jul 8 2023, 5:20 AM
khei4 retitled this revision from (WIP) [MemCpyOpt] precommit tests to add inter-BB stack-move optimization to (WIP) [MemCpyOpt] precommit tests to add single-BB stack-move optimization.Jul 8 2023, 10:20 PM
khei4 edited the summary of this revision. (Show Details)
khei4 added reviewers: nikic, pcwalton.
khei4 added a subscriber: pcwalton.
Herald added a subscriber: StephenFan. · View Herald TranscriptJul 8 2023, 10:20 PM
khei4 mentioned this in D153453: [MemCpyOpt] implement single BB stack-move optimization which unify the static unescaped allocas .Jul 8 2023, 10:20 PM
khei4 updated this revision to Diff 538402.Jul 8 2023, 10:23 PM
khei4 retitled this revision from (WIP) [MemCpyOpt] precommit tests to add single-BB stack-move optimization to [MemCpyOpt] precommit tests to add single-BB stack-move optimization (NFC).

I think it's now worth to be review :)

  • add partial lifetime test
  • mod/ref exhaustive tests before/after copy
  • insert newlines
Harbormaster completed remote builds in B243963: Diff 538402.Jul 9 2023, 12:20 AM
khei4 updated this revision to Diff 538915.Jul 10 2023, 10:15 PM
  • add tests
    • dest ref before copy
    • no lifetime stack move
  • rebase
Harbormaster completed remote builds in B244343: Diff 538915.Jul 10 2023, 11:20 PM
khei4 updated this revision to Diff 539032.Jul 11 2023, 5:18 AM
  • drop all noundef attributes
  • fix the alignments
  • fix typo, missing tail
nikic added a comment.Jul 11 2023, 7:45 AM

We should have a test where the uses are not in the entry block (won't fold right now, but just to check it doesn't crash...)

Harbormaster completed remote builds in B244428: Diff 539032.Jul 11 2023, 7:57 AM
khei4 updated this revision to Diff 539831.Jul 12 2023, 7:54 PM
  • add
    • branched case
    • loop case

to see multi-bb behavior

This revision was not accepted when it landed; it landed in state Needs Review.Jul 12 2023, 10:58 PM
This revision was landed with ongoing or failed builds.
Closed by commit rG393215649bda: [MemCpyOpt] precommit test to add single BB stack-move optimization (NFC) (authored by khei4). · Explain Why
This revision was automatically updated to reflect the committed changes.
khei4 added a commit: rG393215649bda: [MemCpyOpt] precommit test to add single BB stack-move optimization (NFC).
Harbormaster completed remote builds in B244978: Diff 539831.Jul 12 2023, 11:57 PM

Revision Contents

PathSize
llvm/
test/
Transforms/
MemCpyOpt/
399 lines

Diff 528872

llvm/test/Transforms/MemCpyOpt/stack-move.ll

  • This file was added.
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
%struct.Foo = type { i32, i32, i32 }
@constant = private unnamed_addr constant %struct.Foo { i32 1, i32 2, i32 3 }, align 4
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
declare void @llvm.memmove.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg)
declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
declare i32 @use_nocapture(ptr noundef nocapture)
define void @basic_memcpy() {
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
define void @basic_memmove() {
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memmove.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memmove.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that the optimization succeeds with a load/store pair.
define void @load_store() {
; CHECK-LABEL: @load_store(
; CHECK-NEXT: [[SRC:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca i32, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 4, ptr [[SRC]])
; CHECK-NEXT: store i32 42, ptr [[SRC]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 4, ptr [[SRC]])
; CHECK-NEXT: ret void
;
%src = alloca i32, align 4
%dest = alloca i32, align 4
call void @llvm.lifetime.start.p0(i64 4, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 4, ptr nocapture %dest)
store i32 42, ptr %src
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
%2 = load i32, ptr %src
store i32 %2, ptr %dest
call void @llvm.lifetime.end.p0(i64 4, ptr nocapture %src)
%3 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 4, ptr nocapture %dest)
ret void
}
; Tests that merging two allocas with different alignments results in an
; alloca with the broader alignment.
define void @align_up() {
; CHECK-LABEL: @align_up(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 8
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 8
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that we correctly remove extra lifetime intrinsics when performing the
; optimization.
define void @remove_extra_lifetime_intrinsics() {
; CHECK-LABEL: @remove_extra_lifetime_intrinsics(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: [[TMP3:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
%3 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that we remove scoped noalias metadata from a call.
define void @remove_scoped_noalias() {
; CHECK-LABEL: @remove_scoped_noalias(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]]), !alias.scope !0
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src), !alias.scope !2
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest), !noalias !2
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that we remove metadata on the merged alloca.
define void @remove_alloca_metadata() {
; CHECK-LABEL: @remove_alloca_metadata(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]]), !alias.scope !0
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr [[SRC]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4, !annotation !3
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src), !alias.scope !2
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest), !noalias !2
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that dynamically-sized allocas are never merged.
define void @dynamically_sized_alloca(i64 %i) {
; CHECK-LABEL: @dynamically_sized_alloca(
; CHECK-NEXT: [[SRC:%.*]] = alloca i8, i64 [[I:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca i8, i64 [[I]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 -1, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 12, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 -1, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca i8, i64 %i, align 4
%dest = alloca i8, i64 %i, align 4
call void @llvm.lifetime.start.p0(i64 -1, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 -1, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 -1, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 -1, ptr nocapture %dest)
ret void
}
; Tests that a memcpy with a dynamic size is never optimized.
define void @dynamically_sized_memcpy(i64 %size) {
; CHECK-LABEL: @dynamically_sized_memcpy(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 %size, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that allocas with different sizes aren't merged together.
define void @mismatched_alloca_size() {
; CHECK-LABEL: @mismatched_alloca_size(
; CHECK-NEXT: [[SRC:%.*]] = alloca i8, i64 24, align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca i8, i64 12, align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 12, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 24, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca i8, i64 24, align 4
%dest = alloca i8, i64 12, align 4
call void @llvm.lifetime.start.p0(i64 24, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 24, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that allocas with mismatched address spaces aren't combined.
define void @mismatched_alloca_addrspace() {
; CHECK-LABEL: @mismatched_alloca_addrspace(
; CHECK-NEXT: [[SRC:%.*]] = alloca i8, i64 24, align 4, addrspace(1)
; CHECK-NEXT: [[DEST:%.*]] = alloca i8, i64 12, align 4, addrspace(2)
; CHECK-NEXT: call void @llvm.lifetime.start.p1(i64 24, ptr addrspace(1) nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p2(i64 12, ptr addrspace(2) nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p1.p0.i64(ptr addrspace(1) align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr addrspace(1) nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p2.p1.i64(ptr addrspace(2) align 4 [[DEST]], ptr addrspace(1) align 4 [[SRC]], i64 12, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p1(i64 24, ptr addrspace(1) nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr addrspace(2) nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p2(i64 12, ptr addrspace(2) nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca i8, i64 24, align 4, addrspace(1)
%dest = alloca i8, i64 12, align 4, addrspace(2)
call void @llvm.lifetime.start.p1(i64 24, ptr addrspace(1) nocapture %src)
call void @llvm.lifetime.start.p2(i64 12, ptr addrspace(2) nocapture %dest)
call void @llvm.memcpy.p1.p0.i64(ptr addrspace(1) align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr addrspace(1) noundef nocapture %src)
call void @llvm.memcpy.p2.p1.i64(ptr addrspace(2) align 4 %dest, ptr addrspace(1) align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p1(i64 24, ptr addrspace(1) nocapture %src)
%2 = call i32 @use_nocapture(ptr addrspace(2) noundef nocapture %dest)
call void @llvm.lifetime.end.p2(i64 12, ptr addrspace(2) nocapture %dest)
ret void
}
; Tests that volatile memcpys aren't removed.
define void @volatile_memcpy() {
; CHECK-LABEL: @volatile_memcpy(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 true)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 12, i1 true)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 true)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 true)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that the optimization isn't performed when the destination is captured.
define void @dest_captured() {
; CHECK-LABEL: @dest_captured(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 12, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_capture(ptr noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_capture(ptr noundef %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that the optimization isn't performed when the source is captured.
define void @src_captured() {
; CHECK-LABEL: @src_captured(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_capture(ptr noundef [[SRC]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 [[SRC]], i64 12, i1 false)
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
%1 = call i32 @use_capture(ptr noundef %src)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}
; Tests that the optimization isn't performed when the source and destination
; are simultaneously live within the basic block.
define void @local_liveness_conflict() {
; CHECK-LABEL: @local_liveness_conflict(
; CHECK-NEXT: [[SRC:%.*]] = alloca [[STRUCT_FOO:%.*]], align 4
; CHECK-NEXT: [[DEST:%.*]] = alloca [[STRUCT_FOO]], align 4
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[SRC]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: call void @llvm.memcpy.p0.p0.i64(ptr align 4 [[DEST]], ptr align 4 @constant, i64 12, i1 false)
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[SRC]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[SRC]])
; CHECK-NEXT: [[TMP2:%.*]] = call i32 @use_nocapture(ptr nocapture noundef [[DEST]])
; CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 12, ptr nocapture [[DEST]])
; CHECK-NEXT: ret void
;
%src = alloca %struct.Foo, align 4
%dest = alloca %struct.Foo, align 4
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %src)
call void @llvm.lifetime.start.p0(i64 12, ptr nocapture %dest)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %src, ptr align 4 @constant, i64 12, i1 false)
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %dest, ptr align 4 %src, i64 12, i1 false)
%1 = call i32 @use_nocapture(ptr noundef nocapture %src)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %src)
%2 = call i32 @use_nocapture(ptr noundef nocapture %dest)
call void @llvm.lifetime.end.p0(i64 12, ptr nocapture %dest)
ret void
}