xref: /freebsd/contrib/llvm-project/llvm/lib/Analysis/ObjCARCInstKind.cpp (revision 2f513db72b034fd5ef7f080b11be5c711c15186a) 
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 
26 using namespace llvm;
27 using namespace llvm::objcarc;
28 
29 raw_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 
86 ARCInstKind 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.
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 whitelist 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 (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.
311 bool 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.
345 bool 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.
381 bool 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.
416 bool 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.
451 bool 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.
486 bool 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.
521 bool 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.
557 bool 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.
596 bool 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.
635 bool 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 
668 bool 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