mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 19:12:56 +02: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
706 lines
23 KiB
C++
706 lines
23 KiB
C++
//===- ARCInstKind.cpp - ObjC ARC Optimization ----------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This file defines several utility functions used by various ARC
|
|
/// optimizations which are IMHO too big to be in a header file.
|
|
///
|
|
/// WARNING: This file knows about certain library functions. It recognizes them
|
|
/// by name, and hardwires knowledge of their semantics.
|
|
///
|
|
/// WARNING: This file knows about how certain Objective-C library functions are
|
|
/// used. Naive LLVM IR transformations which would otherwise be
|
|
/// behavior-preserving may break these assumptions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/ObjCARCInstKind.h"
|
|
#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
|
|
#include "llvm/IR/Intrinsics.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::objcarc;
|
|
|
|
raw_ostream &llvm::objcarc::operator<<(raw_ostream &OS,
|
|
const ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
return OS << "ARCInstKind::Retain";
|
|
case ARCInstKind::RetainRV:
|
|
return OS << "ARCInstKind::RetainRV";
|
|
case ARCInstKind::ClaimRV:
|
|
return OS << "ARCInstKind::ClaimRV";
|
|
case ARCInstKind::RetainBlock:
|
|
return OS << "ARCInstKind::RetainBlock";
|
|
case ARCInstKind::Release:
|
|
return OS << "ARCInstKind::Release";
|
|
case ARCInstKind::Autorelease:
|
|
return OS << "ARCInstKind::Autorelease";
|
|
case ARCInstKind::AutoreleaseRV:
|
|
return OS << "ARCInstKind::AutoreleaseRV";
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
return OS << "ARCInstKind::AutoreleasepoolPush";
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
return OS << "ARCInstKind::AutoreleasepoolPop";
|
|
case ARCInstKind::NoopCast:
|
|
return OS << "ARCInstKind::NoopCast";
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
return OS << "ARCInstKind::FusedRetainAutorelease";
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
return OS << "ARCInstKind::FusedRetainAutoreleaseRV";
|
|
case ARCInstKind::LoadWeakRetained:
|
|
return OS << "ARCInstKind::LoadWeakRetained";
|
|
case ARCInstKind::StoreWeak:
|
|
return OS << "ARCInstKind::StoreWeak";
|
|
case ARCInstKind::InitWeak:
|
|
return OS << "ARCInstKind::InitWeak";
|
|
case ARCInstKind::LoadWeak:
|
|
return OS << "ARCInstKind::LoadWeak";
|
|
case ARCInstKind::MoveWeak:
|
|
return OS << "ARCInstKind::MoveWeak";
|
|
case ARCInstKind::CopyWeak:
|
|
return OS << "ARCInstKind::CopyWeak";
|
|
case ARCInstKind::DestroyWeak:
|
|
return OS << "ARCInstKind::DestroyWeak";
|
|
case ARCInstKind::StoreStrong:
|
|
return OS << "ARCInstKind::StoreStrong";
|
|
case ARCInstKind::CallOrUser:
|
|
return OS << "ARCInstKind::CallOrUser";
|
|
case ARCInstKind::Call:
|
|
return OS << "ARCInstKind::Call";
|
|
case ARCInstKind::User:
|
|
return OS << "ARCInstKind::User";
|
|
case ARCInstKind::IntrinsicUser:
|
|
return OS << "ARCInstKind::IntrinsicUser";
|
|
case ARCInstKind::None:
|
|
return OS << "ARCInstKind::None";
|
|
}
|
|
llvm_unreachable("Unknown instruction class!");
|
|
}
|
|
|
|
ARCInstKind llvm::objcarc::GetFunctionClass(const Function *F) {
|
|
|
|
Intrinsic::ID ID = F->getIntrinsicID();
|
|
switch (ID) {
|
|
default:
|
|
return ARCInstKind::CallOrUser;
|
|
case Intrinsic::objc_autorelease:
|
|
return ARCInstKind::Autorelease;
|
|
case Intrinsic::objc_autoreleasePoolPop:
|
|
return ARCInstKind::AutoreleasepoolPop;
|
|
case Intrinsic::objc_autoreleasePoolPush:
|
|
return ARCInstKind::AutoreleasepoolPush;
|
|
case Intrinsic::objc_autoreleaseReturnValue:
|
|
return ARCInstKind::AutoreleaseRV;
|
|
case Intrinsic::objc_copyWeak:
|
|
return ARCInstKind::CopyWeak;
|
|
case Intrinsic::objc_destroyWeak:
|
|
return ARCInstKind::DestroyWeak;
|
|
case Intrinsic::objc_initWeak:
|
|
return ARCInstKind::InitWeak;
|
|
case Intrinsic::objc_loadWeak:
|
|
return ARCInstKind::LoadWeak;
|
|
case Intrinsic::objc_loadWeakRetained:
|
|
return ARCInstKind::LoadWeakRetained;
|
|
case Intrinsic::objc_moveWeak:
|
|
return ARCInstKind::MoveWeak;
|
|
case Intrinsic::objc_release:
|
|
return ARCInstKind::Release;
|
|
case Intrinsic::objc_retain:
|
|
return ARCInstKind::Retain;
|
|
case Intrinsic::objc_retainAutorelease:
|
|
return ARCInstKind::FusedRetainAutorelease;
|
|
case Intrinsic::objc_retainAutoreleaseReturnValue:
|
|
return ARCInstKind::FusedRetainAutoreleaseRV;
|
|
case Intrinsic::objc_retainAutoreleasedReturnValue:
|
|
return ARCInstKind::RetainRV;
|
|
case Intrinsic::objc_retainBlock:
|
|
return ARCInstKind::RetainBlock;
|
|
case Intrinsic::objc_storeStrong:
|
|
return ARCInstKind::StoreStrong;
|
|
case Intrinsic::objc_storeWeak:
|
|
return ARCInstKind::StoreWeak;
|
|
case Intrinsic::objc_clang_arc_use:
|
|
return ARCInstKind::IntrinsicUser;
|
|
case Intrinsic::objc_unsafeClaimAutoreleasedReturnValue:
|
|
return ARCInstKind::ClaimRV;
|
|
case Intrinsic::objc_retainedObject:
|
|
return ARCInstKind::NoopCast;
|
|
case Intrinsic::objc_unretainedObject:
|
|
return ARCInstKind::NoopCast;
|
|
case Intrinsic::objc_unretainedPointer:
|
|
return ARCInstKind::NoopCast;
|
|
case Intrinsic::objc_retain_autorelease:
|
|
return ARCInstKind::FusedRetainAutorelease;
|
|
case Intrinsic::objc_sync_enter:
|
|
return ARCInstKind::User;
|
|
case Intrinsic::objc_sync_exit:
|
|
return ARCInstKind::User;
|
|
case Intrinsic::objc_clang_arc_noop_use:
|
|
case Intrinsic::objc_arc_annotation_topdown_bbstart:
|
|
case Intrinsic::objc_arc_annotation_topdown_bbend:
|
|
case Intrinsic::objc_arc_annotation_bottomup_bbstart:
|
|
case Intrinsic::objc_arc_annotation_bottomup_bbend:
|
|
// Ignore annotation calls. This is important to stop the
|
|
// optimizer from treating annotations as uses which would
|
|
// make the state of the pointers they are attempting to
|
|
// elucidate to be incorrect.
|
|
return ARCInstKind::None;
|
|
}
|
|
}
|
|
|
|
// A list of intrinsics that we know do not use objc pointers or decrement
|
|
// ref counts.
|
|
static bool isInertIntrinsic(unsigned ID) {
|
|
// TODO: Make this into a covered switch.
|
|
switch (ID) {
|
|
case Intrinsic::returnaddress:
|
|
case Intrinsic::addressofreturnaddress:
|
|
case Intrinsic::frameaddress:
|
|
case Intrinsic::stacksave:
|
|
case Intrinsic::stackrestore:
|
|
case Intrinsic::vastart:
|
|
case Intrinsic::vacopy:
|
|
case Intrinsic::vaend:
|
|
case Intrinsic::objectsize:
|
|
case Intrinsic::prefetch:
|
|
case Intrinsic::stackprotector:
|
|
case Intrinsic::eh_return_i32:
|
|
case Intrinsic::eh_return_i64:
|
|
case Intrinsic::eh_typeid_for:
|
|
case Intrinsic::eh_dwarf_cfa:
|
|
case Intrinsic::eh_sjlj_lsda:
|
|
case Intrinsic::eh_sjlj_functioncontext:
|
|
case Intrinsic::init_trampoline:
|
|
case Intrinsic::adjust_trampoline:
|
|
case Intrinsic::lifetime_start:
|
|
case Intrinsic::lifetime_end:
|
|
case Intrinsic::invariant_start:
|
|
case Intrinsic::invariant_end:
|
|
// Don't let dbg info affect our results.
|
|
case Intrinsic::dbg_declare:
|
|
case Intrinsic::dbg_value:
|
|
case Intrinsic::dbg_label:
|
|
// Short cut: Some intrinsics obviously don't use ObjC pointers.
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// A list of intrinsics that we know do not use objc pointers or decrement
|
|
// ref counts.
|
|
static bool isUseOnlyIntrinsic(unsigned ID) {
|
|
// We are conservative and even though intrinsics are unlikely to touch
|
|
// reference counts, we white list them for safety.
|
|
//
|
|
// TODO: Expand this into a covered switch. There is a lot more here.
|
|
switch (ID) {
|
|
case Intrinsic::memcpy:
|
|
case Intrinsic::memmove:
|
|
case Intrinsic::memset:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// Determine what kind of construct V is.
|
|
ARCInstKind llvm::objcarc::GetARCInstKind(const Value *V) {
|
|
if (const Instruction *I = dyn_cast<Instruction>(V)) {
|
|
// Any instruction other than bitcast and gep with a pointer operand have a
|
|
// use of an objc pointer. Bitcasts, GEPs, Selects, PHIs transfer a pointer
|
|
// to a subsequent use, rather than using it themselves, in this sense.
|
|
// As a short cut, several other opcodes are known to have no pointer
|
|
// operands of interest. And ret is never followed by a release, so it's
|
|
// not interesting to examine.
|
|
switch (I->getOpcode()) {
|
|
case Instruction::Call: {
|
|
const CallInst *CI = cast<CallInst>(I);
|
|
// See if we have a function that we know something about.
|
|
if (const Function *F = CI->getCalledFunction()) {
|
|
ARCInstKind Class = GetFunctionClass(F);
|
|
if (Class != ARCInstKind::CallOrUser)
|
|
return Class;
|
|
Intrinsic::ID ID = F->getIntrinsicID();
|
|
if (isInertIntrinsic(ID))
|
|
return ARCInstKind::None;
|
|
if (isUseOnlyIntrinsic(ID))
|
|
return ARCInstKind::User;
|
|
}
|
|
|
|
// Otherwise, be conservative.
|
|
return GetCallSiteClass(*CI);
|
|
}
|
|
case Instruction::Invoke:
|
|
// Otherwise, be conservative.
|
|
return GetCallSiteClass(cast<InvokeInst>(*I));
|
|
case Instruction::BitCast:
|
|
case Instruction::GetElementPtr:
|
|
case Instruction::Select:
|
|
case Instruction::PHI:
|
|
case Instruction::Ret:
|
|
case Instruction::Br:
|
|
case Instruction::Switch:
|
|
case Instruction::IndirectBr:
|
|
case Instruction::Alloca:
|
|
case Instruction::VAArg:
|
|
case Instruction::Add:
|
|
case Instruction::FAdd:
|
|
case Instruction::Sub:
|
|
case Instruction::FSub:
|
|
case Instruction::Mul:
|
|
case Instruction::FMul:
|
|
case Instruction::SDiv:
|
|
case Instruction::UDiv:
|
|
case Instruction::FDiv:
|
|
case Instruction::SRem:
|
|
case Instruction::URem:
|
|
case Instruction::FRem:
|
|
case Instruction::Shl:
|
|
case Instruction::LShr:
|
|
case Instruction::AShr:
|
|
case Instruction::And:
|
|
case Instruction::Or:
|
|
case Instruction::Xor:
|
|
case Instruction::SExt:
|
|
case Instruction::ZExt:
|
|
case Instruction::Trunc:
|
|
case Instruction::IntToPtr:
|
|
case Instruction::FCmp:
|
|
case Instruction::FPTrunc:
|
|
case Instruction::FPExt:
|
|
case Instruction::FPToUI:
|
|
case Instruction::FPToSI:
|
|
case Instruction::UIToFP:
|
|
case Instruction::SIToFP:
|
|
case Instruction::InsertElement:
|
|
case Instruction::ExtractElement:
|
|
case Instruction::ShuffleVector:
|
|
case Instruction::ExtractValue:
|
|
break;
|
|
case Instruction::ICmp:
|
|
// Comparing a pointer with null, or any other constant, isn't an
|
|
// interesting use, because we don't care what the pointer points to, or
|
|
// about the values of any other dynamic reference-counted pointers.
|
|
if (IsPotentialRetainableObjPtr(I->getOperand(1)))
|
|
return ARCInstKind::User;
|
|
break;
|
|
default:
|
|
// For anything else, check all the operands.
|
|
// Note that this includes both operands of a Store: while the first
|
|
// operand isn't actually being dereferenced, it is being stored to
|
|
// memory where we can no longer track who might read it and dereference
|
|
// it, so we have to consider it potentially used.
|
|
for (User::const_op_iterator OI = I->op_begin(), OE = I->op_end();
|
|
OI != OE; ++OI)
|
|
if (IsPotentialRetainableObjPtr(*OI))
|
|
return ARCInstKind::User;
|
|
}
|
|
}
|
|
|
|
// Otherwise, it's totally inert for ARC purposes.
|
|
return ARCInstKind::None;
|
|
}
|
|
|
|
/// Test if the given class is a kind of user.
|
|
bool llvm::objcarc::IsUser(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::IntrinsicUser:
|
|
return true;
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::NoopCast:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::ClaimRV:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class is objc_retain or equivalent.
|
|
bool llvm::objcarc::IsRetain(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
return true;
|
|
// I believe we treat retain block as not a retain since it can copy its
|
|
// block.
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::NoopCast:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::ClaimRV:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class is objc_autorelease or equivalent.
|
|
bool llvm::objcarc::IsAutorelease(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
return true;
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::NoopCast:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which return their
|
|
/// argument verbatim.
|
|
bool llvm::objcarc::IsForwarding(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::NoopCast:
|
|
return true;
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which do nothing if
|
|
/// passed a null pointer.
|
|
bool llvm::objcarc::IsNoopOnNull(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::RetainBlock:
|
|
return true;
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which do nothing if
|
|
/// passed a global variable.
|
|
bool llvm::objcarc::IsNoopOnGlobal(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
return true;
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which are always safe
|
|
/// to mark with the "tail" keyword.
|
|
bool llvm::objcarc::IsAlwaysTail(ARCInstKind Class) {
|
|
// ARCInstKind::RetainBlock may be given a stack argument.
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
return true;
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which are never safe
|
|
/// to mark with the "tail" keyword.
|
|
bool llvm::objcarc::IsNeverTail(ARCInstKind Class) {
|
|
/// It is never safe to tail call objc_autorelease since by tail calling
|
|
/// objc_autorelease: fast autoreleasing causing our object to be potentially
|
|
/// reclaimed from the autorelease pool which violates the semantics of
|
|
/// __autoreleasing types in ARC.
|
|
switch (Class) {
|
|
case ARCInstKind::Autorelease:
|
|
return true;
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test if the given class represents instructions which are always safe
|
|
/// to mark with the nounwind attribute.
|
|
bool llvm::objcarc::IsNoThrow(ARCInstKind Class) {
|
|
// objc_retainBlock is not nounwind because it calls user copy constructors
|
|
// which could theoretically throw.
|
|
switch (Class) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
return true;
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
/// Test whether the given instruction can autorelease any pointer or cause an
|
|
/// autoreleasepool pop.
|
|
///
|
|
/// This means that it *could* interrupt the RV optimization.
|
|
bool llvm::objcarc::CanInterruptRV(ARCInstKind Class) {
|
|
switch (Class) {
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
return true;
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::ClaimRV:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
case ARCInstKind::NoopCast:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|
|
|
|
bool llvm::objcarc::CanDecrementRefCount(ARCInstKind Kind) {
|
|
switch (Kind) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::NoopCast:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
case ARCInstKind::IntrinsicUser:
|
|
case ARCInstKind::User:
|
|
case ARCInstKind::None:
|
|
return false;
|
|
|
|
// The cases below are conservative.
|
|
|
|
// RetainBlock can result in user defined copy constructors being called
|
|
// implying releases may occur.
|
|
case ARCInstKind::RetainBlock:
|
|
case ARCInstKind::Release:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::AutoreleasepoolPop:
|
|
case ARCInstKind::LoadWeakRetained:
|
|
case ARCInstKind::StoreWeak:
|
|
case ARCInstKind::InitWeak:
|
|
case ARCInstKind::LoadWeak:
|
|
case ARCInstKind::MoveWeak:
|
|
case ARCInstKind::CopyWeak:
|
|
case ARCInstKind::DestroyWeak:
|
|
case ARCInstKind::StoreStrong:
|
|
case ARCInstKind::CallOrUser:
|
|
case ARCInstKind::Call:
|
|
case ARCInstKind::ClaimRV:
|
|
return true;
|
|
}
|
|
|
|
llvm_unreachable("covered switch isn't covered?");
|
|
}
|