forked from OSchip/llvm-project
335 lines
12 KiB
LLVM
335 lines
12 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
|
; RUN: opt -dse -S < %s | FileCheck %s
|
|
|
|
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
|
|
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
|
|
|
|
declare void @unknown()
|
|
declare void @f(i8*)
|
|
declare void @f2(i8*, i8*)
|
|
declare i8* @f3(i8*, i8*)
|
|
|
|
; Basic case for DSEing a trivially dead writing call
|
|
define void @test_dead() {
|
|
; CHECK-LABEL: @test_dead(
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
; Add in canonical lifetime intrinsics
|
|
define void @test_lifetime() {
|
|
; CHECK-LABEL: @test_lifetime(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* [[BITCAST]])
|
|
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* [[BITCAST]])
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast)
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast)
|
|
ret void
|
|
}
|
|
|
|
; Add some unknown calls just to point out that this is use based, not
|
|
; instruction order sensitive
|
|
define void @test_lifetime2() {
|
|
; CHECK-LABEL: @test_lifetime2(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* [[BITCAST]])
|
|
; CHECK-NEXT: call void @unknown()
|
|
; CHECK-NEXT: call void @unknown()
|
|
; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* [[BITCAST]])
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast)
|
|
call void @unknown()
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
call void @unknown()
|
|
call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast)
|
|
ret void
|
|
}
|
|
|
|
; As long as the result is unused, we can even remove reads of the alloca
|
|
; itself since the write will be dropped.
|
|
define void @test_dead_readwrite() {
|
|
; CHECK-LABEL: @test_dead_readwrite(
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* nocapture %bitcast) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
define i32 @test_neg_read_after() {
|
|
; CHECK-LABEL: @test_neg_read_after(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR1:[0-9]+]]
|
|
; CHECK-NEXT: [[RES:%.*]] = load i32, i32* [[A]], align 4
|
|
; CHECK-NEXT: ret i32 [[RES]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
%res = load i32, i32* %a
|
|
ret i32 %res
|
|
}
|
|
|
|
|
|
define void @test_neg_infinite_loop() {
|
|
; CHECK-LABEL: @test_neg_infinite_loop(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR2:[0-9]+]]
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind
|
|
ret void
|
|
}
|
|
|
|
define void @test_neg_throw() {
|
|
; CHECK-LABEL: @test_neg_throw(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR3:[0-9]+]]
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly willreturn
|
|
ret void
|
|
}
|
|
|
|
define void @test_neg_extra_write() {
|
|
; CHECK-LABEL: @test_neg_extra_write(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR4:[0-9]+]]
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
; In this case, we can't remove a1 because we need to preserve the write to
|
|
; a2, and if we leave the call around, we need memory to pass to the first arg.
|
|
define void @test_neg_unmodeled_write() {
|
|
; CHECK-LABEL: @test_neg_unmodeled_write(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[A2:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: [[BITCAST2:%.*]] = bitcast i32* [[A2]] to i8*
|
|
; CHECK-NEXT: call void @f2(i8* nocapture writeonly [[BITCAST]], i8* [[BITCAST2]]) #[[ATTR1]]
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i32* %a2 to i8*
|
|
call void @f2(i8* nocapture writeonly %bitcast, i8* %bitcast2) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
define i32 @test_neg_captured_by_call() {
|
|
; CHECK-LABEL: @test_neg_captured_by_call(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[A2:%.*]] = alloca i8*, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: [[BITCAST2:%.*]] = bitcast i8** [[A2]] to i8*
|
|
; CHECK-NEXT: call void @f2(i8* writeonly [[BITCAST]], i8* [[BITCAST2]]) #[[ATTR1]]
|
|
; CHECK-NEXT: [[A_COPY_CAST:%.*]] = load i8*, i8** [[A2]], align 8
|
|
; CHECK-NEXT: [[A_COPY:%.*]] = bitcast i8* [[A_COPY_CAST]] to i32*
|
|
; CHECK-NEXT: [[RES:%.*]] = load i32, i32* [[A_COPY]], align 4
|
|
; CHECK-NEXT: ret i32 [[RES]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i8*, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i8** %a2 to i8*
|
|
call void @f2(i8* writeonly %bitcast, i8* %bitcast2) argmemonly nounwind willreturn
|
|
%a_copy_cast = load i8*, i8** %a2
|
|
%a_copy = bitcast i8* %a_copy_cast to i32*
|
|
%res = load i32, i32* %a_copy
|
|
ret i32 %res
|
|
}
|
|
|
|
define i32 @test_neg_captured_before() {
|
|
; CHECK-LABEL: @test_neg_captured_before(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[A2:%.*]] = alloca i8*, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: [[BITCAST2:%.*]] = bitcast i8** [[A2]] to i8*
|
|
; CHECK-NEXT: store i8* [[BITCAST]], i8** [[A2]], align 8
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR1]]
|
|
; CHECK-NEXT: [[A_COPY_CAST:%.*]] = load i8*, i8** [[A2]], align 8
|
|
; CHECK-NEXT: [[A_COPY:%.*]] = bitcast i8* [[A_COPY_CAST]] to i32*
|
|
; CHECK-NEXT: [[RES:%.*]] = load i32, i32* [[A_COPY]], align 4
|
|
; CHECK-NEXT: ret i32 [[RES]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i8*, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i8** %a2 to i8*
|
|
store i8* %bitcast, i8** %a2
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
%a_copy_cast = load i8*, i8** %a2
|
|
%a_copy = bitcast i8* %a_copy_cast to i32*
|
|
%res = load i32, i32* %a_copy
|
|
ret i32 %res
|
|
}
|
|
|
|
; Callee might be dead, but op bundle has unknown semantics and thus isn't.
|
|
define void @test_new_op_bundle() {
|
|
; CHECK-LABEL: @test_new_op_bundle(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR1]] [ "unknown"(i8* [[BITCAST]]) ]
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn ["unknown" (i8* %bitcast)]
|
|
ret void
|
|
}
|
|
|
|
; Show that reading from unrelated memory is okay
|
|
define void @test_unreleated_read() {
|
|
; CHECK-LABEL: @test_unreleated_read(
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i32* %a2 to i8*
|
|
call void @f2(i8* nocapture writeonly %bitcast, i8* nocapture readonly %bitcast2) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
; Removing a capture is also okay. The capture can only be in the return value
|
|
; (which is unused) or written into the dead out parameter.
|
|
define void @test_unrelated_capture() {
|
|
; CHECK-LABEL: @test_unrelated_capture(
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i32* %a2 to i8*
|
|
call i8* @f3(i8* nocapture writeonly %bitcast, i8* readonly %bitcast2) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
; Cannot remove call, as %bitcast2 is captured via the return value.
|
|
define i8 @test_neg_unrelated_capture_used_via_return() {
|
|
; CHECK-LABEL: @test_neg_unrelated_capture_used_via_return(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[A2:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: [[BITCAST2:%.*]] = bitcast i32* [[A2]] to i8*
|
|
; CHECK-NEXT: [[CAPTURE:%.*]] = call i8* @f3(i8* nocapture writeonly [[BITCAST]], i8* readonly [[BITCAST2]]) #[[ATTR1]]
|
|
; CHECK-NEXT: [[V:%.*]] = load i8, i8* [[CAPTURE]], align 1
|
|
; CHECK-NEXT: ret i8 [[V]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%a2 = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
%bitcast2 = bitcast i32* %a2 to i8*
|
|
%capture = call i8* @f3(i8* nocapture writeonly %bitcast, i8* readonly %bitcast2) argmemonly nounwind willreturn
|
|
%v = load i8, i8* %capture
|
|
ret i8 %v
|
|
}
|
|
|
|
; As long as the result is unused, we can even remove reads of the alloca
|
|
; itself since the write will be dropped.
|
|
define void @test_self_read() {
|
|
; CHECK-LABEL: @test_self_read(
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f2(i8* nocapture writeonly %bitcast, i8* nocapture readonly %bitcast) argmemonly nounwind willreturn
|
|
ret void
|
|
}
|
|
|
|
; We can remove the call because while we don't know the size of the write done
|
|
; by the call, we do know the following store writes to the entire contents of
|
|
; the alloca.
|
|
define i32 @test_dse_overwrite() {
|
|
; CHECK-LABEL: @test_dse_overwrite(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: store i32 0, i32* [[A]], align 4
|
|
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[A]], align 4
|
|
; CHECK-NEXT: ret i32 [[V]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
store i32 0, i32* %a
|
|
%v = load i32, i32* %a
|
|
ret i32 %v
|
|
}
|
|
|
|
; Negative case where we can read part of the value written by @f.
|
|
define i32 @test_neg_dse_partial_overwrite() {
|
|
; CHECK-LABEL: @test_neg_dse_partial_overwrite(
|
|
; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR1]]
|
|
; CHECK-NEXT: store i8 0, i8* [[BITCAST]], align 1
|
|
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[A]], align 4
|
|
; CHECK-NEXT: ret i32 [[V]]
|
|
;
|
|
%a = alloca i32, align 4
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
store i8 0, i8* %bitcast
|
|
%v = load i32, i32* %a
|
|
ret i32 %v
|
|
}
|
|
|
|
; Negative case where we don't know the size of a, and thus can't use the
|
|
; full overwrite reasoning
|
|
define i32 @test_neg_dse_unsized(i32* %a) {
|
|
; CHECK-LABEL: @test_neg_dse_unsized(
|
|
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[A:%.*]] to i8*
|
|
; CHECK-NEXT: call void @f(i8* nocapture writeonly [[BITCAST]]) #[[ATTR1]]
|
|
; CHECK-NEXT: store i32 0, i32* [[A]], align 4
|
|
; CHECK-NEXT: [[V:%.*]] = load i32, i32* [[A]], align 4
|
|
; CHECK-NEXT: ret i32 [[V]]
|
|
;
|
|
%bitcast = bitcast i32* %a to i8*
|
|
call void @f(i8* writeonly nocapture %bitcast) argmemonly nounwind willreturn
|
|
store i32 0, i32* %a
|
|
%v = load i32, i32* %a
|
|
ret i32 %v
|
|
}
|
|
|
|
@G = global i8 0
|
|
|
|
; Same as test_dse_overwrite, but with a non-alloca object.
|
|
define void @test_dse_non_alloca() {
|
|
; CHECK-LABEL: @test_dse_non_alloca(
|
|
; CHECK-NEXT: store i8 0, i8* @G, align 1
|
|
; CHECK-NEXT: ret void
|
|
;
|
|
call void @f(i8* writeonly nocapture @G) argmemonly nounwind willreturn
|
|
store i8 0, i8* @G
|
|
ret void
|
|
}
|
|
|