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/ADT/StringSwitch.h"
23#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
24#include "llvm/IR/Intrinsics.h"
25
26using namespace llvm;
27using namespace llvm::objcarc;
28
29raw_ostream &llvm::objcarc::operator<<(raw_ostream &OS,
30                                       const ARCInstKind Class) {
31  switch (Class) {
32  case ARCInstKind::Retain:
33    return OS << "ARCInstKind::Retain";
34  case ARCInstKind::RetainRV:
35    return OS << "ARCInstKind::RetainRV";
36  case ARCInstKind::ClaimRV:
37    return OS << "ARCInstKind::ClaimRV";
38  case ARCInstKind::RetainBlock:
39    return OS << "ARCInstKind::RetainBlock";
40  case ARCInstKind::Release:
41    return OS << "ARCInstKind::Release";
42  case ARCInstKind::Autorelease:
43    return OS << "ARCInstKind::Autorelease";
44  case ARCInstKind::AutoreleaseRV:
45    return OS << "ARCInstKind::AutoreleaseRV";
46  case ARCInstKind::AutoreleasepoolPush:
47    return OS << "ARCInstKind::AutoreleasepoolPush";
48  case ARCInstKind::AutoreleasepoolPop:
49    return OS << "ARCInstKind::AutoreleasepoolPop";
50  case ARCInstKind::NoopCast:
51    return OS << "ARCInstKind::NoopCast";
52  case ARCInstKind::FusedRetainAutorelease:
53    return OS << "ARCInstKind::FusedRetainAutorelease";
54  case ARCInstKind::FusedRetainAutoreleaseRV:
55    return OS << "ARCInstKind::FusedRetainAutoreleaseRV";
56  case ARCInstKind::LoadWeakRetained:
57    return OS << "ARCInstKind::LoadWeakRetained";
58  case ARCInstKind::StoreWeak:
59    return OS << "ARCInstKind::StoreWeak";
60  case ARCInstKind::InitWeak:
61    return OS << "ARCInstKind::InitWeak";
62  case ARCInstKind::LoadWeak:
63    return OS << "ARCInstKind::LoadWeak";
64  case ARCInstKind::MoveWeak:
65    return OS << "ARCInstKind::MoveWeak";
66  case ARCInstKind::CopyWeak:
67    return OS << "ARCInstKind::CopyWeak";
68  case ARCInstKind::DestroyWeak:
69    return OS << "ARCInstKind::DestroyWeak";
70  case ARCInstKind::StoreStrong:
71    return OS << "ARCInstKind::StoreStrong";
72  case ARCInstKind::CallOrUser:
73    return OS << "ARCInstKind::CallOrUser";
74  case ARCInstKind::Call:
75    return OS << "ARCInstKind::Call";
76  case ARCInstKind::User:
77    return OS << "ARCInstKind::User";
78  case ARCInstKind::IntrinsicUser:
79    return OS << "ARCInstKind::IntrinsicUser";
80  case ARCInstKind::None:
81    return OS << "ARCInstKind::None";
82  }
83  llvm_unreachable("Unknown instruction class!");
84}
85
86ARCInstKind llvm::objcarc::GetFunctionClass(const Function *F) {
87
88  Intrinsic::ID ID = F->getIntrinsicID();
89  switch (ID) {
90  default:
91    return ARCInstKind::CallOrUser;
92  case Intrinsic::objc_autorelease:
93    return ARCInstKind::Autorelease;
94  case Intrinsic::objc_autoreleasePoolPop:
95    return ARCInstKind::AutoreleasepoolPop;
96  case Intrinsic::objc_autoreleasePoolPush:
97    return ARCInstKind::AutoreleasepoolPush;
98  case Intrinsic::objc_autoreleaseReturnValue:
99    return ARCInstKind::AutoreleaseRV;
100  case Intrinsic::objc_copyWeak:
101    return ARCInstKind::CopyWeak;
102  case Intrinsic::objc_destroyWeak:
103    return ARCInstKind::DestroyWeak;
104  case Intrinsic::objc_initWeak:
105    return ARCInstKind::InitWeak;
106  case Intrinsic::objc_loadWeak:
107    return ARCInstKind::LoadWeak;
108  case Intrinsic::objc_loadWeakRetained:
109    return ARCInstKind::LoadWeakRetained;
110  case Intrinsic::objc_moveWeak:
111    return ARCInstKind::MoveWeak;
112  case Intrinsic::objc_release:
113    return ARCInstKind::Release;
114  case Intrinsic::objc_retain:
115    return ARCInstKind::Retain;
116  case Intrinsic::objc_retainAutorelease:
117    return ARCInstKind::FusedRetainAutorelease;
118  case Intrinsic::objc_retainAutoreleaseReturnValue:
119    return ARCInstKind::FusedRetainAutoreleaseRV;
120  case Intrinsic::objc_retainAutoreleasedReturnValue:
121    return ARCInstKind::RetainRV;
122  case Intrinsic::objc_retainBlock:
123    return ARCInstKind::RetainBlock;
124  case Intrinsic::objc_storeStrong:
125    return ARCInstKind::StoreStrong;
126  case Intrinsic::objc_storeWeak:
127    return ARCInstKind::StoreWeak;
128  case Intrinsic::objc_clang_arc_use:
129    return ARCInstKind::IntrinsicUser;
130  case Intrinsic::objc_unsafeClaimAutoreleasedReturnValue:
131    return ARCInstKind::ClaimRV;
132  case Intrinsic::objc_retainedObject:
133    return ARCInstKind::NoopCast;
134  case Intrinsic::objc_unretainedObject:
135    return ARCInstKind::NoopCast;
136  case Intrinsic::objc_unretainedPointer:
137    return ARCInstKind::NoopCast;
138  case Intrinsic::objc_retain_autorelease:
139    return ARCInstKind::FusedRetainAutorelease;
140  case Intrinsic::objc_sync_enter:
141    return ARCInstKind::User;
142  case Intrinsic::objc_sync_exit:
143    return ARCInstKind::User;
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 whitelist of intrinsics that we know do not use objc pointers or decrement
157// ref counts.
158static 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 whitelist of intrinsics that we know do not use objc pointers or decrement
196// ref counts.
197static 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.
213ARCInstKind 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 (User::const_op_iterator OI = I->op_begin(), OE = I->op_end();
300           OI != OE; ++OI)
301        if (IsPotentialRetainableObjPtr(*OI))
302          return ARCInstKind::User;
303    }
304  }
305
306  // Otherwise, it's totally inert for ARC purposes.
307  return ARCInstKind::None;
308}
309
310/// Test if the given class is a kind of user.
311bool llvm::objcarc::IsUser(ARCInstKind Class) {
312  switch (Class) {
313  case ARCInstKind::User:
314  case ARCInstKind::CallOrUser:
315  case ARCInstKind::IntrinsicUser:
316    return true;
317  case ARCInstKind::Retain:
318  case ARCInstKind::RetainRV:
319  case ARCInstKind::RetainBlock:
320  case ARCInstKind::Release:
321  case ARCInstKind::Autorelease:
322  case ARCInstKind::AutoreleaseRV:
323  case ARCInstKind::AutoreleasepoolPush:
324  case ARCInstKind::AutoreleasepoolPop:
325  case ARCInstKind::NoopCast:
326  case ARCInstKind::FusedRetainAutorelease:
327  case ARCInstKind::FusedRetainAutoreleaseRV:
328  case ARCInstKind::LoadWeakRetained:
329  case ARCInstKind::StoreWeak:
330  case ARCInstKind::InitWeak:
331  case ARCInstKind::LoadWeak:
332  case ARCInstKind::MoveWeak:
333  case ARCInstKind::CopyWeak:
334  case ARCInstKind::DestroyWeak:
335  case ARCInstKind::StoreStrong:
336  case ARCInstKind::Call:
337  case ARCInstKind::None:
338  case ARCInstKind::ClaimRV:
339    return false;
340  }
341  llvm_unreachable("covered switch isn't covered?");
342}
343
344/// Test if the given class is objc_retain or equivalent.
345bool llvm::objcarc::IsRetain(ARCInstKind Class) {
346  switch (Class) {
347  case ARCInstKind::Retain:
348  case ARCInstKind::RetainRV:
349    return true;
350  // I believe we treat retain block as not a retain since it can copy its
351  // block.
352  case ARCInstKind::RetainBlock:
353  case ARCInstKind::Release:
354  case ARCInstKind::Autorelease:
355  case ARCInstKind::AutoreleaseRV:
356  case ARCInstKind::AutoreleasepoolPush:
357  case ARCInstKind::AutoreleasepoolPop:
358  case ARCInstKind::NoopCast:
359  case ARCInstKind::FusedRetainAutorelease:
360  case ARCInstKind::FusedRetainAutoreleaseRV:
361  case ARCInstKind::LoadWeakRetained:
362  case ARCInstKind::StoreWeak:
363  case ARCInstKind::InitWeak:
364  case ARCInstKind::LoadWeak:
365  case ARCInstKind::MoveWeak:
366  case ARCInstKind::CopyWeak:
367  case ARCInstKind::DestroyWeak:
368  case ARCInstKind::StoreStrong:
369  case ARCInstKind::IntrinsicUser:
370  case ARCInstKind::CallOrUser:
371  case ARCInstKind::Call:
372  case ARCInstKind::User:
373  case ARCInstKind::None:
374  case ARCInstKind::ClaimRV:
375    return false;
376  }
377  llvm_unreachable("covered switch isn't covered?");
378}
379
380/// Test if the given class is objc_autorelease or equivalent.
381bool llvm::objcarc::IsAutorelease(ARCInstKind Class) {
382  switch (Class) {
383  case ARCInstKind::Autorelease:
384  case ARCInstKind::AutoreleaseRV:
385    return true;
386  case ARCInstKind::Retain:
387  case ARCInstKind::RetainRV:
388  case ARCInstKind::ClaimRV:
389  case ARCInstKind::RetainBlock:
390  case ARCInstKind::Release:
391  case ARCInstKind::AutoreleasepoolPush:
392  case ARCInstKind::AutoreleasepoolPop:
393  case ARCInstKind::NoopCast:
394  case ARCInstKind::FusedRetainAutorelease:
395  case ARCInstKind::FusedRetainAutoreleaseRV:
396  case ARCInstKind::LoadWeakRetained:
397  case ARCInstKind::StoreWeak:
398  case ARCInstKind::InitWeak:
399  case ARCInstKind::LoadWeak:
400  case ARCInstKind::MoveWeak:
401  case ARCInstKind::CopyWeak:
402  case ARCInstKind::DestroyWeak:
403  case ARCInstKind::StoreStrong:
404  case ARCInstKind::IntrinsicUser:
405  case ARCInstKind::CallOrUser:
406  case ARCInstKind::Call:
407  case ARCInstKind::User:
408  case ARCInstKind::None:
409    return false;
410  }
411  llvm_unreachable("covered switch isn't covered?");
412}
413
414/// Test if the given class represents instructions which return their
415/// argument verbatim.
416bool llvm::objcarc::IsForwarding(ARCInstKind Class) {
417  switch (Class) {
418  case ARCInstKind::Retain:
419  case ARCInstKind::RetainRV:
420  case ARCInstKind::ClaimRV:
421  case ARCInstKind::Autorelease:
422  case ARCInstKind::AutoreleaseRV:
423  case ARCInstKind::NoopCast:
424    return true;
425  case ARCInstKind::RetainBlock:
426  case ARCInstKind::Release:
427  case ARCInstKind::AutoreleasepoolPush:
428  case ARCInstKind::AutoreleasepoolPop:
429  case ARCInstKind::FusedRetainAutorelease:
430  case ARCInstKind::FusedRetainAutoreleaseRV:
431  case ARCInstKind::LoadWeakRetained:
432  case ARCInstKind::StoreWeak:
433  case ARCInstKind::InitWeak:
434  case ARCInstKind::LoadWeak:
435  case ARCInstKind::MoveWeak:
436  case ARCInstKind::CopyWeak:
437  case ARCInstKind::DestroyWeak:
438  case ARCInstKind::StoreStrong:
439  case ARCInstKind::IntrinsicUser:
440  case ARCInstKind::CallOrUser:
441  case ARCInstKind::Call:
442  case ARCInstKind::User:
443  case ARCInstKind::None:
444    return false;
445  }
446  llvm_unreachable("covered switch isn't covered?");
447}
448
449/// Test if the given class represents instructions which do nothing if
450/// passed a null pointer.
451bool llvm::objcarc::IsNoopOnNull(ARCInstKind Class) {
452  switch (Class) {
453  case ARCInstKind::Retain:
454  case ARCInstKind::RetainRV:
455  case ARCInstKind::ClaimRV:
456  case ARCInstKind::Release:
457  case ARCInstKind::Autorelease:
458  case ARCInstKind::AutoreleaseRV:
459  case ARCInstKind::RetainBlock:
460    return true;
461  case ARCInstKind::AutoreleasepoolPush:
462  case ARCInstKind::AutoreleasepoolPop:
463  case ARCInstKind::FusedRetainAutorelease:
464  case ARCInstKind::FusedRetainAutoreleaseRV:
465  case ARCInstKind::LoadWeakRetained:
466  case ARCInstKind::StoreWeak:
467  case ARCInstKind::InitWeak:
468  case ARCInstKind::LoadWeak:
469  case ARCInstKind::MoveWeak:
470  case ARCInstKind::CopyWeak:
471  case ARCInstKind::DestroyWeak:
472  case ARCInstKind::StoreStrong:
473  case ARCInstKind::IntrinsicUser:
474  case ARCInstKind::CallOrUser:
475  case ARCInstKind::Call:
476  case ARCInstKind::User:
477  case ARCInstKind::None:
478  case ARCInstKind::NoopCast:
479    return false;
480  }
481  llvm_unreachable("covered switch isn't covered?");
482}
483
484/// Test if the given class represents instructions which do nothing if
485/// passed a global variable.
486bool llvm::objcarc::IsNoopOnGlobal(ARCInstKind Class) {
487  switch (Class) {
488  case ARCInstKind::Retain:
489  case ARCInstKind::RetainRV:
490  case ARCInstKind::ClaimRV:
491  case ARCInstKind::Release:
492  case ARCInstKind::Autorelease:
493  case ARCInstKind::AutoreleaseRV:
494  case ARCInstKind::RetainBlock:
495  case ARCInstKind::FusedRetainAutorelease:
496  case ARCInstKind::FusedRetainAutoreleaseRV:
497    return true;
498  case ARCInstKind::AutoreleasepoolPush:
499  case ARCInstKind::AutoreleasepoolPop:
500  case ARCInstKind::LoadWeakRetained:
501  case ARCInstKind::StoreWeak:
502  case ARCInstKind::InitWeak:
503  case ARCInstKind::LoadWeak:
504  case ARCInstKind::MoveWeak:
505  case ARCInstKind::CopyWeak:
506  case ARCInstKind::DestroyWeak:
507  case ARCInstKind::StoreStrong:
508  case ARCInstKind::IntrinsicUser:
509  case ARCInstKind::CallOrUser:
510  case ARCInstKind::Call:
511  case ARCInstKind::User:
512  case ARCInstKind::None:
513  case ARCInstKind::NoopCast:
514    return false;
515  }
516  llvm_unreachable("covered switch isn't covered?");
517}
518
519/// Test if the given class represents instructions which are always safe
520/// to mark with the "tail" keyword.
521bool llvm::objcarc::IsAlwaysTail(ARCInstKind Class) {
522  // ARCInstKind::RetainBlock may be given a stack argument.
523  switch (Class) {
524  case ARCInstKind::Retain:
525  case ARCInstKind::RetainRV:
526  case ARCInstKind::ClaimRV:
527  case ARCInstKind::AutoreleaseRV:
528    return true;
529  case ARCInstKind::Release:
530  case ARCInstKind::Autorelease:
531  case ARCInstKind::RetainBlock:
532  case ARCInstKind::AutoreleasepoolPush:
533  case ARCInstKind::AutoreleasepoolPop:
534  case ARCInstKind::FusedRetainAutorelease:
535  case ARCInstKind::FusedRetainAutoreleaseRV:
536  case ARCInstKind::LoadWeakRetained:
537  case ARCInstKind::StoreWeak:
538  case ARCInstKind::InitWeak:
539  case ARCInstKind::LoadWeak:
540  case ARCInstKind::MoveWeak:
541  case ARCInstKind::CopyWeak:
542  case ARCInstKind::DestroyWeak:
543  case ARCInstKind::StoreStrong:
544  case ARCInstKind::IntrinsicUser:
545  case ARCInstKind::CallOrUser:
546  case ARCInstKind::Call:
547  case ARCInstKind::User:
548  case ARCInstKind::None:
549  case ARCInstKind::NoopCast:
550    return false;
551  }
552  llvm_unreachable("covered switch isn't covered?");
553}
554
555/// Test if the given class represents instructions which are never safe
556/// to mark with the "tail" keyword.
557bool llvm::objcarc::IsNeverTail(ARCInstKind Class) {
558  /// It is never safe to tail call objc_autorelease since by tail calling
559  /// objc_autorelease: fast autoreleasing causing our object to be potentially
560  /// reclaimed from the autorelease pool which violates the semantics of
561  /// __autoreleasing types in ARC.
562  switch (Class) {
563  case ARCInstKind::Autorelease:
564    return true;
565  case ARCInstKind::Retain:
566  case ARCInstKind::RetainRV:
567  case ARCInstKind::ClaimRV:
568  case ARCInstKind::AutoreleaseRV:
569  case ARCInstKind::Release:
570  case ARCInstKind::RetainBlock:
571  case ARCInstKind::AutoreleasepoolPush:
572  case ARCInstKind::AutoreleasepoolPop:
573  case ARCInstKind::FusedRetainAutorelease:
574  case ARCInstKind::FusedRetainAutoreleaseRV:
575  case ARCInstKind::LoadWeakRetained:
576  case ARCInstKind::StoreWeak:
577  case ARCInstKind::InitWeak:
578  case ARCInstKind::LoadWeak:
579  case ARCInstKind::MoveWeak:
580  case ARCInstKind::CopyWeak:
581  case ARCInstKind::DestroyWeak:
582  case ARCInstKind::StoreStrong:
583  case ARCInstKind::IntrinsicUser:
584  case ARCInstKind::CallOrUser:
585  case ARCInstKind::Call:
586  case ARCInstKind::User:
587  case ARCInstKind::None:
588  case ARCInstKind::NoopCast:
589    return false;
590  }
591  llvm_unreachable("covered switch isn't covered?");
592}
593
594/// Test if the given class represents instructions which are always safe
595/// to mark with the nounwind attribute.
596bool llvm::objcarc::IsNoThrow(ARCInstKind Class) {
597  // objc_retainBlock is not nounwind because it calls user copy constructors
598  // which could theoretically throw.
599  switch (Class) {
600  case ARCInstKind::Retain:
601  case ARCInstKind::RetainRV:
602  case ARCInstKind::ClaimRV:
603  case ARCInstKind::Release:
604  case ARCInstKind::Autorelease:
605  case ARCInstKind::AutoreleaseRV:
606  case ARCInstKind::AutoreleasepoolPush:
607  case ARCInstKind::AutoreleasepoolPop:
608    return true;
609  case ARCInstKind::RetainBlock:
610  case ARCInstKind::FusedRetainAutorelease:
611  case ARCInstKind::FusedRetainAutoreleaseRV:
612  case ARCInstKind::LoadWeakRetained:
613  case ARCInstKind::StoreWeak:
614  case ARCInstKind::InitWeak:
615  case ARCInstKind::LoadWeak:
616  case ARCInstKind::MoveWeak:
617  case ARCInstKind::CopyWeak:
618  case ARCInstKind::DestroyWeak:
619  case ARCInstKind::StoreStrong:
620  case ARCInstKind::IntrinsicUser:
621  case ARCInstKind::CallOrUser:
622  case ARCInstKind::Call:
623  case ARCInstKind::User:
624  case ARCInstKind::None:
625  case ARCInstKind::NoopCast:
626    return false;
627  }
628  llvm_unreachable("covered switch isn't covered?");
629}
630
631/// Test whether the given instruction can autorelease any pointer or cause an
632/// autoreleasepool pop.
633///
634/// This means that it *could* interrupt the RV optimization.
635bool llvm::objcarc::CanInterruptRV(ARCInstKind Class) {
636  switch (Class) {
637  case ARCInstKind::AutoreleasepoolPop:
638  case ARCInstKind::CallOrUser:
639  case ARCInstKind::Call:
640  case ARCInstKind::Autorelease:
641  case ARCInstKind::AutoreleaseRV:
642  case ARCInstKind::FusedRetainAutorelease:
643  case ARCInstKind::FusedRetainAutoreleaseRV:
644    return true;
645  case ARCInstKind::Retain:
646  case ARCInstKind::RetainRV:
647  case ARCInstKind::ClaimRV:
648  case ARCInstKind::Release:
649  case ARCInstKind::AutoreleasepoolPush:
650  case ARCInstKind::RetainBlock:
651  case ARCInstKind::LoadWeakRetained:
652  case ARCInstKind::StoreWeak:
653  case ARCInstKind::InitWeak:
654  case ARCInstKind::LoadWeak:
655  case ARCInstKind::MoveWeak:
656  case ARCInstKind::CopyWeak:
657  case ARCInstKind::DestroyWeak:
658  case ARCInstKind::StoreStrong:
659  case ARCInstKind::IntrinsicUser:
660  case ARCInstKind::User:
661  case ARCInstKind::None:
662  case ARCInstKind::NoopCast:
663    return false;
664  }
665  llvm_unreachable("covered switch isn't covered?");
666}
667
668bool llvm::objcarc::CanDecrementRefCount(ARCInstKind Kind) {
669  switch (Kind) {
670  case ARCInstKind::Retain:
671  case ARCInstKind::RetainRV:
672  case ARCInstKind::Autorelease:
673  case ARCInstKind::AutoreleaseRV:
674  case ARCInstKind::NoopCast:
675  case ARCInstKind::FusedRetainAutorelease:
676  case ARCInstKind::FusedRetainAutoreleaseRV:
677  case ARCInstKind::IntrinsicUser:
678  case ARCInstKind::User:
679  case ARCInstKind::None:
680    return false;
681
682  // The cases below are conservative.
683
684  // RetainBlock can result in user defined copy constructors being called
685  // implying releases may occur.
686  case ARCInstKind::RetainBlock:
687  case ARCInstKind::Release:
688  case ARCInstKind::AutoreleasepoolPush:
689  case ARCInstKind::AutoreleasepoolPop:
690  case ARCInstKind::LoadWeakRetained:
691  case ARCInstKind::StoreWeak:
692  case ARCInstKind::InitWeak:
693  case ARCInstKind::LoadWeak:
694  case ARCInstKind::MoveWeak:
695  case ARCInstKind::CopyWeak:
696  case ARCInstKind::DestroyWeak:
697  case ARCInstKind::StoreStrong:
698  case ARCInstKind::CallOrUser:
699  case ARCInstKind::Call:
700  case ARCInstKind::ClaimRV:
701    return true;
702  }
703
704  llvm_unreachable("covered switch isn't covered?");
705}
706