Coverage Report

Created: 2018-07-20 23:04

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/PriorityWorklist.h
Line
Count
Source (jump to first uncovered line)
1
//===- PriorityWorklist.h - Worklist with insertion priority ----*- 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
/// \file
11
///
12
/// This file provides a priority worklist. See the class comments for details.
13
///
14
//===----------------------------------------------------------------------===//
15
16
#ifndef LLVM_ADT_PRIORITYWORKLIST_H
17
#define LLVM_ADT_PRIORITYWORKLIST_H
18
19
#include "llvm/ADT/DenseMap.h"
20
#include "llvm/ADT/STLExtras.h"
21
#include "llvm/ADT/SmallVector.h"
22
#include "llvm/Support/Compiler.h"
23
#include <algorithm>
24
#include <cassert>
25
#include <cstddef>
26
#include <iterator>
27
#include <type_traits>
28
#include <vector>
29
30
namespace llvm {
31
32
/// A FILO worklist that prioritizes on re-insertion without duplication.
33
///
34
/// This is very similar to a \c SetVector with the primary difference that
35
/// while re-insertion does not create a duplicate, it does adjust the
36
/// visitation order to respect the last insertion point. This can be useful
37
/// when the visit order needs to be prioritized based on insertion point
38
/// without actually having duplicate visits.
39
///
40
/// Note that this doesn't prevent re-insertion of elements which have been
41
/// visited -- if you need to break cycles, a set will still be necessary.
42
///
43
/// The type \c T must be default constructable to a null value that will be
44
/// ignored. It is an error to insert such a value, and popping elements will
45
/// never produce such a value. It is expected to be used with common nullable
46
/// types like pointers or optionals.
47
///
48
/// Internally this uses a vector to store the worklist and a map to identify
49
/// existing elements in the worklist. Both of these may be customized, but the
50
/// map must support the basic DenseMap API for mapping from a T to an integer
51
/// index into the vector.
52
///
53
/// A partial specialization is provided to automatically select a SmallVector
54
/// and a SmallDenseMap if custom data structures are not provided.
55
template <typename T, typename VectorT = std::vector<T>,
56
          typename MapT = DenseMap<T, ptrdiff_t>>
57
class PriorityWorklist {
58
public:
59
  using value_type = T;
60
  using key_type = T;
61
  using reference = T&;
62
  using const_reference = const T&;
63
  using size_type = typename MapT::size_type;
64
65
  /// Construct an empty PriorityWorklist
66
1.34k
  PriorityWorklist() = default;
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::PriorityWorklist()
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::PriorityWorklist()
Line
Count
Source
66
718
  PriorityWorklist() = default;
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::PriorityWorklist()
Line
Count
Source
66
312
  PriorityWorklist() = default;
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::PriorityWorklist()
Line
Count
Source
66
312
  PriorityWorklist() = default;
67
68
  /// Determine if the PriorityWorklist is empty or not.
69
3.23k
  bool empty() const {
70
3.23k
    return V.empty();
71
3.23k
  }
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::empty() const
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::empty() const
Line
Count
Source
69
1.15k
  bool empty() const {
70
1.15k
    return V.empty();
71
1.15k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::empty() const
Line
Count
Source
69
1.07k
  bool empty() const {
70
1.07k
    return V.empty();
71
1.07k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::empty() const
Line
Count
Source
69
1.00k
  bool empty() const {
70
1.00k
    return V.empty();
71
1.00k
  }
72
73
  /// Returns the number of elements in the worklist.
74
  size_type size() const {
75
    return M.size();
76
  }
77
78
  /// Count the number of elements of a given key in the PriorityWorklist.
79
  /// \returns 0 if the element is not in the PriorityWorklist, 1 if it is.
80
  size_type count(const key_type &key) const {
81
    return M.count(key);
82
  }
83
84
  /// Return the last element of the PriorityWorklist.
85
6.47k
  const T &back() const {
86
6.47k
    assert(!empty() && "Cannot call back() on empty PriorityWorklist!");
87
6.47k
    return V.back();
88
6.47k
  }
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::back() const
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::back() const
Line
Count
Source
85
2.31k
  const T &back() const {
86
2.31k
    assert(!empty() && "Cannot call back() on empty PriorityWorklist!");
87
2.31k
    return V.back();
88
2.31k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::back() const
Line
Count
Source
85
2.01k
  const T &back() const {
86
2.01k
    assert(!empty() && "Cannot call back() on empty PriorityWorklist!");
87
2.01k
    return V.back();
88
2.01k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::back() const
Line
Count
Source
85
2.14k
  const T &back() const {
86
2.14k
    assert(!empty() && "Cannot call back() on empty PriorityWorklist!");
87
2.14k
    return V.back();
88
2.14k
  }
89
90
  /// Insert a new element into the PriorityWorklist.
91
  /// \returns true if the element was inserted into the PriorityWorklist.
92
2.16k
  bool insert(const T &X) {
93
2.16k
    assert(X != T() && "Cannot insert a null (default constructed) value!");
94
2.16k
    auto InsertResult = M.insert({X, V.size()});
95
2.16k
    if (InsertResult.second) {
96
2.15k
      // Fresh value, just append it to the vector.
97
2.15k
      V.push_back(X);
98
2.15k
      return true;
99
2.15k
    }
100
12
101
12
    auto &Index = InsertResult.first->second;
102
12
    assert(V[Index] == X && "Value not actually at index in map!");
103
12
    if (Index != (ptrdiff_t)(V.size() - 1)) {
104
4
      // If the element isn't at the back, null it out and append a fresh one.
105
4
      V[Index] = T();
106
4
      Index = (ptrdiff_t)V.size();
107
4
      V.push_back(X);
108
4
    }
109
12
    return false;
110
12
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::insert(llvm::LazyCallGraph::RefSCC* const&)
Line
Count
Source
92
1.00k
  bool insert(const T &X) {
93
1.00k
    assert(X != T() && "Cannot insert a null (default constructed) value!");
94
1.00k
    auto InsertResult = M.insert({X, V.size()});
95
1.00k
    if (InsertResult.second) {
96
1.00k
      // Fresh value, just append it to the vector.
97
1.00k
      V.push_back(X);
98
1.00k
      return true;
99
1.00k
    }
100
0
101
0
    auto &Index = InsertResult.first->second;
102
0
    assert(V[Index] == X && "Value not actually at index in map!");
103
0
    if (Index != (ptrdiff_t)(V.size() - 1)) {
104
0
      // If the element isn't at the back, null it out and append a fresh one.
105
0
      V[Index] = T();
106
0
      Index = (ptrdiff_t)V.size();
107
0
      V.push_back(X);
108
0
    }
109
0
    return false;
110
0
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::insert(llvm::LazyCallGraph::SCC* const&)
Line
Count
Source
92
1.08k
  bool insert(const T &X) {
93
1.08k
    assert(X != T() && "Cannot insert a null (default constructed) value!");
94
1.08k
    auto InsertResult = M.insert({X, V.size()});
95
1.08k
    if (InsertResult.second) {
96
1.07k
      // Fresh value, just append it to the vector.
97
1.07k
      V.push_back(X);
98
1.07k
      return true;
99
1.07k
    }
100
12
101
12
    auto &Index = InsertResult.first->second;
102
12
    assert(V[Index] == X && "Value not actually at index in map!");
103
12
    if (Index != (ptrdiff_t)(V.size() - 1)) {
104
4
      // If the element isn't at the back, null it out and append a fresh one.
105
4
      V[Index] = T();
106
4
      Index = (ptrdiff_t)V.size();
107
4
      V.push_back(X);
108
4
    }
109
12
    return false;
110
12
  }
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::insert(llvm::Loop* const&)
Line
Count
Source
92
77
  bool insert(const T &X) {
93
77
    assert(X != T() && "Cannot insert a null (default constructed) value!");
94
77
    auto InsertResult = M.insert({X, V.size()});
95
77
    if (InsertResult.second) {
96
77
      // Fresh value, just append it to the vector.
97
77
      V.push_back(X);
98
77
      return true;
99
77
    }
100
0
101
0
    auto &Index = InsertResult.first->second;
102
0
    assert(V[Index] == X && "Value not actually at index in map!");
103
0
    if (Index != (ptrdiff_t)(V.size() - 1)) {
104
0
      // If the element isn't at the back, null it out and append a fresh one.
105
0
      V[Index] = T();
106
0
      Index = (ptrdiff_t)V.size();
107
0
      V.push_back(X);
108
0
    }
109
0
    return false;
110
0
  }
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::insert(llvm::Region* const&)
111
112
  /// Insert a sequence of new elements into the PriorityWorklist.
113
  template <typename SequenceT>
114
  typename std::enable_if<!std::is_convertible<SequenceT, T>::value>::type
115
875
  insert(SequenceT &&Input) {
116
875
    if (std::begin(Input) == std::end(Input))
117
0
      // Nothing to do for an empty input sequence.
118
0
      return;
119
875
120
875
    // First pull the input sequence into the vector as a bulk append
121
875
    // operation.
122
875
    ptrdiff_t StartIndex = V.size();
123
875
    V.insert(V.end(), std::begin(Input), std::end(Input));
124
875
    // Now walk backwards fixing up the index map and deleting any duplicates.
125
1.95k
    for (ptrdiff_t i = V.size() - 1; i >= StartIndex; 
--i1.08k
) {
126
1.08k
      auto InsertResult = M.insert({V[i], i});
127
1.08k
      if (InsertResult.second)
128
1.08k
        continue;
129
0
130
0
      // If the existing index is before this insert's start, nuke that one and
131
0
      // move it up.
132
0
      ptrdiff_t &Index = InsertResult.first->second;
133
0
      if (Index < StartIndex) {
134
0
        V[Index] = T();
135
0
        Index = i;
136
0
        continue;
137
0
      }
138
0
139
0
      // Otherwise the existing one comes first so just clear out the value in
140
0
      // this slot.
141
0
      V[i] = T();
142
0
    }
143
875
  }
144
145
  /// Remove the last element of the PriorityWorklist.
146
3.23k
  void pop_back() {
147
3.23k
    assert(!empty() && "Cannot remove an element when empty!");
148
3.23k
    assert(back() != T() && "Cannot have a null element at the back!");
149
3.23k
    M.erase(back());
150
3.24k
    do {
151
3.24k
      V.pop_back();
152
3.24k
    } while (!V.empty() && 
V.back() == T()387
);
153
3.23k
  }
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::pop_back()
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::pop_back()
Line
Count
Source
146
1.15k
  void pop_back() {
147
1.15k
    assert(!empty() && "Cannot remove an element when empty!");
148
1.15k
    assert(back() != T() && "Cannot have a null element at the back!");
149
1.15k
    M.erase(back());
150
1.15k
    do {
151
1.15k
      V.pop_back();
152
1.15k
    } while (!V.empty() && 
V.back() == T()325
);
153
1.15k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::pop_back()
Line
Count
Source
146
1.00k
  void pop_back() {
147
1.00k
    assert(!empty() && "Cannot remove an element when empty!");
148
1.00k
    assert(back() != T() && "Cannot have a null element at the back!");
149
1.00k
    M.erase(back());
150
1.00k
    do {
151
1.00k
      V.pop_back();
152
1.00k
    } while (!V.empty() && 
V.back() == T()7
);
153
1.00k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::pop_back()
Line
Count
Source
146
1.07k
  void pop_back() {
147
1.07k
    assert(!empty() && "Cannot remove an element when empty!");
148
1.07k
    assert(back() != T() && "Cannot have a null element at the back!");
149
1.07k
    M.erase(back());
150
1.07k
    do {
151
1.07k
      V.pop_back();
152
1.07k
    } while (!V.empty() && 
V.back() == T()55
);
153
1.07k
  }
154
155
3.23k
  LLVM_NODISCARD T pop_back_val() {
156
3.23k
    T Ret = back();
157
3.23k
    pop_back();
158
3.23k
    return Ret;
159
3.23k
  }
Unexecuted instantiation: llvm::PriorityWorklist<llvm::Region*, llvm::SmallVector<llvm::Region*, 4u>, llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*>, llvm::detail::DenseMapPair<llvm::Region*, long> > >::pop_back_val()
llvm::PriorityWorklist<llvm::Loop*, llvm::SmallVector<llvm::Loop*, 4u>, llvm::SmallDenseMap<llvm::Loop*, long, 4u, llvm::DenseMapInfo<llvm::Loop*>, llvm::detail::DenseMapPair<llvm::Loop*, long> > >::pop_back_val()
Line
Count
Source
155
1.15k
  LLVM_NODISCARD T pop_back_val() {
156
1.15k
    T Ret = back();
157
1.15k
    pop_back();
158
1.15k
    return Ret;
159
1.15k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::RefSCC*, llvm::SmallVector<llvm::LazyCallGraph::RefSCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::RefSCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::RefSCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::RefSCC*, long> > >::pop_back_val()
Line
Count
Source
155
1.00k
  LLVM_NODISCARD T pop_back_val() {
156
1.00k
    T Ret = back();
157
1.00k
    pop_back();
158
1.00k
    return Ret;
159
1.00k
  }
llvm::PriorityWorklist<llvm::LazyCallGraph::SCC*, llvm::SmallVector<llvm::LazyCallGraph::SCC*, 1u>, llvm::SmallDenseMap<llvm::LazyCallGraph::SCC*, long, 4u, llvm::DenseMapInfo<llvm::LazyCallGraph::SCC*>, llvm::detail::DenseMapPair<llvm::LazyCallGraph::SCC*, long> > >::pop_back_val()
Line
Count
Source
155
1.07k
  LLVM_NODISCARD T pop_back_val() {
156
1.07k
    T Ret = back();
157
1.07k
    pop_back();
158
1.07k
    return Ret;
159
1.07k
  }
160
161
  /// Erase an item from the worklist.
162
  ///
163
  /// Note that this is constant time due to the nature of the worklist implementation.
164
0
  bool erase(const T& X) {
165
0
    auto I = M.find(X);
166
0
    if (I == M.end())
167
0
      return false;
168
0
169
0
    assert(V[I->second] == X && "Value not actually at index in map!");
170
0
    if (I->second == (ptrdiff_t)(V.size() - 1)) {
171
0
      do {
172
0
        V.pop_back();
173
0
      } while (!V.empty() && V.back() == T());
174
0
    } else {
175
0
      V[I->second] = T();
176
0
    }
177
0
    M.erase(I);
178
0
    return true;
179
0
  }
180
181
  /// Erase items from the set vector based on a predicate function.
182
  ///
183
  /// This is intended to be equivalent to the following code, if we could
184
  /// write it:
185
  ///
186
  /// \code
187
  ///   V.erase(remove_if(V, P), V.end());
188
  /// \endcode
189
  ///
190
  /// However, PriorityWorklist doesn't expose non-const iterators, making any
191
  /// algorithm like remove_if impossible to use.
192
  ///
193
  /// \returns true if any element is removed.
194
  template <typename UnaryPredicate>
195
  bool erase_if(UnaryPredicate P) {
196
    typename VectorT::iterator E =
197
        remove_if(V, TestAndEraseFromMap<UnaryPredicate>(P, M));
198
    if (E == V.end())
199
      return false;
200
    for (auto I = V.begin(); I != E; ++I)
201
      if (*I != T())
202
        M[*I] = I - V.begin();
203
    V.erase(E, V.end());
204
    return true;
205
  }
206
207
  /// Reverse the items in the PriorityWorklist.
208
  ///
209
  /// This does an in-place reversal. Other kinds of reverse aren't easy to
210
  /// support in the face of the worklist semantics.
211
212
  /// Completely clear the PriorityWorklist
213
  void clear() {
214
    M.clear();
215
    V.clear();
216
  }
217
218
private:
219
  /// A wrapper predicate designed for use with std::remove_if.
220
  ///
221
  /// This predicate wraps a predicate suitable for use with std::remove_if to
222
  /// call M.erase(x) on each element which is slated for removal. This just
223
  /// allows the predicate to be move only which we can't do with lambdas
224
  /// today.
225
  template <typename UnaryPredicateT>
226
  class TestAndEraseFromMap {
227
    UnaryPredicateT P;
228
    MapT &M;
229
230
  public:
231
    TestAndEraseFromMap(UnaryPredicateT P, MapT &M)
232
        : P(std::move(P)), M(M) {}
233
234
    bool operator()(const T &Arg) {
235
      if (Arg == T())
236
        // Skip null values in the PriorityWorklist.
237
        return false;
238
239
      if (P(Arg)) {
240
        M.erase(Arg);
241
        return true;
242
      }
243
      return false;
244
    }
245
  };
246
247
  /// The map from value to index in the vector.
248
  MapT M;
249
250
  /// The vector of elements in insertion order.
251
  VectorT V;
252
};
253
254
/// A version of \c PriorityWorklist that selects small size optimized data
255
/// structures for the vector and map.
256
template <typename T, unsigned N>
257
class SmallPriorityWorklist
258
    : public PriorityWorklist<T, SmallVector<T, N>,
259
                              SmallDenseMap<T, ptrdiff_t>> {
260
public:
261
1.34k
  SmallPriorityWorklist() = default;
Unexecuted instantiation: llvm::SmallPriorityWorklist<llvm::Region*, 4u>::SmallPriorityWorklist()
llvm::SmallPriorityWorklist<llvm::Loop*, 4u>::SmallPriorityWorklist()
Line
Count
Source
261
718
  SmallPriorityWorklist() = default;
llvm::SmallPriorityWorklist<llvm::LazyCallGraph::RefSCC*, 1u>::SmallPriorityWorklist()
Line
Count
Source
261
312
  SmallPriorityWorklist() = default;
llvm::SmallPriorityWorklist<llvm::LazyCallGraph::SCC*, 1u>::SmallPriorityWorklist()
Line
Count
Source
261
312
  SmallPriorityWorklist() = default;
262
};
263
264
} // end namespace llvm
265
266
#endif // LLVM_ADT_PRIORITYWORKLIST_H