Home | History | Annotate | Download | only in Analysis 
      1 //===- ARCInstKind.cpp - ObjC ARC Optimization ----------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 /// \file
     10 /// This file defines several utility functions used by various ARC
     11 /// optimizations which are IMHO too big to be in a header file.
     12 ///
     13 /// WARNING: This file knows about certain library functions. It recognizes them
     14 /// by name, and hardwires knowledge of their semantics.
     15 ///
     16 /// WARNING: This file knows about how certain Objective-C library functions are
     17 /// used. Naive LLVM IR transformations which would otherwise be
     18 /// behavior-preserving may break these assumptions.
     19 ///
     20 //===----------------------------------------------------------------------===//
     21 
     22 #include "llvm/Analysis/ObjCARCInstKind.h"
     23 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
     24 #include "llvm/ADT/StringSwitch.h"
     25 #include "llvm/IR/Intrinsics.h"
     26 
     27 using namespace llvm;
     28 using namespace llvm::objcarc;
     29 
     30 raw_ostream &llvm::objcarc::operator<<(raw_ostream &OS,
     31                                        const ARCInstKind Class) {
     32   switch (Class) {
     33   case ARCInstKind::Retain:
     34     return OS << "ARCInstKind::Retain";
     35   case ARCInstKind::RetainRV:
     36     return OS << "ARCInstKind::RetainRV";
     37   case ARCInstKind::RetainBlock:
     38     return OS << "ARCInstKind::RetainBlock";
     39   case ARCInstKind::Release:
     40     return OS << "ARCInstKind::Release";
     41   case ARCInstKind::Autorelease:
     42     return OS << "ARCInstKind::Autorelease";
     43   case ARCInstKind::AutoreleaseRV:
     44     return OS << "ARCInstKind::AutoreleaseRV";
     45   case ARCInstKind::AutoreleasepoolPush:
     46     return OS << "ARCInstKind::AutoreleasepoolPush";
     47   case ARCInstKind::AutoreleasepoolPop:
     48     return OS << "ARCInstKind::AutoreleasepoolPop";
     49   case ARCInstKind::NoopCast:
     50     return OS << "ARCInstKind::NoopCast";
     51   case ARCInstKind::FusedRetainAutorelease:
     52     return OS << "ARCInstKind::FusedRetainAutorelease";
     53   case ARCInstKind::FusedRetainAutoreleaseRV:
     54     return OS << "ARCInstKind::FusedRetainAutoreleaseRV";
     55   case ARCInstKind::LoadWeakRetained:
     56     return OS << "ARCInstKind::LoadWeakRetained";
     57   case ARCInstKind::StoreWeak:
     58     return OS << "ARCInstKind::StoreWeak";
     59   case ARCInstKind::InitWeak:
     60     return OS << "ARCInstKind::InitWeak";
     61   case ARCInstKind::LoadWeak:
     62     return OS << "ARCInstKind::LoadWeak";
     63   case ARCInstKind::MoveWeak:
     64     return OS << "ARCInstKind::MoveWeak";
     65   case ARCInstKind::CopyWeak:
     66     return OS << "ARCInstKind::CopyWeak";
     67   case ARCInstKind::DestroyWeak:
     68     return OS << "ARCInstKind::DestroyWeak";
     69   case ARCInstKind::StoreStrong:
     70     return OS << "ARCInstKind::StoreStrong";
     71   case ARCInstKind::CallOrUser:
     72     return OS << "ARCInstKind::CallOrUser";
     73   case ARCInstKind::Call:
     74     return OS << "ARCInstKind::Call";
     75   case ARCInstKind::User:
     76     return OS << "ARCInstKind::User";
     77   case ARCInstKind::IntrinsicUser:
     78     return OS << "ARCInstKind::IntrinsicUser";
     79   case ARCInstKind::None:
     80     return OS << "ARCInstKind::None";
     81   }
     82   llvm_unreachable("Unknown instruction class!");
     83 }
     84 
     85 ARCInstKind llvm::objcarc::GetFunctionClass(const Function *F) {
     86   Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
     87 
     88   // No (mandatory) arguments.
     89   if (AI == AE)
     90     return StringSwitch<ARCInstKind>(F->getName())
     91         .Case("objc_autoreleasePoolPush", ARCInstKind::AutoreleasepoolPush)
     92         .Case("clang.arc.use", ARCInstKind::IntrinsicUser)
     93         .Default(ARCInstKind::CallOrUser);
     94 
     95   // One argument.
     96   const Argument *A0 = &*AI++;
     97   if (AI == AE)
     98     // Argument is a pointer.
     99     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType())) {
    100       Type *ETy = PTy->getElementType();
    101       // Argument is i8*.
    102       if (ETy->isIntegerTy(8))
    103         return StringSwitch<ARCInstKind>(F->getName())
    104             .Case("objc_retain", ARCInstKind::Retain)
    105             .Case("objc_retainAutoreleasedReturnValue", ARCInstKind::RetainRV)
    106             .Case("objc_retainBlock", ARCInstKind::RetainBlock)
    107             .Case("objc_release", ARCInstKind::Release)
    108             .Case("objc_autorelease", ARCInstKind::Autorelease)
    109             .Case("objc_autoreleaseReturnValue", ARCInstKind::AutoreleaseRV)
    110             .Case("objc_autoreleasePoolPop", ARCInstKind::AutoreleasepoolPop)
    111             .Case("objc_retainedObject", ARCInstKind::NoopCast)
    112             .Case("objc_unretainedObject", ARCInstKind::NoopCast)
    113             .Case("objc_unretainedPointer", ARCInstKind::NoopCast)
    114             .Case("objc_retain_autorelease",
    115                   ARCInstKind::FusedRetainAutorelease)
    116             .Case("objc_retainAutorelease", ARCInstKind::FusedRetainAutorelease)
    117             .Case("objc_retainAutoreleaseReturnValue",
    118                   ARCInstKind::FusedRetainAutoreleaseRV)
    119             .Case("objc_sync_enter", ARCInstKind::User)
    120             .Case("objc_sync_exit", ARCInstKind::User)
    121             .Default(ARCInstKind::CallOrUser);
    122 
    123       // Argument is i8**
    124       if (PointerType *Pte = dyn_cast<PointerType>(ETy))
    125         if (Pte->getElementType()->isIntegerTy(8))
    126           return StringSwitch<ARCInstKind>(F->getName())
    127               .Case("objc_loadWeakRetained", ARCInstKind::LoadWeakRetained)
    128               .Case("objc_loadWeak", ARCInstKind::LoadWeak)
    129               .Case("objc_destroyWeak", ARCInstKind::DestroyWeak)
    130               .Default(ARCInstKind::CallOrUser);
    131     }
    132 
    133   // Two arguments, first is i8**.
    134   const Argument *A1 = &*AI++;
    135   if (AI == AE)
    136     if (PointerType *PTy = dyn_cast<PointerType>(A0->getType()))
    137       if (PointerType *Pte = dyn_cast<PointerType>(PTy->getElementType()))
    138         if (Pte->getElementType()->isIntegerTy(8))
    139           if (PointerType *PTy1 = dyn_cast<PointerType>(A1->getType())) {
    140             Type *ETy1 = PTy1->getElementType();
    141             // Second argument is i8*
    142             if (ETy1->isIntegerTy(8))
    143               return StringSwitch<ARCInstKind>(F->getName())
    144                   .Case("objc_storeWeak", ARCInstKind::StoreWeak)
    145                   .Case("objc_initWeak", ARCInstKind::InitWeak)
    146                   .Case("objc_storeStrong", ARCInstKind::StoreStrong)
    147                   .Default(ARCInstKind::CallOrUser);
    148             // Second argument is i8**.
    149             if (PointerType *Pte1 = dyn_cast<PointerType>(ETy1))
    150               if (Pte1->getElementType()->isIntegerTy(8))
    151                 return StringSwitch<ARCInstKind>(F->getName())
    152                     .Case("objc_moveWeak", ARCInstKind::MoveWeak)
    153                     .Case("objc_copyWeak", ARCInstKind::CopyWeak)
    154                     // Ignore annotation calls. This is important to stop the
    155                     // optimizer from treating annotations as uses which would
    156                     // make the state of the pointers they are attempting to
    157                     // elucidate to be incorrect.
    158                     .Case("llvm.arc.annotation.topdown.bbstart",
    159                           ARCInstKind::None)
    160                     .Case("llvm.arc.annotation.topdown.bbend",
    161                           ARCInstKind::None)
    162                     .Case("llvm.arc.annotation.bottomup.bbstart",
    163                           ARCInstKind::None)
    164                     .Case("llvm.arc.annotation.bottomup.bbend",
    165                           ARCInstKind::None)
    166                     .Default(ARCInstKind::CallOrUser);
    167           }
    168 
    169   // Anything else.
    170   return ARCInstKind::CallOrUser;
    171 }
    172 
    173 // A whitelist of intrinsics that we know do not use objc pointers or decrement
    174 // ref counts.
    175 static bool isInertIntrinsic(unsigned ID) {
    176   // TODO: Make this into a covered switch.
    177   switch (ID) {
    178   case Intrinsic::returnaddress:
    179   case Intrinsic::frameaddress:
    180   case Intrinsic::stacksave:
    181   case Intrinsic::stackrestore:
    182   case Intrinsic::vastart:
    183   case Intrinsic::vacopy:
    184   case Intrinsic::vaend:
    185   case Intrinsic::objectsize:
    186   case Intrinsic::prefetch:
    187   case Intrinsic::stackprotector:
    188   case Intrinsic::eh_return_i32:
    189   case Intrinsic::eh_return_i64:
    190   case Intrinsic::eh_typeid_for:
    191   case Intrinsic::eh_dwarf_cfa:
    192   case Intrinsic::eh_sjlj_lsda:
    193   case Intrinsic::eh_sjlj_functioncontext:
    194   case Intrinsic::init_trampoline:
    195   case Intrinsic::adjust_trampoline:
    196   case Intrinsic::lifetime_start:
    197   case Intrinsic::lifetime_end:
    198   case Intrinsic::invariant_start:
    199   case Intrinsic::invariant_end:
    200   // Don't let dbg info affect our results.
    201   case Intrinsic::dbg_declare:
    202   case Intrinsic::dbg_value:
    203     // Short cut: Some intrinsics obviously don't use ObjC pointers.
    204     return true;
    205   default:
    206     return false;
    207   }
    208 }
    209 
    210 // A whitelist of intrinsics that we know do not use objc pointers or decrement
    211 // ref counts.
    212 static bool isUseOnlyIntrinsic(unsigned ID) {
    213   // We are conservative and even though intrinsics are unlikely to touch
    214   // reference counts, we white list them for safety.
    215   //
    216   // TODO: Expand this into a covered switch. There is a lot more here.
    217   switch (ID) {
    218   case Intrinsic::memcpy:
    219   case Intrinsic::memmove:
    220   case Intrinsic::memset:
    221     return true;
    222   default:
    223     return false;
    224   }
    225 }
    226 
    227 /// \brief Determine what kind of construct V is.
    228 ARCInstKind llvm::objcarc::GetARCInstKind(const Value *V) {
    229   if (const Instruction *I = dyn_cast<Instruction>(V)) {
    230     // Any instruction other than bitcast and gep with a pointer operand have a
    231     // use of an objc pointer. Bitcasts, GEPs, Selects, PHIs transfer a pointer
    232     // to a subsequent use, rather than using it themselves, in this sense.
    233     // As a short cut, several other opcodes are known to have no pointer
    234     // operands of interest. And ret is never followed by a release, so it's
    235     // not interesting to examine.
    236     switch (I->getOpcode()) {
    237     case Instruction::Call: {
    238       const CallInst *CI = cast<CallInst>(I);
    239       // See if we have a function that we know something about.
    240       if (const Function *F = CI->getCalledFunction()) {
    241         ARCInstKind Class = GetFunctionClass(F);
    242         if (Class != ARCInstKind::CallOrUser)
    243           return Class;
    244         Intrinsic::ID ID = F->getIntrinsicID();
    245         if (isInertIntrinsic(ID))
    246           return ARCInstKind::None;
    247         if (isUseOnlyIntrinsic(ID))
    248           return ARCInstKind::User;
    249       }
    250 
    251       // Otherwise, be conservative.
    252       return GetCallSiteClass(CI);
    253     }
    254     case Instruction::Invoke:
    255       // Otherwise, be conservative.
    256       return GetCallSiteClass(cast<InvokeInst>(I));
    257     case Instruction::BitCast:
    258     case Instruction::GetElementPtr:
    259     case Instruction::Select:
    260     case Instruction::PHI:
    261     case Instruction::Ret:
    262     case Instruction::Br:
    263     case Instruction::Switch:
    264     case Instruction::IndirectBr:
    265     case Instruction::Alloca:
    266     case Instruction::VAArg:
    267     case Instruction::Add:
    268     case Instruction::FAdd:
    269     case Instruction::Sub:
    270     case Instruction::FSub:
    271     case Instruction::Mul:
    272     case Instruction::FMul:
    273     case Instruction::SDiv:
    274     case Instruction::UDiv:
    275     case Instruction::FDiv:
    276     case Instruction::SRem:
    277     case Instruction::URem:
    278     case Instruction::FRem:
    279     case Instruction::Shl:
    280     case Instruction::LShr:
    281     case Instruction::AShr:
    282     case Instruction::And:
    283     case Instruction::Or:
    284     case Instruction::Xor:
    285     case Instruction::SExt:
    286     case Instruction::ZExt:
    287     case Instruction::Trunc:
    288     case Instruction::IntToPtr:
    289     case Instruction::FCmp:
    290     case Instruction::FPTrunc:
    291     case Instruction::FPExt:
    292     case Instruction::FPToUI:
    293     case Instruction::FPToSI:
    294     case Instruction::UIToFP:
    295     case Instruction::SIToFP:
    296     case Instruction::InsertElement:
    297     case Instruction::ExtractElement:
    298     case Instruction::ShuffleVector:
    299     case Instruction::ExtractValue:
    300       break;
    301     case Instruction::ICmp:
    302       // Comparing a pointer with null, or any other constant, isn't an
    303       // interesting use, because we don't care what the pointer points to, or
    304       // about the values of any other dynamic reference-counted pointers.
    305       if (IsPotentialRetainableObjPtr(I->getOperand(1)))
    306         return ARCInstKind::User;
    307       break;
    308     default:
    309       // For anything else, check all the operands.
    310       // Note that this includes both operands of a Store: while the first
    311       // operand isn't actually being dereferenced, it is being stored to
    312       // memory where we can no longer track who might read it and dereference
    313       // it, so we have to consider it potentially used.
    314       for (User::const_op_iterator OI = I->op_begin(), OE = I->op_end();
    315            OI != OE; ++OI)
    316         if (IsPotentialRetainableObjPtr(*OI))
    317           return ARCInstKind::User;
    318     }
    319   }
    320 
    321   // Otherwise, it's totally inert for ARC purposes.
    322   return ARCInstKind::None;
    323 }
    324 
    325 /// \brief Test if the given class is a kind of user.
    326 bool llvm::objcarc::IsUser(ARCInstKind Class) {
    327   switch (Class) {
    328   case ARCInstKind::User:
    329   case ARCInstKind::CallOrUser:
    330   case ARCInstKind::IntrinsicUser:
    331     return true;
    332   case ARCInstKind::Retain:
    333   case ARCInstKind::RetainRV:
    334   case ARCInstKind::RetainBlock:
    335   case ARCInstKind::Release:
    336   case ARCInstKind::Autorelease:
    337   case ARCInstKind::AutoreleaseRV:
    338   case ARCInstKind::AutoreleasepoolPush:
    339   case ARCInstKind::AutoreleasepoolPop:
    340   case ARCInstKind::NoopCast:
    341   case ARCInstKind::FusedRetainAutorelease:
    342   case ARCInstKind::FusedRetainAutoreleaseRV:
    343   case ARCInstKind::LoadWeakRetained:
    344   case ARCInstKind::StoreWeak:
    345   case ARCInstKind::InitWeak:
    346   case ARCInstKind::LoadWeak:
    347   case ARCInstKind::MoveWeak:
    348   case ARCInstKind::CopyWeak:
    349   case ARCInstKind::DestroyWeak:
    350   case ARCInstKind::StoreStrong:
    351   case ARCInstKind::Call:
    352   case ARCInstKind::None:
    353     return false;
    354   }
    355   llvm_unreachable("covered switch isn't covered?");
    356 }
    357 
    358 /// \brief Test if the given class is objc_retain or equivalent.
    359 bool llvm::objcarc::IsRetain(ARCInstKind Class) {
    360   switch (Class) {
    361   case ARCInstKind::Retain:
    362   case ARCInstKind::RetainRV:
    363     return true;
    364   // I believe we treat retain block as not a retain since it can copy its
    365   // block.
    366   case ARCInstKind::RetainBlock:
    367   case ARCInstKind::Release:
    368   case ARCInstKind::Autorelease:
    369   case ARCInstKind::AutoreleaseRV:
    370   case ARCInstKind::AutoreleasepoolPush:
    371   case ARCInstKind::AutoreleasepoolPop:
    372   case ARCInstKind::NoopCast:
    373   case ARCInstKind::FusedRetainAutorelease:
    374   case ARCInstKind::FusedRetainAutoreleaseRV:
    375   case ARCInstKind::LoadWeakRetained:
    376   case ARCInstKind::StoreWeak:
    377   case ARCInstKind::InitWeak:
    378   case ARCInstKind::LoadWeak:
    379   case ARCInstKind::MoveWeak:
    380   case ARCInstKind::CopyWeak:
    381   case ARCInstKind::DestroyWeak:
    382   case ARCInstKind::StoreStrong:
    383   case ARCInstKind::IntrinsicUser:
    384   case ARCInstKind::CallOrUser:
    385   case ARCInstKind::Call:
    386   case ARCInstKind::User:
    387   case ARCInstKind::None:
    388     return false;
    389   }
    390   llvm_unreachable("covered switch isn't covered?");
    391 }
    392 
    393 /// \brief Test if the given class is objc_autorelease or equivalent.
    394 bool llvm::objcarc::IsAutorelease(ARCInstKind Class) {
    395   switch (Class) {
    396   case ARCInstKind::Autorelease:
    397   case ARCInstKind::AutoreleaseRV:
    398     return true;
    399   case ARCInstKind::Retain:
    400   case ARCInstKind::RetainRV:
    401   case ARCInstKind::RetainBlock:
    402   case ARCInstKind::Release:
    403   case ARCInstKind::AutoreleasepoolPush:
    404   case ARCInstKind::AutoreleasepoolPop:
    405   case ARCInstKind::NoopCast:
    406   case ARCInstKind::FusedRetainAutorelease:
    407   case ARCInstKind::FusedRetainAutoreleaseRV:
    408   case ARCInstKind::LoadWeakRetained:
    409   case ARCInstKind::StoreWeak:
    410   case ARCInstKind::InitWeak:
    411   case ARCInstKind::LoadWeak:
    412   case ARCInstKind::MoveWeak:
    413   case ARCInstKind::CopyWeak:
    414   case ARCInstKind::DestroyWeak:
    415   case ARCInstKind::StoreStrong:
    416   case ARCInstKind::IntrinsicUser:
    417   case ARCInstKind::CallOrUser:
    418   case ARCInstKind::Call:
    419   case ARCInstKind::User:
    420   case ARCInstKind::None:
    421     return false;
    422   }
    423   llvm_unreachable("covered switch isn't covered?");
    424 }
    425 
    426 /// \brief Test if the given class represents instructions which return their
    427 /// argument verbatim.
    428 bool llvm::objcarc::IsForwarding(ARCInstKind Class) {
    429   switch (Class) {
    430   case ARCInstKind::Retain:
    431   case ARCInstKind::RetainRV:
    432   case ARCInstKind::Autorelease:
    433   case ARCInstKind::AutoreleaseRV:
    434   case ARCInstKind::NoopCast:
    435     return true;
    436   case ARCInstKind::RetainBlock:
    437   case ARCInstKind::Release:
    438   case ARCInstKind::AutoreleasepoolPush:
    439   case ARCInstKind::AutoreleasepoolPop:
    440   case ARCInstKind::FusedRetainAutorelease:
    441   case ARCInstKind::FusedRetainAutoreleaseRV:
    442   case ARCInstKind::LoadWeakRetained:
    443   case ARCInstKind::StoreWeak:
    444   case ARCInstKind::InitWeak:
    445   case ARCInstKind::LoadWeak:
    446   case ARCInstKind::MoveWeak:
    447   case ARCInstKind::CopyWeak:
    448   case ARCInstKind::DestroyWeak:
    449   case ARCInstKind::StoreStrong:
    450   case ARCInstKind::IntrinsicUser:
    451   case ARCInstKind::CallOrUser:
    452   case ARCInstKind::Call:
    453   case ARCInstKind::User:
    454   case ARCInstKind::None:
    455     return false;
    456   }
    457   llvm_unreachable("covered switch isn't covered?");
    458 }
    459 
    460 /// \brief Test if the given class represents instructions which do nothing if
    461 /// passed a null pointer.
    462 bool llvm::objcarc::IsNoopOnNull(ARCInstKind Class) {
    463   switch (Class) {
    464   case ARCInstKind::Retain:
    465   case ARCInstKind::RetainRV:
    466   case ARCInstKind::Release:
    467   case ARCInstKind::Autorelease:
    468   case ARCInstKind::AutoreleaseRV:
    469   case ARCInstKind::RetainBlock:
    470     return true;
    471   case ARCInstKind::AutoreleasepoolPush:
    472   case ARCInstKind::AutoreleasepoolPop:
    473   case ARCInstKind::FusedRetainAutorelease:
    474   case ARCInstKind::FusedRetainAutoreleaseRV:
    475   case ARCInstKind::LoadWeakRetained:
    476   case ARCInstKind::StoreWeak:
    477   case ARCInstKind::InitWeak:
    478   case ARCInstKind::LoadWeak:
    479   case ARCInstKind::MoveWeak:
    480   case ARCInstKind::CopyWeak:
    481   case ARCInstKind::DestroyWeak:
    482   case ARCInstKind::StoreStrong:
    483   case ARCInstKind::IntrinsicUser:
    484   case ARCInstKind::CallOrUser:
    485   case ARCInstKind::Call:
    486   case ARCInstKind::User:
    487   case ARCInstKind::None:
    488   case ARCInstKind::NoopCast:
    489     return false;
    490   }
    491   llvm_unreachable("covered switch isn't covered?");
    492 }
    493 
    494 /// \brief Test if the given class represents instructions which are always safe
    495 /// to mark with the "tail" keyword.
    496 bool llvm::objcarc::IsAlwaysTail(ARCInstKind Class) {
    497   // ARCInstKind::RetainBlock may be given a stack argument.
    498   switch (Class) {
    499   case ARCInstKind::Retain:
    500   case ARCInstKind::RetainRV:
    501   case ARCInstKind::AutoreleaseRV:
    502     return true;
    503   case ARCInstKind::Release:
    504   case ARCInstKind::Autorelease:
    505   case ARCInstKind::RetainBlock:
    506   case ARCInstKind::AutoreleasepoolPush:
    507   case ARCInstKind::AutoreleasepoolPop:
    508   case ARCInstKind::FusedRetainAutorelease:
    509   case ARCInstKind::FusedRetainAutoreleaseRV:
    510   case ARCInstKind::LoadWeakRetained:
    511   case ARCInstKind::StoreWeak:
    512   case ARCInstKind::InitWeak:
    513   case ARCInstKind::LoadWeak:
    514   case ARCInstKind::MoveWeak:
    515   case ARCInstKind::CopyWeak:
    516   case ARCInstKind::DestroyWeak:
    517   case ARCInstKind::StoreStrong:
    518   case ARCInstKind::IntrinsicUser:
    519   case ARCInstKind::CallOrUser:
    520   case ARCInstKind::Call:
    521   case ARCInstKind::User:
    522   case ARCInstKind::None:
    523   case ARCInstKind::NoopCast:
    524     return false;
    525   }
    526   llvm_unreachable("covered switch isn't covered?");
    527 }
    528 
    529 /// \brief Test if the given class represents instructions which are never safe
    530 /// to mark with the "tail" keyword.
    531 bool llvm::objcarc::IsNeverTail(ARCInstKind Class) {
    532   /// It is never safe to tail call objc_autorelease since by tail calling
    533   /// objc_autorelease: fast autoreleasing causing our object to be potentially
    534   /// reclaimed from the autorelease pool which violates the semantics of
    535   /// __autoreleasing types in ARC.
    536   switch (Class) {
    537   case ARCInstKind::Autorelease:
    538     return true;
    539   case ARCInstKind::Retain:
    540   case ARCInstKind::RetainRV:
    541   case ARCInstKind::AutoreleaseRV:
    542   case ARCInstKind::Release:
    543   case ARCInstKind::RetainBlock:
    544   case ARCInstKind::AutoreleasepoolPush:
    545   case ARCInstKind::AutoreleasepoolPop:
    546   case ARCInstKind::FusedRetainAutorelease:
    547   case ARCInstKind::FusedRetainAutoreleaseRV:
    548   case ARCInstKind::LoadWeakRetained:
    549   case ARCInstKind::StoreWeak:
    550   case ARCInstKind::InitWeak:
    551   case ARCInstKind::LoadWeak:
    552   case ARCInstKind::MoveWeak:
    553   case ARCInstKind::CopyWeak:
    554   case ARCInstKind::DestroyWeak:
    555   case ARCInstKind::StoreStrong:
    556   case ARCInstKind::IntrinsicUser:
    557   case ARCInstKind::CallOrUser:
    558   case ARCInstKind::Call:
    559   case ARCInstKind::User:
    560   case ARCInstKind::None:
    561   case ARCInstKind::NoopCast:
    562     return false;
    563   }
    564   llvm_unreachable("covered switch isn't covered?");
    565 }
    566 
    567 /// \brief Test if the given class represents instructions which are always safe
    568 /// to mark with the nounwind attribute.
    569 bool llvm::objcarc::IsNoThrow(ARCInstKind Class) {
    570   // objc_retainBlock is not nounwind because it calls user copy constructors
    571   // which could theoretically throw.
    572   switch (Class) {
    573   case ARCInstKind::Retain:
    574   case ARCInstKind::RetainRV:
    575   case ARCInstKind::Release:
    576   case ARCInstKind::Autorelease:
    577   case ARCInstKind::AutoreleaseRV:
    578   case ARCInstKind::AutoreleasepoolPush:
    579   case ARCInstKind::AutoreleasepoolPop:
    580     return true;
    581   case ARCInstKind::RetainBlock:
    582   case ARCInstKind::FusedRetainAutorelease:
    583   case ARCInstKind::FusedRetainAutoreleaseRV:
    584   case ARCInstKind::LoadWeakRetained:
    585   case ARCInstKind::StoreWeak:
    586   case ARCInstKind::InitWeak:
    587   case ARCInstKind::LoadWeak:
    588   case ARCInstKind::MoveWeak:
    589   case ARCInstKind::CopyWeak:
    590   case ARCInstKind::DestroyWeak:
    591   case ARCInstKind::StoreStrong:
    592   case ARCInstKind::IntrinsicUser:
    593   case ARCInstKind::CallOrUser:
    594   case ARCInstKind::Call:
    595   case ARCInstKind::User:
    596   case ARCInstKind::None:
    597   case ARCInstKind::NoopCast:
    598     return false;
    599   }
    600   llvm_unreachable("covered switch isn't covered?");
    601 }
    602 
    603 /// Test whether the given instruction can autorelease any pointer or cause an
    604 /// autoreleasepool pop.
    605 ///
    606 /// This means that it *could* interrupt the RV optimization.
    607 bool llvm::objcarc::CanInterruptRV(ARCInstKind Class) {
    608   switch (Class) {
    609   case ARCInstKind::AutoreleasepoolPop:
    610   case ARCInstKind::CallOrUser:
    611   case ARCInstKind::Call:
    612   case ARCInstKind::Autorelease:
    613   case ARCInstKind::AutoreleaseRV:
    614   case ARCInstKind::FusedRetainAutorelease:
    615   case ARCInstKind::FusedRetainAutoreleaseRV:
    616     return true;
    617   case ARCInstKind::Retain:
    618   case ARCInstKind::RetainRV:
    619   case ARCInstKind::Release:
    620   case ARCInstKind::AutoreleasepoolPush:
    621   case ARCInstKind::RetainBlock:
    622   case ARCInstKind::LoadWeakRetained:
    623   case ARCInstKind::StoreWeak:
    624   case ARCInstKind::InitWeak:
    625   case ARCInstKind::LoadWeak:
    626   case ARCInstKind::MoveWeak:
    627   case ARCInstKind::CopyWeak:
    628   case ARCInstKind::DestroyWeak:
    629   case ARCInstKind::StoreStrong:
    630   case ARCInstKind::IntrinsicUser:
    631   case ARCInstKind::User:
    632   case ARCInstKind::None:
    633   case ARCInstKind::NoopCast:
    634     return false;
    635   }
    636   llvm_unreachable("covered switch isn't covered?");
    637 }
    638 
    639 bool llvm::objcarc::CanDecrementRefCount(ARCInstKind Kind) {
    640   switch (Kind) {
    641   case ARCInstKind::Retain:
    642   case ARCInstKind::RetainRV:
    643   case ARCInstKind::Autorelease:
    644   case ARCInstKind::AutoreleaseRV:
    645   case ARCInstKind::NoopCast:
    646   case ARCInstKind::FusedRetainAutorelease:
    647   case ARCInstKind::FusedRetainAutoreleaseRV:
    648   case ARCInstKind::IntrinsicUser:
    649   case ARCInstKind::User:
    650   case ARCInstKind::None:
    651     return false;
    652 
    653   // The cases below are conservative.
    654 
    655   // RetainBlock can result in user defined copy constructors being called
    656   // implying releases may occur.
    657   case ARCInstKind::RetainBlock:
    658   case ARCInstKind::Release:
    659   case ARCInstKind::AutoreleasepoolPush:
    660   case ARCInstKind::AutoreleasepoolPop:
    661   case ARCInstKind::LoadWeakRetained:
    662   case ARCInstKind::StoreWeak:
    663   case ARCInstKind::InitWeak:
    664   case ARCInstKind::LoadWeak:
    665   case ARCInstKind::MoveWeak:
    666   case ARCInstKind::CopyWeak:
    667   case ARCInstKind::DestroyWeak:
    668   case ARCInstKind::StoreStrong:
    669   case ARCInstKind::CallOrUser:
    670   case ARCInstKind::Call:
    671     return true;
    672   }
    673 
    674   llvm_unreachable("covered switch isn't covered?");
    675 }
    676