mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 03:02:36 +01:00
4055195f29
explicitly emitting retainRV or claimRV calls in the IR This reapplies ed4718eccb12bd42214ca4fb17d196d49561c0c7, which was reverted because it was causing a miscompile. The bug that was causing the miscompile has been fixed in 75805dce5ff874676f3559c069fcd6737838f5c0. Original commit message: Background: This fixes a longstanding problem where llvm breaks ARC's autorelease optimization (see the link below) by separating calls from the marker instructions or retainRV/claimRV calls. The backend changes are in https://reviews.llvm.org/D92569. https://clang.llvm.org/docs/AutomaticReferenceCounting.html#arc-runtime-objc-autoreleasereturnvalue What this patch does to fix the problem: - The front-end adds operand bundle "clang.arc.attachedcall" to calls, which indicates the call is implicitly followed by a marker instruction and an implicit retainRV/claimRV call that consumes the call result. In addition, it emits a call to @llvm.objc.clang.arc.noop.use, which consumes the call result, to prevent the middle-end passes from changing the return type of the called function. This is currently done only when the target is arm64 and the optimization level is higher than -O0. - ARC optimizer temporarily emits retainRV/claimRV calls after the calls with the operand bundle in the IR and removes the inserted calls after processing the function. - ARC contract pass emits retainRV/claimRV calls after the call with the operand bundle. It doesn't remove the operand bundle on the call since the backend needs it to emit the marker instruction. The retainRV and claimRV calls are emitted late in the pipeline to prevent optimization passes from transforming the IR in a way that makes it harder for the ARC middle-end passes to figure out the def-use relationship between the call and the retainRV/claimRV calls (which is the cause of PR31925). - The function inliner removes an autoreleaseRV call in the callee if nothing in the callee prevents it from being paired up with the retainRV/claimRV call in the caller. It then inserts a release call if claimRV is attached to the call since autoreleaseRV+claimRV is equivalent to a release. If it cannot find an autoreleaseRV call, it tries to transfer the operand bundle to a function call in the callee. This is important since the ARC optimizer can remove the autoreleaseRV returning the callee result, which makes it impossible to pair it up with the retainRV/claimRV call in the caller. If that fails, it simply emits a retain call in the IR if retainRV is attached to the call and does nothing if claimRV is attached to it. - SCCP refrains from replacing the return value of a call with a constant value if the call has the operand bundle. This ensures the call always has at least one user (the call to @llvm.objc.clang.arc.noop.use). - This patch also fixes a bug in replaceUsesOfNonProtoConstant where multiple operand bundles of the same kind were being added to a call. Future work: - Use the operand bundle on x86-64. - Fix the auto upgrader to convert call+retainRV/claimRV pairs into calls with the operand bundles. rdar://71443534 Differential Revision: https://reviews.llvm.org/D92808
176 lines
5.1 KiB
LLVM
176 lines
5.1 KiB
LLVM
; RUN: opt < %s -inline -S | FileCheck %s
|
|
|
|
@g0 = global i8* null, align 8
|
|
declare i8* @foo0()
|
|
|
|
define i8* @callee0_autoreleaseRV() {
|
|
%call = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
%1 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
|
|
ret i8* %call
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test0_autoreleaseRV(
|
|
; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
|
|
define void @test0_autoreleaseRV() {
|
|
%call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test0_claimRV_autoreleaseRV(
|
|
; CHECK: %[[CALL:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
; CHECK: call void @llvm.objc.release(i8* %[[CALL]])
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test0_claimRV_autoreleaseRV() {
|
|
%call = call i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test1_autoreleaseRV(
|
|
; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
|
|
define void @test1_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
|
|
entry:
|
|
%call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
|
|
to label %invoke.cont unwind label %lpad
|
|
|
|
invoke.cont:
|
|
ret void
|
|
|
|
lpad:
|
|
%0 = landingpad { i8*, i32 }
|
|
cleanup
|
|
resume { i8*, i32 } undef
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test1_claimRV_autoreleaseRV(
|
|
; CHECK: %[[INVOKE:.*]] = invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
; CHECK: call void @llvm.objc.release(i8* %[[INVOKE]])
|
|
; CHECK-NEXT: br
|
|
|
|
define void @test1_claimRV_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
|
|
entry:
|
|
%call = invoke i8* @callee0_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
|
|
to label %invoke.cont unwind label %lpad
|
|
|
|
invoke.cont:
|
|
ret void
|
|
|
|
lpad:
|
|
%0 = landingpad { i8*, i32 }
|
|
cleanup
|
|
resume { i8*, i32 } undef
|
|
}
|
|
|
|
define i8* @callee1_no_autoreleaseRV() {
|
|
%call = call i8* @foo0()
|
|
ret i8* %call
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test2_no_autoreleaseRV(
|
|
; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test2_no_autoreleaseRV() {
|
|
%call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test2_claimRV_no_autoreleaseRV(
|
|
; CHECK: call i8* @foo0() [ "clang.arc.attachedcall"(i64 1) ]
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test2_claimRV_no_autoreleaseRV() {
|
|
%call = call i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 1) ]
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test3_no_autoreleaseRV(
|
|
; CHECK: invoke i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
|
|
define void @test3_no_autoreleaseRV() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
|
|
entry:
|
|
%call = invoke i8* @callee1_no_autoreleaseRV() [ "clang.arc.attachedcall"(i64 0) ]
|
|
to label %invoke.cont unwind label %lpad
|
|
|
|
invoke.cont:
|
|
ret void
|
|
|
|
lpad:
|
|
%0 = landingpad { i8*, i32 }
|
|
cleanup
|
|
resume { i8*, i32 } undef
|
|
}
|
|
|
|
define i8* @callee2_nocall() {
|
|
%1 = load i8*, i8** @g0, align 8
|
|
ret i8* %1
|
|
}
|
|
|
|
; Check that a call to @llvm.objc.retain is inserted if there is no matching
|
|
; autoreleaseRV call or a call.
|
|
|
|
; CHECK-LABEL: define void @test4_nocall(
|
|
; CHECK: %[[V0:.*]] = load i8*, i8** @g0,
|
|
; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %[[V0]])
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test4_nocall() {
|
|
%call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test4_claimRV_nocall(
|
|
; CHECK: %[[V0:.*]] = load i8*, i8** @g0,
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test4_claimRV_nocall() {
|
|
%call = call i8* @callee2_nocall() [ "clang.arc.attachedcall"(i64 1) ]
|
|
ret void
|
|
}
|
|
|
|
; Check that a call to @llvm.objc.retain is inserted if call to @foo already has
|
|
; the attribute. I'm not sure this will happen in practice.
|
|
|
|
define i8* @callee3_marker() {
|
|
%1 = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret i8* %1
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test5(
|
|
; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %[[V0]])
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test5() {
|
|
%call = call i8* @callee3_marker() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret void
|
|
}
|
|
|
|
; Don't pair up an autoreleaseRV in the callee and an retainRV in the caller
|
|
; if there is an instruction between the ret instruction and the call to
|
|
; autoreleaseRV that isn't a cast instruction.
|
|
|
|
define i8* @callee0_autoreleaseRV2() {
|
|
%call = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
%1 = tail call i8* @llvm.objc.autoreleaseReturnValue(i8* %call)
|
|
store i8* null, i8** @g0
|
|
ret i8* %call
|
|
}
|
|
|
|
; CHECK-LABEL: define void @test6(
|
|
; CHECK: %[[V0:.*]] = call i8* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
|
|
; CHECK: call i8* @llvm.objc.autoreleaseReturnValue(i8* %[[V0]])
|
|
; CHECK: store i8* null, i8** @g0, align 8
|
|
; CHECK: call i8* @llvm.objc.retain(i8* %[[V0]])
|
|
; CHECK-NEXT: ret void
|
|
|
|
define void @test6() {
|
|
%call = call i8* @callee0_autoreleaseRV2() [ "clang.arc.attachedcall"(i64 0) ]
|
|
ret void
|
|
}
|
|
|
|
declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
|
|
declare i32 @__gxx_personality_v0(...)
|