Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/Transforms/ObjCARC/PtrState.h
Line
Count
Source (jump to first uncovered line)
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
19
#include "llvm/ADT/SmallPtrSet.h"
20
#include "llvm/Analysis/ObjCARCInstKind.h"
21
#include "llvm/Support/Compiler.h"
22
23
namespace llvm {
24
25
class BasicBlock;
26
class Instruction;
27
class MDNode;
28
class raw_ostream;
29
class Value;
30
31
namespace objcarc {
32
33
class ARCMDKindCache;
34
class ProvenanceAnalysis;
35
36
/// \enum Sequence
37
///
38
/// A sequence of states that a pointer may go through in which an
39
/// objc_retain and objc_release are actually needed.
40
enum Sequence {
41
  S_None,
42
  S_Retain,        ///< objc_retain(x).
43
  S_CanRelease,    ///< foo(x) -- x could possibly see a ref count decrement.
44
  S_Use,           ///< any use of x.
45
  S_Stop,          ///< like S_Release, but code motion is stopped.
46
  S_Release,       ///< objc_release(x).
47
  S_MovableRelease ///< objc_release(x), !clang.imprecise_release.
48
};
49
50
raw_ostream &operator<<(raw_ostream &OS,
51
                        const Sequence S) LLVM_ATTRIBUTE_UNUSED;
52
53
/// Unidirectional information about either a
54
/// retain-decrement-use-release sequence or release-use-decrement-retain
55
/// reverse sequence.
56
struct 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.
76
  MDNode *ReleaseMetadata = nullptr;
77
78
  /// For a top-down sequence, the set of objc_retains or
79
  /// objc_retainBlocks. For bottom-up, the set of objc_releases.
80
  SmallPtrSet<Instruction *, 2> Calls;
81
82
  /// The set of optimal insert positions for moving calls in the opposite
83
  /// sequence.
84
  SmallPtrSet<Instruction *, 2> ReverseInsertPts;
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
1.89k
  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.
101
class PtrState {
102
protected:
103
  /// True if the reference count is known to be incremented.
104
  bool KnownPositiveRefCount = false;
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.
114
  RRInfo RRI;
115
116
1.10k
  PtrState() : Seq(S_None) {}
117
118
public:
119
972
  bool IsKnownSafe() const { return RRI.KnownSafe; }
120
121
706
  void SetKnownSafe(const bool NewValue) { RRI.KnownSafe = NewValue; }
122
123
0
  bool IsTailCallRelease() const { return RRI.IsTailCallRelease; }
124
125
588
  void SetTailCallRelease(const bool NewValue) {
126
588
    RRI.IsTailCallRelease = NewValue;
127
588
  }
128
129
44
  bool IsTrackingImpreciseReleases() const {
130
44
    return RRI.ReleaseMetadata != nullptr;
131
44
  }
132
133
0
  const MDNode *GetReleaseMetadata() const { return RRI.ReleaseMetadata; }
134
135
588
  void SetReleaseMetadata(MDNode *NewValue) { RRI.ReleaseMetadata = NewValue; }
136
137
0
  bool IsCFGHazardAfflicted() const { return RRI.CFGHazardAfflicted; }
138
139
120
  void SetCFGHazardAfflicted(const bool NewValue) {
140
120
    RRI.CFGHazardAfflicted = NewValue;
141
120
  }
142
143
  void SetKnownPositiveRefCount();
144
  void ClearKnownPositiveRefCount();
145
146
706
  bool HasKnownPositiveRefCount() const { return KnownPositiveRefCount; }
147
148
  void SetSeq(Sequence NewSeq);
149
150
14.9k
  Sequence GetSeq() const { return static_cast<Sequence>(Seq); }
151
152
503
  void ClearSequenceProgress() { ResetSequenceProgress(S_None); }
153
154
  void ResetSequenceProgress(Sequence NewSeq);
155
  void Merge(const PtrState &Other, bool TopDown);
156
157
706
  void InsertCall(Instruction *I) { RRI.Calls.insert(I); }
158
159
486
  void InsertReverseInsertPt(Instruction *I) { RRI.ReverseInsertPts.insert(I); }
160
161
137
  void ClearReverseInsertPts() { RRI.ReverseInsertPts.clear(); }
162
163
0
  bool HasReverseInsertPts() const { return !RRI.ReverseInsertPts.empty(); }
164
165
399
  const RRInfo &GetRRInfo() const { return RRI; }
166
};
167
168
struct BottomUpPtrState : PtrState {
169
688
  BottomUpPtrState() = default;
170
171
  /// (Re-)Initialize this bottom up pointer returning true if we detected a
172
  /// pointer with nested releases.
173
  bool InitBottomUp(ARCMDKindCache &Cache, Instruction *I);
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,
184
                          ProvenanceAnalysis &PA, ARCInstKind Class);
185
  bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr,
186
                                    ProvenanceAnalysis &PA, ARCInstKind Class);
187
};
188
189
struct TopDownPtrState : PtrState {
190
416
  TopDownPtrState() = default;
191
192
  /// (Re-)Initialize this bottom up pointer returning true if we detected a
193
  /// pointer with nested releases.
194
  bool InitTopDown(ARCInstKind Kind, Instruction *I);
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.
199
  bool MatchWithRelease(ARCMDKindCache &Cache, Instruction *Release);
200
201
  void HandlePotentialUse(Instruction *Inst, const Value *Ptr,
202
                          ProvenanceAnalysis &PA, ARCInstKind Class);
203
204
  bool HandlePotentialAlterRefCount(Instruction *Inst, const Value *Ptr,
205
                                    ProvenanceAnalysis &PA, ARCInstKind Class);
206
};
207
208
} // end namespace objcarc
209
210
} // end namespace llvm
211
212
#endif // LLVM_LIB_TRANSFORMS_OBJCARC_PTRSTATE_H