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