• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/Instructions.h"
14 #include "llvm/IR/Function.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 
58 raw_ostream &operator<<(raw_ostream &OS, const ARCInstKind Class);
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.
95 ARCInstKind GetFunctionClass(const Function *F);
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 ///
GetBasicARCInstKind(const Value * V)102 inline ARCInstKind GetBasicARCInstKind(const Value *V) {
103   if (const CallInst *CI = dyn_cast<CallInst>(V)) {
104     if (const Function *F = CI->getCalledFunction())
105       return GetFunctionClass(F);
106     // Otherwise, be conservative.
107     return ARCInstKind::CallOrUser;
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.
115 ARCInstKind GetARCInstKind(const Value *V);
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.
119 bool CanDecrementRefCount(ARCInstKind Kind);
120 
121 } // end namespace objcarc
122 } // end namespace llvm
123 
124 #endif
125