lib/Analysis/ObjCARCInstKind.cpp

   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 }