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