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
27 using namespace llvm;
28 using namespace llvm::objcarc;
29
operator <<(raw_ostream & OS,const ARCInstKind Class)30 raw_ostream &llvm::objcarc::operator<<(raw_ostream &OS,
31 const ARCInstKind Class) {
32 switch (Class) {
33 case ARCInstKind::Retain:
34 return OS << "ARCInstKind::Retain";
35 case ARCInstKind::RetainRV:
36 return OS << "ARCInstKind::RetainRV";
37 case ARCInstKind::ClaimRV:
38 return OS << "ARCInstKind::ClaimRV";
39 case ARCInstKind::RetainBlock:
40 return OS << "ARCInstKind::RetainBlock";
41 case ARCInstKind::Release:
42 return OS << "ARCInstKind::Release";
43 case ARCInstKind::Autorelease:
44 return OS << "ARCInstKind::Autorelease";
45 case ARCInstKind::AutoreleaseRV:
46 return OS << "ARCInstKind::AutoreleaseRV";
47 case ARCInstKind::AutoreleasepoolPush:
48 return OS << "ARCInstKind::AutoreleasepoolPush";
49 case ARCInstKind::AutoreleasepoolPop:
50 return OS << "ARCInstKind::AutoreleasepoolPop";
51 case ARCInstKind::NoopCast:
52 return OS << "ARCInstKind::NoopCast";
53 case ARCInstKind::FusedRetainAutorelease:
54 return OS << "ARCInstKind::FusedRetainAutorelease";
55 case ARCInstKind::FusedRetainAutoreleaseRV:
56 return OS << "ARCInstKind::FusedRetainAutoreleaseRV";
57 case ARCInstKind::LoadWeakRetained:
58 return OS << "ARCInstKind::LoadWeakRetained";
59 case ARCInstKind::StoreWeak:
60 return OS << "ARCInstKind::StoreWeak";
61 case ARCInstKind::InitWeak:
62 return OS << "ARCInstKind::InitWeak";
63 case ARCInstKind::LoadWeak:
64 return OS << "ARCInstKind::LoadWeak";
65 case ARCInstKind::MoveWeak:
66 return OS << "ARCInstKind::MoveWeak";
67 case ARCInstKind::CopyWeak:
68 return OS << "ARCInstKind::CopyWeak";
69 case ARCInstKind::DestroyWeak:
70 return OS << "ARCInstKind::DestroyWeak";
71 case ARCInstKind::StoreStrong:
72 return OS << "ARCInstKind::StoreStrong";
73 case ARCInstKind::CallOrUser:
74 return OS << "ARCInstKind::CallOrUser";
75 case ARCInstKind::Call:
76 return OS << "ARCInstKind::Call";
77 case ARCInstKind::User:
78 return OS << "ARCInstKind::User";
79 case ARCInstKind::IntrinsicUser:
80 return OS << "ARCInstKind::IntrinsicUser";
81 case ARCInstKind::None:
82 return OS << "ARCInstKind::None";
83 }
84 llvm_unreachable("Unknown instruction class!");
85 }
86
GetFunctionClass(const Function * F)87 ARCInstKind 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.
isInertIntrinsic(unsigned ID)179 static 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.
isUseOnlyIntrinsic(unsigned ID)216 static 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.
GetARCInstKind(const Value * V)232 ARCInstKind 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.
IsUser(ARCInstKind Class)330 bool 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.
IsRetain(ARCInstKind Class)364 bool 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.
IsAutorelease(ARCInstKind Class)400 bool 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.
IsForwarding(ARCInstKind Class)435 bool 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.
IsNoopOnNull(ARCInstKind Class)470 bool 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.
IsAlwaysTail(ARCInstKind Class)505 bool 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.
IsNeverTail(ARCInstKind Class)541 bool 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.
IsNoThrow(ARCInstKind Class)580 bool 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.
CanInterruptRV(ARCInstKind Class)619 bool 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
CanDecrementRefCount(ARCInstKind Kind)652 bool 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