linux-packaging-mono/external/llvm-project/llvm/lib/Analysis/ObjCARCInstKind.cpp

//===- 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.
///
//===----------------------------------------------------------------------===//

#include "llvm/Analysis/ObjCARCInstKind.h"
#include "llvm/ADT/StringSwitch.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) {
  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.
  const Argument *A0 = &*AI++;
  if (AI == AE) {
    // Argument is a pointer.
    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))
        return StringSwitch<ARCInstKind>(F->getName())
            .Case("objc_loadWeakRetained", ARCInstKind::LoadWeakRetained)
            .Case("objc_loadWeak", ARCInstKind::LoadWeak)
            .Case("objc_destroyWeak", ARCInstKind::DestroyWeak)
            .Default(ARCInstKind::CallOrUser);

    // Anything else with one argument.
    return ARCInstKind::CallOrUser;
  }

  // Two arguments, first is i8**.
  const Argument *A1 = &*AI++;
  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;
}

// 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::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:
    // 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;
  }
}

/// \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);
      // 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;
}

/// \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:
  case ARCInstKind::ClaimRV:
    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:
  case ARCInstKind::ClaimRV:
    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:
  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?");
}

/// \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:
  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?");
}

/// \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:
  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?");
}

/// \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:
  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?");
}

/// \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:
  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?");
}

/// \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:
  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?");
}