LLVM  6.0.0svn
ObjCARCInstKind.h
Go to the documentation of this file.
1 //===- ObjCARCInstKind.h - ARC instruction equivalence classes --*- C++ -*-===//
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 
10 #ifndef LLVM_ANALYSIS_OBJCARCINSTKIND_H
11 #define LLVM_ANALYSIS_OBJCARCINSTKIND_H
12 
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/Instructions.h"
15 
16 namespace llvm {
17 namespace objcarc {
18 
19 /// \enum ARCInstKind
20 ///
21 /// \brief Equivalence classes of instructions in the ARC Model.
22 ///
23 /// Since we do not have "instructions" to represent ARC concepts in LLVM IR,
24 /// we instead operate on equivalence classes of instructions.
25 ///
26 /// TODO: This should be split into two enums: a runtime entry point enum
27 /// (possibly united with the ARCRuntimeEntrypoint class) and an enum that deals
28 /// with effects of instructions in the ARC model (which would handle the notion
29 /// of a User or CallOrUser).
30 enum class ARCInstKind {
31  Retain, ///< objc_retain
32  RetainRV, ///< objc_retainAutoreleasedReturnValue
33  ClaimRV, ///< objc_unsafeClaimAutoreleasedReturnValue
34  RetainBlock, ///< objc_retainBlock
35  Release, ///< objc_release
36  Autorelease, ///< objc_autorelease
37  AutoreleaseRV, ///< objc_autoreleaseReturnValue
38  AutoreleasepoolPush, ///< objc_autoreleasePoolPush
39  AutoreleasepoolPop, ///< objc_autoreleasePoolPop
40  NoopCast, ///< objc_retainedObject, etc.
41  FusedRetainAutorelease, ///< objc_retainAutorelease
42  FusedRetainAutoreleaseRV, ///< objc_retainAutoreleaseReturnValue
43  LoadWeakRetained, ///< objc_loadWeakRetained (primitive)
44  StoreWeak, ///< objc_storeWeak (primitive)
45  InitWeak, ///< objc_initWeak (derived)
46  LoadWeak, ///< objc_loadWeak (derived)
47  MoveWeak, ///< objc_moveWeak (derived)
48  CopyWeak, ///< objc_copyWeak (derived)
49  DestroyWeak, ///< objc_destroyWeak (derived)
50  StoreStrong, ///< objc_storeStrong (derived)
51  IntrinsicUser, ///< clang.arc.use
52  CallOrUser, ///< could call objc_release and/or "use" pointers
53  Call, ///< could call objc_release
54  User, ///< could "use" a pointer
55  None ///< anything that is inert from an ARC perspective.
56 };
57 
59 
60 /// \brief Test if the given class is a kind of user.
61 bool IsUser(ARCInstKind Class);
62 
63 /// \brief Test if the given class is objc_retain or equivalent.
64 bool IsRetain(ARCInstKind Class);
65 
66 /// \brief Test if the given class is objc_autorelease or equivalent.
67 bool IsAutorelease(ARCInstKind Class);
68 
69 /// \brief Test if the given class represents instructions which return their
70 /// argument verbatim.
71 bool IsForwarding(ARCInstKind Class);
72 
73 /// \brief Test if the given class represents instructions which do nothing if
74 /// passed a null pointer.
75 bool IsNoopOnNull(ARCInstKind Class);
76 
77 /// \brief Test if the given class represents instructions which are always safe
78 /// to mark with the "tail" keyword.
79 bool IsAlwaysTail(ARCInstKind Class);
80 
81 /// \brief Test if the given class represents instructions which are never safe
82 /// to mark with the "tail" keyword.
83 bool IsNeverTail(ARCInstKind Class);
84 
85 /// \brief Test if the given class represents instructions which are always safe
86 /// to mark with the nounwind attribute.
87 bool IsNoThrow(ARCInstKind Class);
88 
89 /// Test whether the given instruction can autorelease any pointer or cause an
90 /// autoreleasepool pop.
91 bool CanInterruptRV(ARCInstKind Class);
92 
93 /// \brief Determine if F is one of the special known Functions. If it isn't,
94 /// return ARCInstKind::CallOrUser.
96 
97 /// \brief Determine which objc runtime call instruction class V belongs to.
98 ///
99 /// This is similar to GetARCInstKind except that it only detects objc
100 /// runtime calls. This allows it to be faster.
101 ///
103  if (const CallInst *CI = dyn_cast<CallInst>(V)) {
104  if (const Function *F = CI->getCalledFunction())
105  return GetFunctionClass(F);
106  // Otherwise, be conservative.
108  }
109 
110  // Otherwise, be conservative.
111  return isa<InvokeInst>(V) ? ARCInstKind::CallOrUser : ARCInstKind::User;
112 }
113 
114 /// Map V to its ARCInstKind equivalence class.
116 
117 /// Returns false if conservatively we can prove that any instruction mapped to
118 /// this kind can not decrement ref counts. Returns true otherwise.
120 
121 } // end namespace objcarc
122 } // end namespace llvm
123 
124 #endif
ARCInstKind GetARCInstKind(const Value *V)
Map V to its ARCInstKind equivalence class.
objc_destroyWeak (derived)
bool IsUser(ARCInstKind Class)
Test if the given class is a kind of user.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
objc_loadWeakRetained (primitive)
could call objc_release and/or "use" pointers
objc_loadWeak (derived)
This class represents a function call, abstracting a target machine&#39;s calling convention.
objc_retainedObject, etc.
F(f)
could call objc_release
objc_moveWeak (derived)
bool IsNoopOnNull(ARCInstKind Class)
Test if the given class represents instructions which do nothing if passed a null pointer...
bool IsForwarding(ARCInstKind Class)
Test if the given class represents instructions which return their argument verbatim.
objc_autoreleaseReturnValue
objc_retainAutoreleasedReturnValue
bool IsAlwaysTail(ARCInstKind Class)
Test if the given class represents instructions which are always safe to mark with the "tail" keyword...
raw_ostream & operator<<(raw_ostream &OS, const ARCInstKind Class)
objc_initWeak (derived)
ARCInstKind GetFunctionClass(const Function *F)
Determine if F is one of the special known Functions.
objc_copyWeak (derived)
anything that is inert from an ARC perspective.
ARCInstKind GetBasicARCInstKind(const Value *V)
Determine which objc runtime call instruction class V belongs to.
bool CanDecrementRefCount(ARCInstKind Kind)
Returns false if conservatively we can prove that any instruction mapped to this kind can not decreme...
ARCInstKind
Equivalence classes of instructions in the ARC Model.
bool IsNoThrow(ARCInstKind Class)
Test if the given class represents instructions which are always safe to mark with the nounwind attri...
objc_unsafeClaimAutoreleasedReturnValue
objc_storeStrong (derived)
could "use" a pointer
bool IsRetain(ARCInstKind Class)
Test if the given class is objc_retain or equivalent.
objc_storeWeak (primitive)
const unsigned Kind
LLVM Value Representation.
Definition: Value.h:73
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
bool CanInterruptRV(ARCInstKind Class)
Test whether the given instruction can autorelease any pointer or cause an autoreleasepool pop...
bool IsNeverTail(ARCInstKind Class)
Test if the given class represents instructions which are never safe to mark with the "tail" keyword...
bool IsAutorelease(ARCInstKind Class)
Test if the given class is objc_autorelease or equivalent.