llvm/lib/Analysis/ObjCARCInstKind.cpp

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