1 //===--- PtrState.h - ARC State for a Ptr -------------------*- C++ -*-----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains declarations for the ARC state associated with a ptr. It
11 // is only used by the ARC Sequence Dataflow computation. By separating this
12 // from the actual dataflow, it is easier to consider the mechanics of the ARC
13 // optimization separate from the actual predicates being used.
15 //===----------------------------------------------------------------------===//
17 #ifndef LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H
18 #define LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H
20 #include "ARCInstKind.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/IR/Instruction.h"
23 #include "llvm/IR/Value.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include "llvm/Support/Debug.h"
31 class ProvenanceAnalysis;
35 /// \brief A sequence of states that a pointer may go through in which an
36 /// objc_retain and objc_release are actually needed.
39 S_Retain, ///< objc_retain(x).
40 S_CanRelease, ///< foo(x) -- x could possibly see a ref count decrement.
41 S_Use, ///< any use of x.
42 S_Stop, ///< like S_Release, but code motion is stopped.
43 S_Release, ///< objc_release(x).
44 S_MovableRelease ///< objc_release(x), !clang.imprecise_release.
47 raw_ostream &operator<<(raw_ostream &OS,
48 const Sequence S) LLVM_ATTRIBUTE_UNUSED;
50 /// \brief Unidirectional information about either a
51 /// retain-decrement-use-release sequence or release-use-decrement-retain
54 /// After an objc_retain, the reference count of the referenced
55 /// object is known to be positive. Similarly, before an objc_release, the
56 /// reference count of the referenced object is known to be positive. If
57 /// there are retain-release pairs in code regions where the retain count
58 /// is known to be positive, they can be eliminated, regardless of any side
59 /// effects between them.
61 /// Also, a retain+release pair nested within another retain+release
62 /// pair all on the known same pointer value can be eliminated, regardless
63 /// of any intervening side effects.
65 /// KnownSafe is true when either of these conditions is satisfied.
68 /// True of the objc_release calls are all marked with the "tail" keyword.
69 bool IsTailCallRelease;
71 /// If the Calls are objc_release calls and they all have a
72 /// clang.imprecise_release tag, this is the metadata tag.
73 MDNode *ReleaseMetadata;
75 /// For a top-down sequence, the set of objc_retains or
76 /// objc_retainBlocks. For bottom-up, the set of objc_releases.
77 SmallPtrSet<Instruction *, 2> Calls;
79 /// The set of optimal insert positions for moving calls in the opposite
81 SmallPtrSet<Instruction *, 2> ReverseInsertPts;
83 /// If this is true, we cannot perform code motion but can still remove
84 /// retain/release pairs.
85 bool CFGHazardAfflicted;
88 : KnownSafe(false), IsTailCallRelease(false), ReleaseMetadata(nullptr),
89 CFGHazardAfflicted(false) {}
93 /// Conservatively merge the two RRInfo. Returns true if a partial merge has
94 /// occurred, false otherwise.
95 bool Merge(const RRInfo &Other);
98 /// \brief This class summarizes several per-pointer runtime properties which
99 /// are propagated through the flow graph.
102 /// True if the reference count is known to be incremented.
103 bool KnownPositiveRefCount;
105 /// True if we've seen an opportunity for partial RR elimination, such as
106 /// pushing calls into a CFG triangle or into one side of a CFG diamond.
109 /// The current position in the sequence.
110 unsigned char Seq : 8;
112 /// Unidirectional information about the current sequence.
115 PtrState() : KnownPositiveRefCount(false), Partial(false), Seq(S_None) {}
118 bool IsKnownSafe() const { return RRI.KnownSafe; }
120 void SetKnownSafe(const bool NewValue) { RRI.KnownSafe = NewValue; }
122 bool IsTailCallRelease() const { return RRI.IsTailCallRelease; }
124 void SetTailCallRelease(const bool NewValue) {
125 RRI.IsTailCallRelease = NewValue;
128 bool IsTrackingImpreciseReleases() const {
129 return RRI.ReleaseMetadata != nullptr;
132 const MDNode *GetReleaseMetadata() const { return RRI.ReleaseMetadata; }
134 void SetReleaseMetadata(MDNode *NewValue) { RRI.ReleaseMetadata = NewValue; }
136 bool IsCFGHazardAfflicted() const { return RRI.CFGHazardAfflicted; }
138 void SetCFGHazardAfflicted(const bool NewValue) {
139 RRI.CFGHazardAfflicted = NewValue;
142 void SetKnownPositiveRefCount();
143 void ClearKnownPositiveRefCount();
145 bool HasKnownPositiveRefCount() const { return KnownPositiveRefCount; }
147 void SetSeq(Sequence NewSeq);
149 Sequence GetSeq() const { return static_cast<Sequence>(Seq); }
151 void ClearSequenceProgress() { ResetSequenceProgress(S_None); }
153 void ResetSequenceProgress(Sequence NewSeq);
154 void Merge(const PtrState &Other, bool TopDown);
156 void InsertCall(Instruction *I) { RRI.Calls.insert(I); }
158 void InsertReverseInsertPt(Instruction *I) { RRI.ReverseInsertPts.insert(I); }
160 void ClearReverseInsertPts() { RRI.ReverseInsertPts.clear(); }
162 bool HasReverseInsertPts() const { return !RRI.ReverseInsertPts.empty(); }
164 const RRInfo &GetRRInfo() const { return RRI; }
167 struct BottomUpPtrState : PtrState {
168 BottomUpPtrState() : PtrState() {}
170 /// (Re-)Initialize this bottom up pointer returning true if we detected a
171 /// pointer with nested releases.
172 bool InitBottomUp(ARCMDKindCache &Cache, Instruction *I);
174 /// Return true if this set of releases can be paired with a release. Modifies
175 /// state appropriately to reflect that the matching occurred if it is
178 /// It is assumed that one has already checked that the RCIdentity of the
179 /// retain and the RCIdentity of this ptr state are the same.
180 bool MatchWithRetain();
182 void HandlePotentialUse(BasicBlock *BB, Instruction *Inst, const Value *Ptr,
183 ProvenanceAnalysis &PA, ARCInstKind Class);
184 bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr,
185 ProvenanceAnalysis &PA, ARCInstKind Class);
188 struct TopDownPtrState : PtrState {
189 TopDownPtrState() : PtrState() {}
191 /// (Re-)Initialize this bottom up pointer returning true if we detected a
192 /// pointer with nested releases.
193 bool InitTopDown(ARCInstKind Kind, Instruction *I);
195 /// Return true if this set of retains can be paired with the given
196 /// release. Modifies state appropriately to reflect that the matching
198 bool MatchWithRelease(ARCMDKindCache &Cache, Instruction *Release);
200 void HandlePotentialUse(Instruction *Inst, const Value *Ptr,
201 ProvenanceAnalysis &PA, ARCInstKind Class);
203 bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr,
204 ProvenanceAnalysis &PA, ARCInstKind Class);
207 } // end namespace objcarc
208 } // end namespace llvm