LLVM 17.0.0git
PtrState.h
Go to the documentation of this file.
1//===- PtrState.h - ARC State for a Ptr -------------------------*- C++ -*-===//
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//
9// This file contains declarations for the ARC state associated with a ptr. It
10// is only used by the ARC Sequence Dataflow computation. By separating this
11// from the actual dataflow, it is easier to consider the mechanics of the ARC
12// optimization separate from the actual predicates being used.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H
17#define LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H
18
22
23namespace llvm {
24
25class BasicBlock;
26class Instruction;
27class MDNode;
28class raw_ostream;
29class Value;
30
31namespace objcarc {
32
33class ARCMDKindCache;
34class BundledRetainClaimRVs;
35class ProvenanceAnalysis;
36
37/// \enum Sequence
38///
39/// A sequence of states that a pointer may go through in which an
40/// objc_retain and objc_release are actually needed.
43 S_Retain, ///< objc_retain(x).
44 S_CanRelease, ///< foo(x) -- x could possibly see a ref count decrement.
45 S_Use, ///< any use of x.
46 S_Stop, ///< code motion is stopped.
47 S_MovableRelease ///< objc_release(x), !clang.imprecise_release.
48};
49
52
53/// Unidirectional information about either a
54/// retain-decrement-use-release sequence or release-use-decrement-retain
55/// reverse sequence.
56struct RRInfo {
57 /// After an objc_retain, the reference count of the referenced
58 /// object is known to be positive. Similarly, before an objc_release, the
59 /// reference count of the referenced object is known to be positive. If
60 /// there are retain-release pairs in code regions where the retain count
61 /// is known to be positive, they can be eliminated, regardless of any side
62 /// effects between them.
63 ///
64 /// Also, a retain+release pair nested within another retain+release
65 /// pair all on the known same pointer value can be eliminated, regardless
66 /// of any intervening side effects.
67 ///
68 /// KnownSafe is true when either of these conditions is satisfied.
69 bool KnownSafe = false;
70
71 /// True of the objc_release calls are all marked with the "tail" keyword.
72 bool IsTailCallRelease = false;
73
74 /// If the Calls are objc_release calls and they all have a
75 /// clang.imprecise_release tag, this is the metadata tag.
77
78 /// For a top-down sequence, the set of objc_retains or
79 /// objc_retainBlocks. For bottom-up, the set of objc_releases.
81
82 /// The set of optimal insert positions for moving calls in the opposite
83 /// sequence.
85
86 /// If this is true, we cannot perform code motion but can still remove
87 /// retain/release pairs.
88 bool CFGHazardAfflicted = false;
89
90 RRInfo() = default;
91
92 void clear();
93
94 /// Conservatively merge the two RRInfo. Returns true if a partial merge has
95 /// occurred, false otherwise.
96 bool Merge(const RRInfo &Other);
97};
98
99/// This class summarizes several per-pointer runtime properties which
100/// are propagated through the flow graph.
101class PtrState {
102protected:
103 /// True if the reference count is known to be incremented.
105
106 /// True if we've seen an opportunity for partial RR elimination, such as
107 /// pushing calls into a CFG triangle or into one side of a CFG diamond.
108 bool Partial = false;
109
110 /// The current position in the sequence.
111 unsigned char Seq : 8;
112
113 /// Unidirectional information about the current sequence.
115
117
118public:
119 bool IsKnownSafe() const { return RRI.KnownSafe; }
120
121 void SetKnownSafe(const bool NewValue) { RRI.KnownSafe = NewValue; }
122
123 bool IsTailCallRelease() const { return RRI.IsTailCallRelease; }
124
125 void SetTailCallRelease(const bool NewValue) {
126 RRI.IsTailCallRelease = NewValue;
127 }
128
130 return RRI.ReleaseMetadata != nullptr;
131 }
132
133 const MDNode *GetReleaseMetadata() const { return RRI.ReleaseMetadata; }
134
135 void SetReleaseMetadata(MDNode *NewValue) { RRI.ReleaseMetadata = NewValue; }
136
138
139 void SetCFGHazardAfflicted(const bool NewValue) {
140 RRI.CFGHazardAfflicted = NewValue;
141 }
142
145
147
148 void SetSeq(Sequence NewSeq);
149
150 Sequence GetSeq() const { return static_cast<Sequence>(Seq); }
151
153
154 void ResetSequenceProgress(Sequence NewSeq);
155 void Merge(const PtrState &Other, bool TopDown);
156
157 void InsertCall(Instruction *I) { RRI.Calls.insert(I); }
158
160
162
163 bool HasReverseInsertPts() const { return !RRI.ReverseInsertPts.empty(); }
164
165 const RRInfo &GetRRInfo() const { return RRI; }
166};
167
169 BottomUpPtrState() = default;
170
171 /// (Re-)Initialize this bottom up pointer returning true if we detected a
172 /// pointer with nested releases.
174
175 /// Return true if this set of releases can be paired with a release. Modifies
176 /// state appropriately to reflect that the matching occurred if it is
177 /// successful.
178 ///
179 /// It is assumed that one has already checked that the RCIdentity of the
180 /// retain and the RCIdentity of this ptr state are the same.
181 bool MatchWithRetain();
182
183 void HandlePotentialUse(BasicBlock *BB, Instruction *Inst, const Value *Ptr,
187};
188
190 TopDownPtrState() = default;
191
192 /// (Re-)Initialize this bottom up pointer returning true if we detected a
193 /// pointer with nested releases.
195
196 /// Return true if this set of retains can be paired with the given
197 /// release. Modifies state appropriately to reflect that the matching
198 /// occurred.
200
201 void HandlePotentialUse(Instruction *Inst, const Value *Ptr,
203
206 const BundledRetainClaimRVs &BundledRVs);
207};
208
209} // end namespace objcarc
210
211} // end namespace llvm
212
213#endif // LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H
#define LLVM_ATTRIBUTE_UNUSED
Definition: Compiler.h:172
#define I(x, y, z)
Definition: MD5.cpp:58
R600 Clause Merge
This file defines the SmallPtrSet class.
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
Metadata node.
Definition: Metadata.h:943
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
LLVM Value Representation.
Definition: Value.h:74
A cache of MDKinds used by various ARC optimizations.
This is similar to BasicAliasAnalysis, and it uses many of the same techniques, except it uses specia...
This class summarizes several per-pointer runtime properties which are propagated through the flow gr...
Definition: PtrState.h:101
bool KnownPositiveRefCount
True if the reference count is known to be incremented.
Definition: PtrState.h:104
unsigned char Seq
The current position in the sequence.
Definition: PtrState.h:111
void SetCFGHazardAfflicted(const bool NewValue)
Definition: PtrState.h:139
Sequence GetSeq() const
Definition: PtrState.h:150
RRInfo RRI
Unidirectional information about the current sequence.
Definition: PtrState.h:114
void ClearReverseInsertPts()
Definition: PtrState.h:161
bool IsTailCallRelease() const
Definition: PtrState.h:123
bool HasKnownPositiveRefCount() const
Definition: PtrState.h:146
void InsertReverseInsertPt(Instruction *I)
Definition: PtrState.h:159
bool HasReverseInsertPts() const
Definition: PtrState.h:163
const RRInfo & GetRRInfo() const
Definition: PtrState.h:165
void SetTailCallRelease(const bool NewValue)
Definition: PtrState.h:125
void ClearKnownPositiveRefCount()
Definition: PtrState.cpp:129
bool IsCFGHazardAfflicted() const
Definition: PtrState.h:137
const MDNode * GetReleaseMetadata() const
Definition: PtrState.h:133
void SetReleaseMetadata(MDNode *NewValue)
Definition: PtrState.h:135
void InsertCall(Instruction *I)
Definition: PtrState.h:157
void ResetSequenceProgress(Sequence NewSeq)
Definition: PtrState.cpp:140
void SetSeq(Sequence NewSeq)
Definition: PtrState.cpp:134
void SetKnownSafe(const bool NewValue)
Definition: PtrState.h:121
void ClearSequenceProgress()
Definition: PtrState.h:152
bool IsKnownSafe() const
Definition: PtrState.h:119
bool Partial
True if we've seen an opportunity for partial RR elimination, such as pushing calls into a CFG triang...
Definition: PtrState.h:108
bool IsTrackingImpreciseReleases() const
Definition: PtrState.h:129
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
@ BasicBlock
Various leaf nodes.
Definition: ISDOpcodes.h:71
raw_ostream & operator<<(raw_ostream &OS, const ARCInstKind Class)
ARCInstKind
Equivalence classes of instructions in the ARC Model.
Sequence
A sequence of states that a pointer may go through in which an objc_retain and objc_release are actua...
Definition: PtrState.h:41
@ S_CanRelease
foo(x) – x could possibly see a ref count decrement.
Definition: PtrState.h:44
@ S_Use
any use of x.
Definition: PtrState.h:45
@ S_Retain
objc_retain(x).
Definition: PtrState.h:43
@ S_Stop
code motion is stopped.
Definition: PtrState.h:46
@ S_MovableRelease
objc_release(x), !clang.imprecise_release.
Definition: PtrState.h:47
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class)
Definition: PtrState.cpp:226
bool InitBottomUp(ARCMDKindCache &Cache, Instruction *I)
(Re-)Initialize this bottom up pointer returning true if we detected a pointer with nested releases.
Definition: PtrState.cpp:174
bool MatchWithRetain()
Return true if this set of releases can be paired with a release.
Definition: PtrState.cpp:203
void HandlePotentialUse(BasicBlock *BB, Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class)
Definition: PtrState.cpp:253
Unidirectional information about either a retain-decrement-use-release sequence or release-use-decrem...
Definition: PtrState.h:56
bool KnownSafe
After an objc_retain, the reference count of the referenced object is known to be positive.
Definition: PtrState.h:69
SmallPtrSet< Instruction *, 2 > Calls
For a top-down sequence, the set of objc_retains or objc_retainBlocks.
Definition: PtrState.h:80
MDNode * ReleaseMetadata
If the Calls are objc_release calls and they all have a clang.imprecise_release tag,...
Definition: PtrState.h:76
bool CFGHazardAfflicted
If this is true, we cannot perform code motion but can still remove retain/release pairs.
Definition: PtrState.h:88
bool IsTailCallRelease
True of the objc_release calls are all marked with the "tail" keyword.
Definition: PtrState.h:72
SmallPtrSet< Instruction *, 2 > ReverseInsertPts
The set of optimal insert positions for moving calls in the opposite sequence.
Definition: PtrState.h:84
bool MatchWithRelease(ARCMDKindCache &Cache, Instruction *Release)
Return true if this set of retains can be paired with the given release.
Definition: PtrState.cpp:349
bool InitTopDown(ARCInstKind Kind, Instruction *I)
(Re-)Initialize this bottom up pointer returning true if we detected a pointer with nested releases.
Definition: PtrState.cpp:324
bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class, const BundledRetainClaimRVs &BundledRVs)
Definition: PtrState.cpp:377
void HandlePotentialUse(Instruction *Inst, const Value *Ptr, ProvenanceAnalysis &PA, ARCInstKind Class)
Definition: PtrState.cpp:416