maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/Analysis/ObjCARCInstKind.cpp

694 lines
24 KiB
C++
Raw Normal View History

[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
//===- ARCInstKind.cpp - ObjC ARC Optimization ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
/// \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.
///
//===----------------------------------------------------------------------===//
[ARC] Pull the ObjC ARC components that really serve the role of analyses into LLVM's Analysis library rather than having them in a Transforms library. This is motivated by the need to have the core AliasAnalysis infrastructure be aware of the ObjCARCAliasAnalysis. However, it also seems like a nice and clean separation. Everything was very easy to move and this doesn't create much clutter in the analysis library IMO. Differential Revision: http://reviews.llvm.org/D12133 llvm-svn: 245541
2015-08-20 16:06:03 +08:00
#include "llvm/Analysis/ObjCARCInstKind.h"
#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
#include "llvm/ADT/StringSwitch.h"
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
#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";
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
return OS << "ARCInstKind::ClaimRV";
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
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) {
Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
// No (mandatory) arguments.
if (AI == AE)
return StringSwitch<ARCInstKind>(F->getName())
.Case("objc_autoreleasePoolPush", ARCInstKind::AutoreleasepoolPush)
.Case("clang.arc.use", ARCInstKind::IntrinsicUser)
.Default(ARCInstKind::CallOrUser);
// One argument.
Analysis: Remove implicit ilist iterator conversions Remove implicit ilist iterator conversions from LLVMAnalysis. I came across something really scary in `llvm::isKnownNotFullPoison()` which relied on `Instruction::getNextNode()` being completely broken (not surprising, but scary nevertheless). This function is documented (and coded to) return `nullptr` when it gets to the sentinel, but with an `ilist_half_node` as a sentinel, the sentinel check looks into some other memory and we don't recognize we've hit the end. Rooting out these scary cases is the reason I'm removing the implicit conversions before doing anything else with `ilist`; I'm not at all surprised that clients rely on badness. I found another scary case -- this time, not relying on badness, just bad (but I guess getting lucky so far) -- in `ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the insertion point, do some things, and then restore it. Previously, we let the iterator auto-convert to `Instruction*`, and then set it back using the `Instruction*` version: Instruction *PrevInsertPoint = Builder.GetInsertPoint(); /* Logic that may change insert point */ if (PrevInsertPoint) Builder.SetInsertPoint(PrevInsertPoint); The check for `PrevInsertPoint` doesn't protect correctly against bad accesses. If the insertion point has been set to the end of a basic block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns an iterator pointing at the list sentinel. The version of `SetInsertPoint()` that's getting called will then call `PrevInsertPoint->getParent()`, which explodes horribly. The only reason this hasn't blown up is that it's fairly unlikely the builder is adding to the end of the block; usually, we're adding instructions somewhere before the terminator. llvm-svn: 249925
2015-10-10 08:53:03 +08:00
const Argument *A0 = &*AI++;
ObjCARC: Don't increment or dereference end() when scanning args When there's only one argument and it doesn't match one of the known functions, return ARCInstKind::CallOrUser rather than falling through to the two argument case. The old behaviour both incremented past and dereferenced end(). llvm-svn: 278881
2016-08-17 09:02:18 +08:00
if (AI == AE) {
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
// Argument is a pointer.
ObjCARC: Don't increment or dereference end() when scanning args When there's only one argument and it doesn't match one of the known functions, return ARCInstKind::CallOrUser rather than falling through to the two argument case. The old behaviour both incremented past and dereferenced end(). llvm-svn: 278881
2016-08-17 09:02:18 +08:00
PointerType *PTy = dyn_cast<PointerType>(A0->getType());
if (!PTy)
return ARCInstKind::CallOrUser;
Type *ETy = PTy->getElementType();
// Argument is i8*.
if (ETy->isIntegerTy(8))
return StringSwitch<ARCInstKind>(F->getName())
.Case("objc_retain", ARCInstKind::Retain)
.Case("objc_retainAutoreleasedReturnValue", ARCInstKind::RetainRV)
.Case("objc_unsafeClaimAutoreleasedReturnValue", ARCInstKind::ClaimRV)
.Case("objc_retainBlock", ARCInstKind::RetainBlock)
.Case("objc_release", ARCInstKind::Release)
.Case("objc_autorelease", ARCInstKind::Autorelease)
.Case("objc_autoreleaseReturnValue", ARCInstKind::AutoreleaseRV)
.Case("objc_autoreleasePoolPop", ARCInstKind::AutoreleasepoolPop)
.Case("objc_retainedObject", ARCInstKind::NoopCast)
.Case("objc_unretainedObject", ARCInstKind::NoopCast)
.Case("objc_unretainedPointer", ARCInstKind::NoopCast)
.Case("objc_retain_autorelease", ARCInstKind::FusedRetainAutorelease)
.Case("objc_retainAutorelease", ARCInstKind::FusedRetainAutorelease)
.Case("objc_retainAutoreleaseReturnValue",
ARCInstKind::FusedRetainAutoreleaseRV)
.Case("objc_sync_enter", ARCInstKind::User)
.Case("objc_sync_exit", ARCInstKind::User)
.Default(ARCInstKind::CallOrUser);
// Argument is i8**
if (PointerType *Pte = dyn_cast<PointerType>(ETy))
if (Pte->getElementType()->isIntegerTy(8))
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
return StringSwitch<ARCInstKind>(F->getName())
ObjCARC: Don't increment or dereference end() when scanning args When there's only one argument and it doesn't match one of the known functions, return ARCInstKind::CallOrUser rather than falling through to the two argument case. The old behaviour both incremented past and dereferenced end(). llvm-svn: 278881
2016-08-17 09:02:18 +08:00
.Case("objc_loadWeakRetained", ARCInstKind::LoadWeakRetained)
.Case("objc_loadWeak", ARCInstKind::LoadWeak)
.Case("objc_destroyWeak", ARCInstKind::DestroyWeak)
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
.Default(ARCInstKind::CallOrUser);
ObjCARC: Don't increment or dereference end() when scanning args When there's only one argument and it doesn't match one of the known functions, return ARCInstKind::CallOrUser rather than falling through to the two argument case. The old behaviour both incremented past and dereferenced end(). llvm-svn: 278881
2016-08-17 09:02:18 +08:00
// Anything else with one argument.
return ARCInstKind::CallOrUser;
}
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
// Two arguments, first is i8**.
Analysis: Remove implicit ilist iterator conversions Remove implicit ilist iterator conversions from LLVMAnalysis. I came across something really scary in `llvm::isKnownNotFullPoison()` which relied on `Instruction::getNextNode()` being completely broken (not surprising, but scary nevertheless). This function is documented (and coded to) return `nullptr` when it gets to the sentinel, but with an `ilist_half_node` as a sentinel, the sentinel check looks into some other memory and we don't recognize we've hit the end. Rooting out these scary cases is the reason I'm removing the implicit conversions before doing anything else with `ilist`; I'm not at all surprised that clients rely on badness. I found another scary case -- this time, not relying on badness, just bad (but I guess getting lucky so far) -- in `ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the insertion point, do some things, and then restore it. Previously, we let the iterator auto-convert to `Instruction*`, and then set it back using the `Instruction*` version: Instruction *PrevInsertPoint = Builder.GetInsertPoint(); /* Logic that may change insert point */ if (PrevInsertPoint) Builder.SetInsertPoint(PrevInsertPoint); The check for `PrevInsertPoint` doesn't protect correctly against bad accesses. If the insertion point has been set to the end of a basic block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns an iterator pointing at the list sentinel. The version of `SetInsertPoint()` that's getting called will then call `PrevInsertPoint->getParent()`, which explodes horribly. The only reason this hasn't blown up is that it's fairly unlikely the builder is adding to the end of the block; usually, we're adding instructions somewhere before the terminator. llvm-svn: 249925
2015-10-10 08:53:03 +08:00
const Argument *A1 = &*AI++;
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
if (AI == AE)
if (PointerType *PTy = dyn_cast<PointerType>(A0->getType()))
if (PointerType *Pte = dyn_cast<PointerType>(PTy->getElementType()))
if (Pte->getElementType()->isIntegerTy(8))
if (PointerType *PTy1 = dyn_cast<PointerType>(A1->getType())) {
Type *ETy1 = PTy1->getElementType();
// Second argument is i8*
if (ETy1->isIntegerTy(8))
return StringSwitch<ARCInstKind>(F->getName())
.Case("objc_storeWeak", ARCInstKind::StoreWeak)
.Case("objc_initWeak", ARCInstKind::InitWeak)
.Case("objc_storeStrong", ARCInstKind::StoreStrong)
.Default(ARCInstKind::CallOrUser);
// Second argument is i8**.
if (PointerType *Pte1 = dyn_cast<PointerType>(ETy1))
if (Pte1->getElementType()->isIntegerTy(8))
return StringSwitch<ARCInstKind>(F->getName())
.Case("objc_moveWeak", ARCInstKind::MoveWeak)
.Case("objc_copyWeak", ARCInstKind::CopyWeak)
// 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.
.Case("llvm.arc.annotation.topdown.bbstart",
ARCInstKind::None)
.Case("llvm.arc.annotation.topdown.bbend",
ARCInstKind::None)
.Case("llvm.arc.annotation.bottomup.bbstart",
ARCInstKind::None)
.Case("llvm.arc.annotation.bottomup.bbend",
ARCInstKind::None)
.Default(ARCInstKind::CallOrUser);
}
// Anything else.
return ARCInstKind::CallOrUser;
}
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
// A whitelist 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::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:
// Short cut: Some intrinsics obviously don't use ObjC pointers.
return true;
default:
return false;
}
}
// A whitelist 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;
}
}
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
/// \brief 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);
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
// See if we have a function that we know something about.
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
if (const Function *F = CI->getCalledFunction()) {
ARCInstKind Class = GetFunctionClass(F);
if (Class != ARCInstKind::CallOrUser)
return Class;
Change Function::getIntrinsicID() to return an Intrinsic::ID. NFC. Now that Intrinsic::ID is a typed enum, we can forward declare it and so return it from this method. This updates all users which were either using an unsigned to store it, or had a now unnecessary cast. llvm-svn: 237810
2015-05-21 01:16:39 +08:00
Intrinsic::ID ID = F->getIntrinsicID();
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
if (isInertIntrinsic(ID))
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
return ARCInstKind::None;
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
if (isUseOnlyIntrinsic(ID))
return ARCInstKind::User;
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
}
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
// Otherwise, be conservative.
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
return GetCallSiteClass(CI);
}
case Instruction::Invoke:
[objc-arc] Treat memcpy, memove, memset as just using pointers, not decrementing them. This will be tested in the next commit (which required it). The commit is going to update a bunch of tests at the same time. llvm-svn: 232350
2015-03-16 15:02:32 +08:00
// Otherwise, be conservative.
[objc-arc] Change the InstructionClass to be an enum class called ARCInstKind. I also renamed ObjCARCUtil.cpp -> ARCInstKind.cpp. That file only contained items related to ARCInstKind anyways. llvm-svn: 229905
2015-02-20 03:51:32 +08:00
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;
}
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
return false;
}
llvm_unreachable("covered switch isn't covered?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
return false;
}
llvm_unreachable("covered switch isn't covered?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
/// \brief 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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Convert the bodies of ARCInstKind predicates into covered switches. This is much better than the previous manner of just using short-curcuiting booleans from: 1. A "naive" efficiency perspective: we do not have to rely on the compiler to change the short circuiting boolean operations into a switch. 2. An understanding perspective by making the implicit behavior of negative predicates explicit. 3. A maintainability perspective through the covered switch flag making it easy to know where to update code when adding new ARCInstKinds. llvm-svn: 229906
2015-02-20 03:51:36 +08:00
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?");
}
[objc-arc] Add the predicate CanDecrementRefCount. This is different from CanAlterRefCount since CanDecrementRefCount is attempting to prove specifically whether or not an instruction can decrement instead of the more general question of whether it can decrement or increment. llvm-svn: 229936
2015-02-20 08:02:45 +08:00
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:
Add support for objc_unsafeClaimAutoreleasedReturnValue to the ObjC ARC Optimizer. The main implication of this is: 1. Ensuring that we treat it conservatively in terms of optimization. 2. We put the ASM marker on it so that the runtime can recognize objc_unsafeClaimAutoreleasedReturnValue from releaseRV. <rdar://problem/21567064> Patch by Michael Gottesman! llvm-svn: 258970
2016-01-28 03:05:08 +08:00
case ARCInstKind::ClaimRV:
[objc-arc] Add the predicate CanDecrementRefCount. This is different from CanAlterRefCount since CanDecrementRefCount is attempting to prove specifically whether or not an instruction can decrement instead of the more general question of whether it can decrement or increment. llvm-svn: 229936
2015-02-20 08:02:45 +08:00
return true;
}
llvm_unreachable("covered switch isn't covered?");
}