Coverage Report

Created: 2018-09-23 22:08

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/SmallSet.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/ADT/SmallSet.h - 'Normally small' sets --------------*- 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
// This file defines the SmallSet class.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_ADT_SMALLSET_H
15
#define LLVM_ADT_SMALLSET_H
16
17
#include "llvm/ADT/None.h"
18
#include "llvm/ADT/SmallPtrSet.h"
19
#include "llvm/ADT/SmallVector.h"
20
#include "llvm/ADT/iterator.h"
21
#include "llvm/Support/Compiler.h"
22
#include "llvm/Support/type_traits.h"
23
#include <cstddef>
24
#include <functional>
25
#include <set>
26
#include <type_traits>
27
#include <utility>
28
29
namespace llvm {
30
31
/// SmallSetIterator - This class implements a const_iterator for SmallSet by
32
/// delegating to the underlying SmallVector or Set iterators.
33
template <typename T, unsigned N, typename C>
34
class SmallSetIterator
35
    : public iterator_facade_base<SmallSetIterator<T, N, C>,
36
                                  std::forward_iterator_tag, T> {
37
private:
38
  using SetIterTy = typename std::set<T, C>::const_iterator;
39
  using VecIterTy = typename SmallVector<T, N>::const_iterator;
40
  using SelfTy = SmallSetIterator<T, N, C>;
41
42
  /// Iterators to the parts of the SmallSet containing the data. They are set
43
  /// depending on isSmall.
44
  union {
45
    SetIterTy SetIter;
46
    VecIterTy VecIter;
47
  };
48
49
  bool isSmall;
50
51
public:
52
0
  SmallSetIterator(SetIterTy SetIter) : SetIter(SetIter), isSmall(false) {}
53
54
1.16M
  SmallSetIterator(VecIterTy VecIter) : VecIter(VecIter), isSmall(true) {}
55
56
  // Spell out destructor, copy/move constructor and assignment operators for
57
  // MSVC STL, where set<T>::const_iterator is not trivially copy constructible.
58
1.16M
  ~SmallSetIterator() {
59
1.16M
    if (isSmall)
60
1.16M
      VecIter.~VecIterTy();
61
0
    else
62
0
      SetIter.~SetIterTy();
63
1.16M
  }
64
65
  SmallSetIterator(const SmallSetIterator &Other) : isSmall(Other.isSmall) {
66
    if (isSmall)
67
      VecIter = Other.VecIter;
68
    else
69
      // Use placement new, to make sure SetIter is properly constructed, even
70
      // if it is not trivially copy-able (e.g. in MSVC).
71
      new (&SetIter) SetIterTy(Other.SetIter);
72
  }
73
74
  SmallSetIterator(SmallSetIterator &&Other) : isSmall(Other.isSmall) {
75
    if (isSmall)
76
      VecIter = std::move(Other.VecIter);
77
    else
78
      // Use placement new, to make sure SetIter is properly constructed, even
79
      // if it is not trivially copy-able (e.g. in MSVC).
80
      new (&SetIter) SetIterTy(std::move(Other.SetIter));
81
  }
82
83
  SmallSetIterator& operator=(const SmallSetIterator& Other) {
84
    // Call destructor for SetIter, so it gets properly destroyed if it is
85
    // not trivially destructible in case we are setting VecIter.
86
    if (!isSmall)
87
      SetIter.~SetIterTy();
88
89
    isSmall = Other.isSmall;
90
    if (isSmall)
91
      VecIter = Other.VecIter;
92
    else
93
      new (&SetIter) SetIterTy(Other.SetIter);
94
    return *this;
95
  }
96
97
  SmallSetIterator& operator=(SmallSetIterator&& Other) {
98
    // Call destructor for SetIter, so it gets properly destroyed if it is
99
    // not trivially destructible in case we are setting VecIter.
100
    if (!isSmall)
101
      SetIter.~SetIterTy();
102
103
    isSmall = Other.isSmall;
104
    if (isSmall)
105
      VecIter = std::move(Other.VecIter);
106
    else
107
      new (&SetIter) SetIterTy(std::move(Other.SetIter));
108
    return *this;
109
  }
110
111
620k
  bool operator==(const SmallSetIterator &RHS) const {
112
620k
    if (isSmall != RHS.isSmall)
113
0
      return false;
114
620k
    if (isSmall)
115
620k
      return VecIter == RHS.VecIter;
116
0
    return SetIter == RHS.SetIter;
117
0
  }
118
119
40.6k
  SmallSetIterator &operator++() { // Preincrement
120
40.6k
    if (isSmall)
121
40.6k
      VecIter++;
122
0
    else
123
0
      SetIter++;
124
40.6k
    return *this;
125
40.6k
  }
126
127
40.6k
  const T &operator*() const { return isSmall ? *VecIter : 
*SetIter0
; }
128
};
129
130
/// SmallSet - This maintains a set of unique values, optimizing for the case
131
/// when the set is small (less than N).  In this case, the set can be
132
/// maintained with no mallocs.  If the set gets large, we expand to using an
133
/// std::set to maintain reasonable lookup times.
134
template <typename T, unsigned N, typename C = std::less<T>>
135
class SmallSet {
136
  /// Use a SmallVector to hold the elements here (even though it will never
137
  /// reach its 'large' stage) to avoid calling the default ctors of elements
138
  /// we will never use.
139
  SmallVector<T, N> Vector;
140
  std::set<T, C> Set;
141
142
  using VIterator = typename SmallVector<T, N>::const_iterator;
143
  using mutable_iterator = typename SmallVector<T, N>::iterator;
144
145
  // In small mode SmallPtrSet uses linear search for the elements, so it is
146
  // not a good idea to choose this value too high. You may consider using a
147
  // DenseSet<> instead if you expect many elements in the set.
148
  static_assert(N <= 32, "N should be small");
149
150
public:
151
  using size_type = size_t;
152
  using const_iterator = SmallSetIterator<T, N, C>;
153
154
91.9M
  SmallSet() = default;
llvm::SmallSet<int, 4u, std::__1::less<int> >::SmallSet()
Line
Count
Source
154
31.2k
  SmallSet() = default;
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
154
343k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
40.5M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
11.4M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
16.6M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
871k
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
154
4.35k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
17.8M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
48
  SmallSet() = default;
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
154
2.03k
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
154
26.0k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::SmallSet()
Line
Count
Source
154
31.4k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::PHINode*, llvm::PHINode*>, 8u, std::__1::less<std::__1::pair<llvm::PHINode*, llvm::PHINode*> > >::SmallSet()
Line
Count
Source
154
15.9k
  SmallSet() = default;
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::SmallSet()
Line
Count
Source
154
545
  SmallSet() = default;
llvm::SmallSet<int, 16u, std::__1::less<int> >::SmallSet()
Line
Count
Source
154
494k
  SmallSet() = default;
llvm::SmallSet<int, 32u, std::__1::less<int> >::SmallSet()
Line
Count
Source
154
151k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::SmallSet()
Line
Count
Source
154
31.3k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::DIScope*, llvm::DILocation*>, 5u, std::__1::less<std::__1::pair<llvm::DIScope*, llvm::DILocation*> > >::SmallSet()
Line
Count
Source
154
182k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::SmallSet()
Line
Count
Source
154
83
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::SmallSet()
Line
Count
Source
154
1.56M
  SmallSet() = default;
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
154
206k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::SmallSet()
Line
Count
Source
154
102k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::Value*, llvm::Value*>, 32u, std::__1::less<std::__1::pair<llvm::Value*, llvm::Value*> > >::SmallSet()
Line
Count
Source
154
753k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSet()
Line
Count
Source
154
580k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
154
112
  SmallSet() = default;
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::SmallSet()
Line
Count
Source
154
169
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::SmallSet()
Line
Count
Source
154
169
  SmallSet() = default;
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::SmallSet()
Line
Count
Source
154
27.3k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::SmallSet()
Line
Count
Source
154
292
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
154
28.2k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<void const*, void const*>, 4u, std::__1::less<std::__1::pair<void const*, void const*> > >::SmallSet()
Line
Count
Source
154
10.6k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::SmallSet()
Line
Count
Source
154
2
  SmallSet() = default;
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::SmallSet()
Line
Count
Source
154
20
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
154
87
  SmallSet() = default;
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::SmallSet()
Line
Count
Source
154
20.8k
  SmallSet() = default;
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::SmallSet()
Line
Count
Source
154
1.45k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
154
936
  SmallSet() = default;
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::SmallSet()
Line
Count
Source
154
14.1k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
43
  SmallSet() = default;
155
156
27.5M
  LLVM_NODISCARD bool empty() const {
157
27.5M
    return Vector.empty() && 
Set.empty()26.1M
;
158
27.5M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
258
  LLVM_NODISCARD bool empty() const {
157
258
    return Vector.empty() && 
Set.empty()0
;
158
258
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
988k
  LLVM_NODISCARD bool empty() const {
157
988k
    return Vector.empty() && 
Set.empty()479k
;
158
988k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
992k
  LLVM_NODISCARD bool empty() const {
157
992k
    return Vector.empty() && 
Set.empty()489k
;
158
992k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
24.6M
  LLVM_NODISCARD bool empty() const {
157
24.6M
    return Vector.empty() && 
Set.empty()24.3M
;
158
24.6M
  }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::empty() const
Line
Count
Source
156
371
  LLVM_NODISCARD bool empty() const {
157
371
    return Vector.empty() && 
Set.empty()2
;
158
371
  }
llvm::SmallSet<std::__1::pair<void const*, void const*>, 4u, std::__1::less<std::__1::pair<void const*, void const*> > >::empty() const
Line
Count
Source
156
875k
  LLVM_NODISCARD bool empty() const {
157
875k
    return Vector.empty() && 
Set.empty()874k
;
158
875k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::empty() const
Line
Count
Source
156
16.7k
  LLVM_NODISCARD bool empty() const {
157
16.7k
    return Vector.empty() && 
Set.empty()14.5k
;
158
16.7k
  }
159
160
357k
  size_type size() const {
161
357k
    return isSmall() ? 
Vector.size()353k
:
Set.size()4.01k
;
162
357k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::size() const
Line
Count
Source
160
315k
  size_type size() const {
161
315k
    return isSmall() ? 
Vector.size()315k
:
Set.size()26
;
162
315k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::size() const
Line
Count
Source
160
15.5k
  size_type size() const {
161
15.5k
    return isSmall() ? 
Vector.size()15.1k
:
Set.size()434
;
162
15.5k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
160
23.6k
  size_type size() const {
161
23.6k
    return isSmall() ? 
Vector.size()20.0k
:
Set.size()3.55k
;
162
23.6k
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
160
2.46k
  size_type size() const {
161
2.46k
    return isSmall() ? Vector.size() : 
Set.size()0
;
162
2.46k
  }
163
164
  /// count - Return 1 if the element is in the set, 0 otherwise.
165
41.7M
  size_type count(const T &V) const {
166
41.7M
    if (isSmall()) {
167
38.1M
      // Since the collection is small, just do a linear search.
168
38.1M
      return vfind(V) == Vector.end() ? 
026.0M
:
112.0M
;
169
38.1M
    } else {
170
3.54M
      return Set.count(V);
171
3.54M
    }
172
41.7M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
165
2.39k
  size_type count(const T &V) const {
166
2.39k
    if (isSmall()) {
167
2.08k
      // Since the collection is small, just do a linear search.
168
2.08k
      return vfind(V) == Vector.end() ? 
01.65k
:
1432
;
169
2.08k
    } else {
170
311
      return Set.count(V);
171
311
    }
172
2.39k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
3.14M
  size_type count(const T &V) const {
166
3.14M
    if (isSmall()) {
167
3.14M
      // Since the collection is small, just do a linear search.
168
3.14M
      return vfind(V) == Vector.end() ? 
02.56M
:
1581k
;
169
3.14M
    } else {
170
1.57k
      return Set.count(V);
171
1.57k
    }
172
3.14M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
999k
  size_type count(const T &V) const {
166
999k
    if (isSmall()) {
167
993k
      // Since the collection is small, just do a linear search.
168
993k
      return vfind(V) == Vector.end() ? 
0855k
:
1137k
;
169
993k
    } else {
170
6.15k
      return Set.count(V);
171
6.15k
    }
172
999k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
15.1M
  size_type count(const T &V) const {
166
15.1M
    if (isSmall()) {
167
13.6M
      // Since the collection is small, just do a linear search.
168
13.6M
      return vfind(V) == Vector.end() ? 
012.3M
:
11.24M
;
169
13.6M
    } else {
170
1.50M
      return Set.count(V);
171
1.50M
    }
172
15.1M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
2.87M
  size_type count(const T &V) const {
166
2.87M
    if (isSmall()) {
167
981k
      // Since the collection is small, just do a linear search.
168
981k
      return vfind(V) == Vector.end() ? 
0559k
:
1422k
;
169
1.88M
    } else {
170
1.88M
      return Set.count(V);
171
1.88M
    }
172
2.87M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::count(unsigned long long const&) const
Line
Count
Source
165
2.41k
  size_type count(const T &V) const {
166
2.41k
    if (isSmall()) {
167
2.41k
      // Since the collection is small, just do a linear search.
168
2.41k
      return vfind(V) == Vector.end() ? 
02.39k
:
119
;
169
2.41k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
2.41k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
18.6M
  size_type count(const T &V) const {
166
18.6M
    if (isSmall()) {
167
18.6M
      // Since the collection is small, just do a linear search.
168
18.6M
      return vfind(V) == Vector.end() ? 
09.15M
:
19.52M
;
169
18.6M
    } else {
170
134
      return Set.count(V);
171
134
    }
172
18.6M
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
73
  size_type count(const T &V) const {
166
73
    if (isSmall()) {
167
67
      // Since the collection is small, just do a linear search.
168
67
      return vfind(V) == Vector.end() ? 
061
:
16
;
169
67
    } else {
170
6
      return Set.count(V);
171
6
    }
172
73
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
165
2.97k
  size_type count(const T &V) const {
166
2.97k
    if (isSmall()) {
167
2.76k
      // Since the collection is small, just do a linear search.
168
2.76k
      return vfind(V) == Vector.end() ? 
01.94k
:
1815
;
169
2.76k
    } else {
170
209
      return Set.count(V);
171
209
    }
172
2.97k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::count(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
165
14.9k
  size_type count(const T &V) const {
166
14.9k
    if (isSmall()) {
167
14.9k
      // Since the collection is small, just do a linear search.
168
14.9k
      return vfind(V) == Vector.end() ? 
014.9k
:
14
;
169
14.9k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
14.9k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::count(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
165
14.7k
  size_type count(const T &V) const {
166
14.7k
    if (isSmall()) {
167
13.8k
      // Since the collection is small, just do a linear search.
168
13.8k
      return vfind(V) == Vector.end() ? 
013.8k
:
144
;
169
13.8k
    } else {
170
845
      return Set.count(V);
171
845
    }
172
14.7k
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::count(llvm::SlotIndex const&) const
Line
Count
Source
165
826
  size_type count(const T &V) const {
166
826
    if (isSmall()) {
167
826
      // Since the collection is small, just do a linear search.
168
826
      return vfind(V) == Vector.end() ? 
0577
:
1249
;
169
826
    } else {
170
0
      return Set.count(V);
171
0
    }
172
826
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
165
231k
  size_type count(const T &V) const {
166
231k
    if (isSmall()) {
167
231k
      // Since the collection is small, just do a linear search.
168
231k
      return vfind(V) == Vector.end() ? 
0225k
:
15.68k
;
169
231k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
231k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
165
216k
  size_type count(const T &V) const {
166
216k
    if (isSmall()) {
167
210k
      // Since the collection is small, just do a linear search.
168
210k
      return vfind(V) == Vector.end() ? 
0175k
:
134.9k
;
169
210k
    } else {
170
5.15k
      return Set.count(V);
171
5.15k
    }
172
216k
  }
llvm::SmallSet<std::__1::pair<llvm::DIScope*, llvm::DILocation*>, 5u, std::__1::less<std::__1::pair<llvm::DIScope*, llvm::DILocation*> > >::count(std::__1::pair<llvm::DIScope*, llvm::DILocation*> const&) const
Line
Count
Source
165
396k
  size_type count(const T &V) const {
166
396k
    if (isSmall()) {
167
263k
      // Since the collection is small, just do a linear search.
168
263k
      return vfind(V) == Vector.end() ? 
0124k
:
1139k
;
169
263k
    } else {
170
132k
      return Set.count(V);
171
132k
    }
172
396k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::count(std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> const&) const
Line
Count
Source
165
4.61k
  size_type count(const T &V) const {
166
4.61k
    if (isSmall()) {
167
4.61k
      // Since the collection is small, just do a linear search.
168
4.61k
      return vfind(V) == Vector.end() ? 
01.43k
:
13.18k
;
169
4.61k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
4.61k
  }
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::count(std::__1::pair<clang::SourceLocation, clang::SourceLocation> const&) const
Line
Count
Source
165
1.06k
  size_type count(const T &V) const {
166
1.06k
    if (isSmall()) {
167
874
      // Since the collection is small, just do a linear search.
168
874
      return vfind(V) == Vector.end() ? 
0866
:
18
;
169
874
    } else {
170
190
      return Set.count(V);
171
190
    }
172
1.06k
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::count(clang::CudaArch const&) const
Line
Count
Source
165
55
  size_type count(const T &V) const {
166
55
    if (isSmall()) {
167
55
      // Since the collection is small, just do a linear search.
168
55
      return vfind(V) == Vector.end() ? 
050
:
15
;
169
55
    } else {
170
0
      return Set.count(V);
171
0
    }
172
55
  }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::count(std::__1::pair<clang::IdentifierInfo const*, clang::Selector> const&) const
Line
Count
Source
165
100
  size_type count(const T &V) const {
166
100
    if (isSmall()) {
167
100
      // Since the collection is small, just do a linear search.
168
100
      return vfind(V) == Vector.end() ? 
061
:
139
;
169
100
    } else {
170
0
      return Set.count(V);
171
0
    }
172
100
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::count(clang::Selector const&) const
Line
Count
Source
165
33
  size_type count(const T &V) const {
166
33
    if (isSmall()) {
167
33
      // Since the collection is small, just do a linear search.
168
33
      return vfind(V) == Vector.end() ? 
03
:
130
;
169
33
    } else {
170
0
      return Set.count(V);
171
0
    }
172
33
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::count(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const
Line
Count
Source
165
267
  size_type count(const T &V) const {
166
267
    if (isSmall()) {
167
265
      // Since the collection is small, just do a linear search.
168
265
      return vfind(V) == Vector.end() ? 0 : 
10
;
169
265
    } else {
170
2
      return Set.count(V);
171
2
    }
172
267
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::count(clang::SourceLocation const&) const
Line
Count
Source
165
1.94k
  size_type count(const T &V) const {
166
1.94k
    if (isSmall()) {
167
1.01k
      // Since the collection is small, just do a linear search.
168
1.01k
      return vfind(V) == Vector.end() ? 
0516
:
1503
;
169
1.01k
    } else {
170
921
      return Set.count(V);
171
921
    }
172
1.94k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::count(llvm::DWARFDie const&) const
Line
Count
Source
165
14.4k
  size_type count(const T &V) const {
166
14.4k
    if (isSmall()) {
167
14.4k
      // Since the collection is small, just do a linear search.
168
14.4k
      return vfind(V) == Vector.end() ? 
014.4k
:
12
;
169
14.4k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
14.4k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
55
  size_type count(const T &V) const {
166
55
    if (isSmall()) {
167
55
      // Since the collection is small, just do a linear search.
168
55
      return vfind(V) == Vector.end() ? 
03
:
152
;
169
55
    } else {
170
0
      return Set.count(V);
171
0
    }
172
55
  }
173
174
  /// insert - Insert an element into the set if it isn't already there.
175
  /// Returns true if the element is inserted (it was not in the set before).
176
  /// The first value of the returned pair is unused and provided for
177
  /// partial compatibility with the standard library self-associative container
178
  /// concept.
179
  // FIXME: Add iterators that abstract over the small and large form, and then
180
  // return those here.
181
107M
  std::pair<NoneType, bool> insert(const T &V) {
182
107M
    if (!isSmall())
183
14.8M
      return std::make_pair(None, Set.insert(V).second);
184
92.1M
185
92.1M
    VIterator I = vfind(V);
186
92.1M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
21.7M
      return std::make_pair(None, false);
188
70.4M
    if (Vector.size() < N) {
189
68.8M
      Vector.push_back(V);
190
68.8M
      return std::make_pair(None, true);
191
68.8M
    }
192
1.61M
193
1.61M
    // Otherwise, grow from vector to set.
194
9.12M
    
while (1.61M
!Vector.empty()) {
195
7.50M
      Set.insert(Vector.back());
196
7.50M
      Vector.pop_back();
197
7.50M
    }
198
1.61M
    Set.insert(V);
199
1.61M
    return std::make_pair(None, true);
200
1.61M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
181
592
  std::pair<NoneType, bool> insert(const T &V) {
182
592
    if (!isSmall())
183
66
      return std::make_pair(None, Set.insert(V).second);
184
526
185
526
    VIterator I = vfind(V);
186
526
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
110
      return std::make_pair(None, false);
188
416
    if (Vector.size() < N) {
189
403
      Vector.push_back(V);
190
403
      return std::make_pair(None, true);
191
403
    }
192
13
193
13
    // Otherwise, grow from vector to set.
194
65
    
while (13
!Vector.empty()) {
195
52
      Set.insert(Vector.back());
196
52
      Vector.pop_back();
197
52
    }
198
13
    Set.insert(V);
199
13
    return std::make_pair(None, true);
200
13
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
181
524k
  std::pair<NoneType, bool> insert(const T &V) {
182
524k
    if (!isSmall())
183
15.9k
      return std::make_pair(None, Set.insert(V).second);
184
508k
185
508k
    VIterator I = vfind(V);
186
508k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
5.85k
      return std::make_pair(None, false);
188
502k
    if (Vector.size() < N) {
189
499k
      Vector.push_back(V);
190
499k
      return std::make_pair(None, true);
191
499k
    }
192
2.68k
193
2.68k
    // Otherwise, grow from vector to set.
194
13.4k
    
while (2.68k
!Vector.empty()) {
195
10.7k
      Set.insert(Vector.back());
196
10.7k
      Vector.pop_back();
197
10.7k
    }
198
2.68k
    Set.insert(V);
199
2.68k
    return std::make_pair(None, true);
200
2.68k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
44.5M
  std::pair<NoneType, bool> insert(const T &V) {
182
44.5M
    if (!isSmall())
183
21.2k
      return std::make_pair(None, Set.insert(V).second);
184
44.5M
185
44.5M
    VIterator I = vfind(V);
186
44.5M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
16.0M
      return std::make_pair(None, false);
188
28.4M
    if (Vector.size() < N) {
189
28.4M
      Vector.push_back(V);
190
28.4M
      return std::make_pair(None, true);
191
28.4M
    }
192
2.93k
193
2.93k
    // Otherwise, grow from vector to set.
194
26.3k
    
while (2.93k
!Vector.empty()) {
195
23.4k
      Set.insert(Vector.back());
196
23.4k
      Vector.pop_back();
197
23.4k
    }
198
2.93k
    Set.insert(V);
199
2.93k
    return std::make_pair(None, true);
200
2.93k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
402k
  std::pair<NoneType, bool> insert(const T &V) {
182
402k
    if (!isSmall())
183
2.36k
      return std::make_pair(None, Set.insert(V).second);
184
400k
185
400k
    VIterator I = vfind(V);
186
400k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
109k
      return std::make_pair(None, false);
188
291k
    if (Vector.size() < N) {
189
291k
      Vector.push_back(V);
190
291k
      return std::make_pair(None, true);
191
291k
    }
192
52
193
52
    // Otherwise, grow from vector to set.
194
884
    
while (52
!Vector.empty()) {
195
832
      Set.insert(Vector.back());
196
832
      Vector.pop_back();
197
832
    }
198
52
    Set.insert(V);
199
52
    return std::make_pair(None, true);
200
52
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
17.5M
  std::pair<NoneType, bool> insert(const T &V) {
182
17.5M
    if (!isSmall())
183
5.26M
      return std::make_pair(None, Set.insert(V).second);
184
12.2M
185
12.2M
    VIterator I = vfind(V);
186
12.2M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
1.12M
      return std::make_pair(None, false);
188
11.1M
    if (Vector.size() < N) {
189
9.75M
      Vector.push_back(V);
190
9.75M
      return std::make_pair(None, true);
191
9.75M
    }
192
1.37M
193
1.37M
    // Otherwise, grow from vector to set.
194
6.88M
    
while (1.37M
!Vector.empty()) {
195
5.50M
      Set.insert(Vector.back());
196
5.50M
      Vector.pop_back();
197
5.50M
    }
198
1.37M
    Set.insert(V);
199
1.37M
    return std::make_pair(None, true);
200
1.37M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
3.16M
  std::pair<NoneType, bool> insert(const T &V) {
182
3.16M
    if (!isSmall())
183
1.56M
      return std::make_pair(None, Set.insert(V).second);
184
1.59M
185
1.59M
    VIterator I = vfind(V);
186
1.59M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
134k
      return std::make_pair(None, false);
188
1.46M
    if (Vector.size() < N) {
189
1.32M
      Vector.push_back(V);
190
1.32M
      return std::make_pair(None, true);
191
1.32M
    }
192
140k
193
140k
    // Otherwise, grow from vector to set.
194
421k
    
while (140k
!Vector.empty()) {
195
281k
      Set.insert(Vector.back());
196
281k
      Vector.pop_back();
197
281k
    }
198
140k
    Set.insert(V);
199
140k
    return std::make_pair(None, true);
200
140k
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::insert(unsigned long long const&)
Line
Count
Source
181
2.38k
  std::pair<NoneType, bool> insert(const T &V) {
182
2.38k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
2.38k
185
2.38k
    VIterator I = vfind(V);
186
2.38k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
2.38k
    if (Vector.size() < N) {
189
2.38k
      Vector.push_back(V);
190
2.38k
      return std::make_pair(None, true);
191
2.38k
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
33.4M
  std::pair<NoneType, bool> insert(const T &V) {
182
33.4M
    if (!isSmall())
183
4.62M
      return std::make_pair(None, Set.insert(V).second);
184
28.8M
185
28.8M
    VIterator I = vfind(V);
186
28.8M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
3.02M
      return std::make_pair(None, false);
188
25.8M
    if (Vector.size() < N) {
189
25.7M
      Vector.push_back(V);
190
25.7M
      return std::make_pair(None, true);
191
25.7M
    }
192
39.2k
193
39.2k
    // Otherwise, grow from vector to set.
194
1.29M
    
while (39.2k
!Vector.empty()) {
195
1.25M
      Set.insert(Vector.back());
196
1.25M
      Vector.pop_back();
197
1.25M
    }
198
39.2k
    Set.insert(V);
199
39.2k
    return std::make_pair(None, true);
200
39.2k
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
12
  std::pair<NoneType, bool> insert(const T &V) {
182
12
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
12
185
12
    VIterator I = vfind(V);
186
12
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
12
    if (Vector.size() < N) {
189
9
      Vector.push_back(V);
190
9
      return std::make_pair(None, true);
191
9
    }
192
3
193
3
    // Otherwise, grow from vector to set.
194
6
    
while (3
!Vector.empty()) {
195
3
      Set.insert(Vector.back());
196
3
      Vector.pop_back();
197
3
    }
198
3
    Set.insert(V);
199
3
    return std::make_pair(None, true);
200
3
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
181
12.5k
  std::pair<NoneType, bool> insert(const T &V) {
182
12.5k
    if (!isSmall())
183
2.40k
      return std::make_pair(None, Set.insert(V).second);
184
10.1k
185
10.1k
    VIterator I = vfind(V);
186
10.1k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
4.12k
      return std::make_pair(None, false);
188
5.98k
    if (Vector.size() < N) {
189
5.90k
      Vector.push_back(V);
190
5.90k
      return std::make_pair(None, true);
191
5.90k
    }
192
85
193
85
    // Otherwise, grow from vector to set.
194
765
    
while (85
!Vector.empty()) {
195
680
      Set.insert(Vector.back());
196
680
      Vector.pop_back();
197
680
    }
198
85
    Set.insert(V);
199
85
    return std::make_pair(None, true);
200
85
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
181
264k
  std::pair<NoneType, bool> insert(const T &V) {
182
264k
    if (!isSmall())
183
36.1k
      return std::make_pair(None, Set.insert(V).second);
184
228k
185
228k
    VIterator I = vfind(V);
186
228k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
131k
      return std::make_pair(None, false);
188
97.2k
    if (Vector.size() < N) {
189
93.6k
      Vector.push_back(V);
190
93.6k
      return std::make_pair(None, true);
191
93.6k
    }
192
3.53k
193
3.53k
    // Otherwise, grow from vector to set.
194
31.8k
    
while (3.53k
!Vector.empty()) {
195
28.3k
      Set.insert(Vector.back());
196
28.3k
      Vector.pop_back();
197
28.3k
    }
198
3.53k
    Set.insert(V);
199
3.53k
    return std::make_pair(None, true);
200
3.53k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::insert(llvm::AssertingVH<llvm::MemoryPhi> const&)
Line
Count
Source
181
48
  std::pair<NoneType, bool> insert(const T &V) {
182
48
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
48
185
48
    VIterator I = vfind(V);
186
48
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
48
    if (Vector.size() < N) {
189
48
      Vector.push_back(V);
190
48
      return std::make_pair(None, true);
191
48
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<std::__1::pair<llvm::PHINode*, llvm::PHINode*>, 8u, std::__1::less<std::__1::pair<llvm::PHINode*, llvm::PHINode*> > >::insert(std::__1::pair<llvm::PHINode*, llvm::PHINode*> const&)
Line
Count
Source
181
16.0k
  std::pair<NoneType, bool> insert(const T &V) {
182
16.0k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
16.0k
185
16.0k
    VIterator I = vfind(V);
186
16.0k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
16.0k
    if (Vector.size() < N) {
189
16.0k
      Vector.push_back(V);
190
16.0k
      return std::make_pair(None, true);
191
16.0k
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::insert(llvm::AssertingVH<llvm::Value> const&)
Line
Count
Source
181
182
  std::pair<NoneType, bool> insert(const T &V) {
182
182
    if (!isSmall())
183
64
      return std::make_pair(None, Set.insert(V).second);
184
118
185
118
    VIterator I = vfind(V);
186
118
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
118
    if (Vector.size() < N) {
189
90
      Vector.push_back(V);
190
90
      return std::make_pair(None, true);
191
90
    }
192
28
193
28
    // Otherwise, grow from vector to set.
194
84
    
while (28
!Vector.empty()) {
195
56
      Set.insert(Vector.back());
196
56
      Vector.pop_back();
197
56
    }
198
28
    Set.insert(V);
199
28
    return std::make_pair(None, true);
200
28
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::insert(llvm::SlotIndex const&)
Line
Count
Source
181
249
  std::pair<NoneType, bool> insert(const T &V) {
182
249
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
249
185
249
    VIterator I = vfind(V);
186
249
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
249
    if (Vector.size() < N) {
189
249
      Vector.push_back(V);
190
249
      return std::make_pair(None, true);
191
249
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
181
5.68k
  std::pair<NoneType, bool> insert(const T &V) {
182
5.68k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
5.68k
185
5.68k
    VIterator I = vfind(V);
186
5.68k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
5.68k
    if (Vector.size() < N) {
189
5.68k
      Vector.push_back(V);
190
5.68k
      return std::make_pair(None, true);
191
5.68k
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
181
17.7k
  std::pair<NoneType, bool> insert(const T &V) {
182
17.7k
    if (!isSmall())
183
504
      return std::make_pair(None, Set.insert(V).second);
184
17.2k
185
17.2k
    VIterator I = vfind(V);
186
17.2k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
17.2k
    if (Vector.size() < N) {
189
17.2k
      Vector.push_back(V);
190
17.2k
      return std::make_pair(None, true);
191
17.2k
    }
192
24
193
24
    // Otherwise, grow from vector to set.
194
792
    
while (24
!Vector.empty()) {
195
768
      Set.insert(Vector.back());
196
768
      Vector.pop_back();
197
768
    }
198
24
    Set.insert(V);
199
24
    return std::make_pair(None, true);
200
24
  }
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::insert(std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> const&)
Line
Count
Source
181
429k
  std::pair<NoneType, bool> insert(const T &V) {
182
429k
    if (!isSmall())
183
83.7k
      return std::make_pair(None, Set.insert(V).second);
184
345k
185
345k
    VIterator I = vfind(V);
186
345k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
88.8k
      return std::make_pair(None, false);
188
257k
    if (Vector.size() < N) {
189
252k
      Vector.push_back(V);
190
252k
      return std::make_pair(None, true);
191
252k
    }
192
4.19k
193
4.19k
    // Otherwise, grow from vector to set.
194
37.7k
    
while (4.19k
!Vector.empty()) {
195
33.5k
      Set.insert(Vector.back());
196
33.5k
      Vector.pop_back();
197
33.5k
    }
198
4.19k
    Set.insert(V);
199
4.19k
    return std::make_pair(None, true);
200
4.19k
  }
llvm::SmallSet<std::__1::pair<llvm::DIScope*, llvm::DILocation*>, 5u, std::__1::less<std::__1::pair<llvm::DIScope*, llvm::DILocation*> > >::insert(std::__1::pair<llvm::DIScope*, llvm::DILocation*> const&)
Line
Count
Source
181
674k
  std::pair<NoneType, bool> insert(const T &V) {
182
674k
    if (!isSmall())
183
86.4k
      return std::make_pair(None, Set.insert(V).second);
184
587k
185
587k
    VIterator I = vfind(V);
186
587k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
587k
    if (Vector.size() < N) {
189
544k
      Vector.push_back(V);
190
544k
      return std::make_pair(None, true);
191
544k
    }
192
43.2k
193
43.2k
    // Otherwise, grow from vector to set.
194
259k
    
while (43.2k
!Vector.empty()) {
195
216k
      Set.insert(Vector.back());
196
216k
      Vector.pop_back();
197
216k
    }
198
43.2k
    Set.insert(V);
199
43.2k
    return std::make_pair(None, true);
200
43.2k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::insert(std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> const&)
Line
Count
Source
181
664
  std::pair<NoneType, bool> insert(const T &V) {
182
664
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
664
185
664
    VIterator I = vfind(V);
186
664
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
664
    if (Vector.size() < N) {
189
664
      Vector.push_back(V);
190
664
      return std::make_pair(None, true);
191
664
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
181
230k
  std::pair<NoneType, bool> insert(const T &V) {
182
230k
    if (!isSmall())
183
450
      return std::make_pair(None, Set.insert(V).second);
184
229k
185
229k
    VIterator I = vfind(V);
186
229k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
31.9k
      return std::make_pair(None, false);
188
197k
    if (Vector.size() < N) {
189
197k
      Vector.push_back(V);
190
197k
      return std::make_pair(None, true);
191
197k
    }
192
76
193
76
    // Otherwise, grow from vector to set.
194
684
    
while (76
!Vector.empty()) {
195
608
      Set.insert(Vector.back());
196
608
      Vector.pop_back();
197
608
    }
198
76
    Set.insert(V);
199
76
    return std::make_pair(None, true);
200
76
  }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::insert(std::__1::pair<unsigned long, long long> const&)
Line
Count
Source
181
4.78M
  std::pair<NoneType, bool> insert(const T &V) {
182
4.78M
    if (!isSmall())
183
3.15M
      return std::make_pair(None, Set.insert(V).second);
184
1.62M
185
1.62M
    VIterator I = vfind(V);
186
1.62M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
981k
      return std::make_pair(None, false);
188
640k
    if (Vector.size() < N) {
189
636k
      Vector.push_back(V);
190
636k
      return std::make_pair(None, true);
191
636k
    }
192
4.35k
193
4.35k
    // Otherwise, grow from vector to set.
194
143k
    
while (4.35k
!Vector.empty()) {
195
139k
      Set.insert(Vector.back());
196
139k
      Vector.pop_back();
197
139k
    }
198
4.35k
    Set.insert(V);
199
4.35k
    return std::make_pair(None, true);
200
4.35k
  }
llvm::SmallSet<std::__1::pair<llvm::Value*, llvm::Value*>, 32u, std::__1::less<std::__1::pair<llvm::Value*, llvm::Value*> > >::insert(std::__1::pair<llvm::Value*, llvm::Value*> const&)
Line
Count
Source
181
866k
  std::pair<NoneType, bool> insert(const T &V) {
182
866k
    if (!isSmall())
183
344
      return std::make_pair(None, Set.insert(V).second);
184
865k
185
865k
    VIterator I = vfind(V);
186
865k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
651
      return std::make_pair(None, false);
188
865k
    if (Vector.size() < N) {
189
865k
      Vector.push_back(V);
190
865k
      return std::make_pair(None, true);
191
865k
    }
192
100
193
100
    // Otherwise, grow from vector to set.
194
3.26k
    
while (100
!Vector.empty()) {
195
3.16k
      Set.insert(Vector.back());
196
3.16k
      Vector.pop_back();
197
3.16k
    }
198
100
    Set.insert(V);
199
100
    return std::make_pair(None, true);
200
100
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::insert(llvm::AssertingVH<llvm::Function> const&)
Line
Count
Source
181
40.6k
  std::pair<NoneType, bool> insert(const T &V) {
182
40.6k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
40.6k
185
40.6k
    VIterator I = vfind(V);
186
40.6k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
40.6k
    
if (40.6k
Vector.size() < N40.6k
) {
189
40.6k
      Vector.push_back(V);
190
40.6k
      return std::make_pair(None, true);
191
40.6k
    }
192
18.4E
193
18.4E
    // Otherwise, grow from vector to set.
194
18.4E
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
18.4E
    Set.insert(V);
199
18.4E
    return std::make_pair(None, true);
200
18.4E
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
181
169
  std::pair<NoneType, bool> insert(const T &V) {
182
169
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
169
185
169
    VIterator I = vfind(V);
186
169
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
34
      return std::make_pair(None, false);
188
135
    if (Vector.size() < N) {
189
135
      Vector.push_back(V);
190
135
      return std::make_pair(None, true);
191
135
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::insert(clang::FileID const&)
Line
Count
Source
181
1.07k
  std::pair<NoneType, bool> insert(const T &V) {
182
1.07k
    if (!isSmall())
183
97
      return std::make_pair(None, Set.insert(V).second);
184
978
185
978
    VIterator I = vfind(V);
186
978
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
690
      return std::make_pair(None, false);
188
288
    if (Vector.size() < N) {
189
282
      Vector.push_back(V);
190
282
      return std::make_pair(None, true);
191
282
    }
192
6
193
6
    // Otherwise, grow from vector to set.
194
54
    
while (6
!Vector.empty()) {
195
48
      Set.insert(Vector.back());
196
48
      Vector.pop_back();
197
48
    }
198
6
    Set.insert(V);
199
6
    return std::make_pair(None, true);
200
6
  }
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::insert(std::__1::pair<clang::SourceLocation, clang::SourceLocation> const&)
Line
Count
Source
181
138
  std::pair<NoneType, bool> insert(const T &V) {
182
138
    if (!isSmall())
183
21
      return std::make_pair(None, Set.insert(V).second);
184
117
185
117
    VIterator I = vfind(V);
186
117
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
117
    if (Vector.size() < N) {
189
113
      Vector.push_back(V);
190
113
      return std::make_pair(None, true);
191
113
    }
192
4
193
4
    // Otherwise, grow from vector to set.
194
36
    
while (4
!Vector.empty()) {
195
32
      Set.insert(Vector.back());
196
32
      Vector.pop_back();
197
32
    }
198
4
    Set.insert(V);
199
4
    return std::make_pair(None, true);
200
4
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::insert(clang::CudaArch const&)
Line
Count
Source
181
7
  std::pair<NoneType, bool> insert(const T &V) {
182
7
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
7
185
7
    VIterator I = vfind(V);
186
7
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
7
    if (Vector.size() < N) {
189
7
      Vector.push_back(V);
190
7
      return std::make_pair(None, true);
191
7
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::insert(std::__1::pair<llvm::SCEV const*, llvm::Type*> const&)
Line
Count
Source
181
115
  std::pair<NoneType, bool> insert(const T &V) {
182
115
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
115
185
115
    VIterator I = vfind(V);
186
115
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
4
      return std::make_pair(None, false);
188
111
    if (Vector.size() < N) {
189
111
      Vector.push_back(V);
190
111
      return std::make_pair(None, true);
191
111
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
181
13.0k
  std::pair<NoneType, bool> insert(const T &V) {
182
13.0k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
13.0k
185
13.0k
    VIterator I = vfind(V);
186
13.0k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
6.47k
      return std::make_pair(None, false);
188
6.58k
    if (Vector.size() < N) {
189
6.58k
      Vector.push_back(V);
190
6.58k
      return std::make_pair(None, true);
191
6.58k
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::insert(std::__1::pair<clang::IdentifierInfo const*, clang::Selector> const&)
Line
Count
Source
181
14
  std::pair<NoneType, bool> insert(const T &V) {
182
14
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
14
185
14
    VIterator I = vfind(V);
186
14
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
14
    if (Vector.size() < N) {
189
14
      Vector.push_back(V);
190
14
      return std::make_pair(None, true);
191
14
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<std::__1::pair<void const*, void const*>, 4u, std::__1::less<std::__1::pair<void const*, void const*> > >::insert(std::__1::pair<void const*, void const*> const&)
Line
Count
Source
181
248
  std::pair<NoneType, bool> insert(const T &V) {
182
248
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
248
185
248
    VIterator I = vfind(V);
186
248
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
53
      return std::make_pair(None, false);
188
195
    if (Vector.size() < N) {
189
195
      Vector.push_back(V);
190
195
      return std::make_pair(None, true);
191
195
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::insert(clang::Selector const&)
Line
Count
Source
181
90
  std::pair<NoneType, bool> insert(const T &V) {
182
90
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
90
185
90
    VIterator I = vfind(V);
186
90
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
90
    if (Vector.size() < N) {
189
90
      Vector.push_back(V);
190
90
      return std::make_pair(None, true);
191
90
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
181
118
  std::pair<NoneType, bool> insert(const T &V) {
182
118
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
118
185
118
    VIterator I = vfind(V);
186
118
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
1
      return std::make_pair(None, false);
188
117
    if (Vector.size() < N) {
189
117
      Vector.push_back(V);
190
117
      return std::make_pair(None, true);
191
117
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::insert(clang::DeclarationName const&)
Line
Count
Source
181
3.63k
  std::pair<NoneType, bool> insert(const T &V) {
182
3.63k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
3.63k
185
3.63k
    VIterator I = vfind(V);
186
3.63k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
3.63k
    if (Vector.size() < N) {
189
3.63k
      Vector.push_back(V);
190
3.63k
      return std::make_pair(None, true);
191
3.63k
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::insert(clang::CanonicalDeclPtr<clang::FunctionDecl> const&)
Line
Count
Source
181
1.57k
  std::pair<NoneType, bool> insert(const T &V) {
182
1.57k
    if (!isSmall())
183
2
      return std::make_pair(None, Set.insert(V).second);
184
1.57k
185
1.57k
    VIterator I = vfind(V);
186
1.57k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
1.57k
    if (Vector.size() < N) {
189
1.57k
      Vector.push_back(V);
190
1.57k
      return std::make_pair(None, true);
191
1.57k
    }
192
3
193
3
    // Otherwise, grow from vector to set.
194
15
    
while (3
!Vector.empty()) {
195
12
      Set.insert(Vector.back());
196
12
      Vector.pop_back();
197
12
    }
198
3
    Set.insert(V);
199
3
    return std::make_pair(None, true);
200
3
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
181
1.35k
  std::pair<NoneType, bool> insert(const T &V) {
182
1.35k
    if (!isSmall())
183
169
      return std::make_pair(None, Set.insert(V).second);
184
1.18k
185
1.18k
    VIterator I = vfind(V);
186
1.18k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
1.18k
    if (Vector.size() < N) {
189
1.11k
      Vector.push_back(V);
190
1.11k
      return std::make_pair(None, true);
191
1.11k
    }
192
72
193
72
    // Otherwise, grow from vector to set.
194
216
    
while (72
!Vector.empty()) {
195
144
      Set.insert(Vector.back());
196
144
      Vector.pop_back();
197
144
    }
198
72
    Set.insert(V);
199
72
    return std::make_pair(None, true);
200
72
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::insert(llvm::DWARFDie const&)
Line
Count
Source
181
14.4k
  std::pair<NoneType, bool> insert(const T &V) {
182
14.4k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
14.4k
185
14.4k
    VIterator I = vfind(V);
186
14.4k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
14.4k
    if (Vector.size() < N) {
189
14.4k
      Vector.push_back(V);
190
14.4k
      return std::make_pair(None, true);
191
14.4k
    }
192
1
193
1
    // Otherwise, grow from vector to set.
194
4
    
while (1
!Vector.empty()) {
195
3
      Set.insert(Vector.back());
196
3
      Vector.pop_back();
197
3
    }
198
1
    Set.insert(V);
199
1
    return std::make_pair(None, true);
200
1
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
59
  std::pair<NoneType, bool> insert(const T &V) {
182
59
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
59
185
59
    VIterator I = vfind(V);
186
59
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
2
      return std::make_pair(None, false);
188
57
    if (Vector.size() < N) {
189
57
      Vector.push_back(V);
190
57
      return std::make_pair(None, true);
191
57
    }
192
0
193
0
    // Otherwise, grow from vector to set.
194
0
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
0
    Set.insert(V);
199
0
    return std::make_pair(None, true);
200
0
  }
201
202
  template <typename IterT>
203
88.2k
  void insert(IterT I, IterT E) {
204
729k
    for (; I != E; 
++I641k
)
205
641k
      insert(*I);
206
88.2k
  }
207
208
905k
  bool erase(const T &V) {
209
905k
    if (!isSmall())
210
470k
      return Set.erase(V);
211
809k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 434k
I != E;
++I374k
)
212
418k
      if (*I == V) {
213
43.2k
        Vector.erase(I);
214
43.2k
        return true;
215
43.2k
      }
216
434k
    
return false391k
;
217
434k
  }
Unexecuted instantiation: llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::erase(llvm::AssertingVH<llvm::MemoryPhi> const&)
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
871k
  bool erase(const T &V) {
209
871k
    if (!isSmall())
210
470k
      return Set.erase(V);
211
770k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 400k
I != E;
++I369k
)
212
400k
      if (*I == V) {
213
31.0k
        Vector.erase(I);
214
31.0k
        return true;
215
31.0k
      }
216
400k
    
return false369k
;
217
400k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
3.64k
  bool erase(const T &V) {
209
3.64k
    if (!isSmall())
210
0
      return Set.erase(V);
211
4.58k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 3.64k
I != E;
++I939
)
212
1.20k
      if (*I == V) {
213
270
        Vector.erase(I);
214
270
        return true;
215
270
      }
216
3.64k
    
return false3.37k
;
217
3.64k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
10.9k
  bool erase(const T &V) {
209
10.9k
    if (!isSmall())
210
265
      return Set.erase(V);
211
13.0k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 10.7k
I != E;
++I2.34k
)
212
10.1k
      if (*I == V) {
213
7.75k
        Vector.erase(I);
214
7.75k
        return true;
215
7.75k
      }
216
10.7k
    
return false2.95k
;
217
10.7k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
11.3k
  bool erase(const T &V) {
209
11.3k
    if (!isSmall())
210
0
      return Set.erase(V);
211
13.1k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 11.3k
I != E;
++I1.76k
)
212
2.29k
      if (*I == V) {
213
536
        Vector.erase(I);
214
536
        return true;
215
536
      }
216
11.3k
    
return false10.8k
;
217
11.3k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::erase(clang::DeclarationName const&)
Line
Count
Source
208
8.39k
  bool erase(const T &V) {
209
8.39k
    if (!isSmall())
210
0
      return Set.erase(V);
211
8.41k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 8.39k
I != E;
++I16
)
212
3.64k
      if (*I == V) {
213
3.63k
        Vector.erase(I);
214
3.63k
        return true;
215
3.63k
      }
216
8.39k
    
return false4.76k
;
217
8.39k
  }
218
219
8.71M
  void clear() {
220
8.71M
    Vector.clear();
221
8.71M
    Set.clear();
222
8.71M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
24.5k
  void clear() {
220
24.5k
    Vector.clear();
221
24.5k
    Set.clear();
222
24.5k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
23.8k
  void clear() {
220
23.8k
    Vector.clear();
221
23.8k
    Set.clear();
222
23.8k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
5.73M
  void clear() {
220
5.73M
    Vector.clear();
221
5.73M
    Set.clear();
222
5.73M
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::clear()
Line
Count
Source
219
5.30k
  void clear() {
220
5.30k
    Vector.clear();
221
5.30k
    Set.clear();
222
5.30k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
1.08M
  void clear() {
220
1.08M
    Vector.clear();
221
1.08M
    Set.clear();
222
1.08M
  }
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::clear()
Line
Count
Source
219
1.05M
  void clear() {
220
1.05M
    Vector.clear();
221
1.05M
    Set.clear();
222
1.05M
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::clear()
Line
Count
Source
219
251
  void clear() {
220
251
    Vector.clear();
221
251
    Set.clear();
222
251
  }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::clear()
Line
Count
Source
219
102k
  void clear() {
220
102k
    Vector.clear();
221
102k
    Set.clear();
222
102k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::clear()
Line
Count
Source
219
102k
  void clear() {
220
102k
    Vector.clear();
221
102k
    Set.clear();
222
102k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::clear()
Line
Count
Source
219
580k
  void clear() {
220
580k
    Vector.clear();
221
580k
    Set.clear();
222
580k
  }
223
224
580k
  const_iterator begin() const {
225
580k
    if (isSmall())
226
580k
      return {Vector.begin()};
227
0
    return {Set.begin()};
228
0
  }
229
230
580k
  const_iterator end() const {
231
580k
    if (isSmall())
232
580k
      return {Vector.end()};
233
0
    return {Set.end()};
234
0
  }
235
236
private:
237
151M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 4u, std::__1::less<int> >::isSmall() const
Line
Count
Source
237
3.01k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
237
840k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
47.7M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
1.41M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
33.5M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
6.04M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
237
4.80k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
52.1M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
85
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
237
15.4k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
237
288k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::isSmall() const
Line
Count
Source
237
15.0k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::isSmall() const
Line
Count
Source
237
14.9k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::PHINode*, llvm::PHINode*>, 8u, std::__1::less<std::__1::pair<llvm::PHINode*, llvm::PHINode*> > >::isSmall() const
Line
Count
Source
237
16.0k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::isSmall() const
Line
Count
Source
237
1.07k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 16u, std::__1::less<int> >::isSmall() const
Line
Count
Source
237
236k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 32u, std::__1::less<int> >::isSmall() const
Line
Count
Source
237
233k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::isSmall() const
Line
Count
Source
237
429k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::DIScope*, llvm::DILocation*>, 5u, std::__1::less<std::__1::pair<llvm::DIScope*, llvm::DILocation*> > >::isSmall() const
Line
Count
Source
237
1.07M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::isSmall() const
Line
Count
Source
237
5.27k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
237
230k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::isSmall() const
Line
Count
Source
237
4.78M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::Value*, llvm::Value*>, 32u, std::__1::less<std::__1::pair<llvm::Value*, llvm::Value*> > >::isSmall() const
Line
Count
Source
237
866k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::isSmall() const
Line
Count
Source
237
1.20M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
237
169
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::isSmall() const
Line
Count
Source
237
1.07k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::isSmall() const
Line
Count
Source
237
1.20k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::isSmall() const
Line
Count
Source
237
62
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::isSmall() const
Line
Count
Source
237
115
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
237
15.5k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::isSmall() const
Line
Count
Source
237
114
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<void const*, void const*>, 4u, std::__1::less<std::__1::pair<void const*, void const*> > >::isSmall() const
Line
Count
Source
237
248
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::isSmall() const
Line
Count
Source
237
123
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
237
281
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::isSmall() const
Line
Count
Source
237
12.0k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::isSmall() const
Line
Count
Source
237
1.84k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
237
3.29k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::isSmall() const
Line
Count
Source
237
28.9k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
114
  bool isSmall() const { return Set.empty(); }
238
239
130M
  VIterator vfind(const T &V) const {
240
347M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I217M
)
241
250M
      if (*I == V)
242
33.8M
        return I;
243
130M
    
return Vector.end()96.5M
;
244
130M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
2.61k
  VIterator vfind(const T &V) const {
240
3.60k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I998
)
241
1.54k
      if (*I == V)
242
542
        return I;
243
2.61k
    
return Vector.end()2.06k
;
244
2.61k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
239
508k
  VIterator vfind(const T &V) const {
240
767k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I258k
)
241
264k
      if (*I == V)
242
5.85k
        return I;
243
508k
    
return Vector.end()502k
;
244
508k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
47.6M
  VIterator vfind(const T &V) const {
240
120M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I72.6M
)
241
89.3M
      if (*I == V)
242
16.6M
        return I;
243
47.6M
    
return Vector.end()31.0M
;
244
47.6M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
1.39M
  VIterator vfind(const T &V) const {
240
4.35M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.96M
)
241
3.21M
      if (*I == V)
242
247k
        return I;
243
1.39M
    
return Vector.end()1.14M
;
244
1.39M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
25.8M
  VIterator vfind(const T &V) const {
240
48.6M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I22.7M
)
241
25.1M
      if (*I == V)
242
2.36M
        return I;
243
25.8M
    
return Vector.end()23.5M
;
244
25.8M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
2.57M
  VIterator vfind(const T &V) const {
240
4.21M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.63M
)
241
2.19M
      if (*I == V)
242
556k
        return I;
243
2.57M
    
return Vector.end()2.02M
;
244
2.57M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
239
4.80k
  VIterator vfind(const T &V) const {
240
5.28k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I481
)
241
500
      if (*I == V)
242
19
        return I;
243
4.80k
    
return Vector.end()4.78k
;
244
4.80k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
47.5M
  VIterator vfind(const T &V) const {
240
150M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I103M
)
241
115M
      if (*I == V)
242
12.5M
        return I;
243
47.5M
    
return Vector.end()34.9M
;
244
47.5M
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
79
  VIterator vfind(const T &V) const {
240
84
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
241
11
      if (*I == V)
242
6
        return I;
243
79
    
return Vector.end()73
;
244
79
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
239
12.8k
  VIterator vfind(const T &V) const {
240
44.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I32.0k
)
241
36.9k
      if (*I == V)
242
4.93k
        return I;
243
12.8k
    
return Vector.end()7.93k
;
244
12.8k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
239
228k
  VIterator vfind(const T &V) const {
240
577k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I348k
)
241
480k
      if (*I == V)
242
131k
        return I;
243
228k
    
return Vector.end()97.2k
;
244
228k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::vfind(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
239
15.0k
  VIterator vfind(const T &V) const {
240
15.0k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I15
)
241
19
      if (*I == V)
242
4
        return I;
243
15.0k
    
return Vector.end()15.0k
;
244
15.0k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::vfind(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
239
14.0k
  VIterator vfind(const T &V) const {
240
16.5k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.50k
)
241
2.55k
      if (*I == V)
242
44
        return I;
243
14.0k
    
return Vector.end()13.9k
;
244
14.0k
  }
llvm::SmallSet<std::__1::pair<llvm::PHINode*, llvm::PHINode*>, 8u, std::__1::less<std::__1::pair<llvm::PHINode*, llvm::PHINode*> > >::vfind(std::__1::pair<llvm::PHINode*, llvm::PHINode*> const&) const
Line
Count
Source
239
16.0k
  VIterator vfind(const T &V) const {
240
16.0k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I24
)
241
24
      if (*I == V)
242
0
        return I;
243
16.0k
    return Vector.end();
244
16.0k
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::vfind(llvm::SlotIndex const&) const
Line
Count
Source
239
1.07k
  VIterator vfind(const T &V) const {
240
1.27k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I203
)
241
452
      if (*I == V)
242
249
        return I;
243
1.07k
    
return Vector.end()826
;
244
1.07k
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
236k
  VIterator vfind(const T &V) const {
240
262k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I25.4k
)
241
31.1k
      if (*I == V)
242
5.68k
        return I;
243
236k
    
return Vector.end()231k
;
244
236k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
228k
  VIterator vfind(const T &V) const {
240
638k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I410k
)
241
445k
      if (*I == V)
242
34.9k
        return I;
243
228k
    
return Vector.end()193k
;
244
228k
  }
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::vfind(std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> const&) const
Line
Count
Source
239
345k
  VIterator vfind(const T &V) const {
240
883k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I537k
)
241
626k
      if (*I == V)
242
88.8k
        return I;
243
345k
    
return Vector.end()257k
;
244
345k
  }
llvm::SmallSet<std::__1::pair<llvm::DIScope*, llvm::DILocation*>, 5u, std::__1::less<std::__1::pair<llvm::DIScope*, llvm::DILocation*> > >::vfind(std::__1::pair<llvm::DIScope*, llvm::DILocation*> const&) const
Line
Count
Source
239
851k
  VIterator vfind(const T &V) const {
240
2.11M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.25M
)
241
1.39M
      if (*I == V)
242
139k
        return I;
243
851k
    
return Vector.end()711k
;
244
851k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*>, 32u, std::__1::less<std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> > >::vfind(std::__1::pair<llvm::BasicBlock const*, llvm::BasicBlock const*> const&) const
Line
Count
Source
239
5.27k
  VIterator vfind(const T &V) const {
240
25.7k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I20.4k
)
241
23.6k
      if (*I == V)
242
3.18k
        return I;
243
5.27k
    
return Vector.end()2.09k
;
244
5.27k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
239
229k
  VIterator vfind(const T &V) const {
240
515k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I286k
)
241
318k
      if (*I == V)
242
31.9k
        return I;
243
229k
    
return Vector.end()197k
;
244
229k
  }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::vfind(std::__1::pair<unsigned long, long long> const&) const
Line
Count
Source
239
1.62M
  VIterator vfind(const T &V) const {
240
11.8M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I10.1M
)
241
11.1M
      if (*I == V)
242
981k
        return I;
243
1.62M
    
return Vector.end()640k
;
244
1.62M
  }
llvm::SmallSet<std::__1::pair<llvm::Value*, llvm::Value*>, 32u, std::__1::less<std::__1::pair<llvm::Value*, llvm::Value*> > >::vfind(std::__1::pair<llvm::Value*, llvm::Value*> const&) const
Line
Count
Source
239
865k
  VIterator vfind(const T &V) const {
240
1.21M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I353k
)
241
353k
      if (*I == V)
242
651
        return I;
243
865k
    
return Vector.end()865k
;
244
865k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::vfind(llvm::AssertingVH<llvm::Function> const&) const
Line
Count
Source
239
40.6k
  VIterator vfind(const T &V) const {
240
55.6k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I14.9k
)
241
14.9k
      if (*I == V)
242
0
        return I;
243
40.6k
    return Vector.end();
244
40.6k
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
239
169
  VIterator vfind(const T &V) const {
240
197
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I28
)
241
62
      if (*I == V)
242
34
        return I;
243
169
    
return Vector.end()135
;
244
169
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::vfind(clang::FileID const&) const
Line
Count
Source
239
978
  VIterator vfind(const T &V) const {
240
1.79k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I819
)
241
1.50k
      if (*I == V)
242
690
        return I;
243
978
    
return Vector.end()288
;
244
978
  }
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::vfind(std::__1::pair<clang::SourceLocation, clang::SourceLocation> const&) const
Line
Count
Source
239
991
  VIterator vfind(const T &V) const {
240
2.45k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.46k
)
241
1.46k
      if (*I == V)
242
8
        return I;
243
991
    
return Vector.end()983
;
244
991
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::vfind(clang::CudaArch const&) const
Line
Count
Source
239
62
  VIterator vfind(const T &V) const {
240
65
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3
)
241
8
      if (*I == V)
242
5
        return I;
243
62
    
return Vector.end()57
;
244
62
  }
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::vfind(std::__1::pair<llvm::SCEV const*, llvm::Type*> const&) const
Line
Count
Source
239
115
  VIterator vfind(const T &V) const {
240
262
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I147
)
241
151
      if (*I == V)
242
4
        return I;
243
115
    
return Vector.end()111
;
244
115
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
239
13.0k
  VIterator vfind(const T &V) const {
240
20.3k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I7.29k
)
241
13.7k
      if (*I == V)
242
6.47k
        return I;
243
13.0k
    
return Vector.end()6.58k
;
244
13.0k
  }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::vfind(std::__1::pair<clang::IdentifierInfo const*, clang::Selector> const&) const
Line
Count
Source
239
114
  VIterator vfind(const T &V) const {
240
583
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I469
)
241
508
      if (*I == V)
242
39
        return I;
243
114
    
return Vector.end()75
;
244
114
  }
llvm::SmallSet<std::__1::pair<void const*, void const*>, 4u, std::__1::less<std::__1::pair<void const*, void const*> > >::vfind(std::__1::pair<void const*, void const*> const&) const
Line
Count
Source
239
248
  VIterator vfind(const T &V) const {
240
253
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
241
58
      if (*I == V)
242
53
        return I;
243
248
    
return Vector.end()195
;
244
248
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::vfind(clang::Selector const&) const
Line
Count
Source
239
123
  VIterator vfind(const T &V) const {
240
656
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I533
)
241
563
      if (*I == V)
242
30
        return I;
243
123
    
return Vector.end()93
;
244
123
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
239
281
  VIterator vfind(const T &V) const {
240
805
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I524
)
241
529
      if (*I == V)
242
5
        return I;
243
281
    
return Vector.end()276
;
244
281
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::vfind(clang::DeclarationName const&) const
Line
Count
Source
239
3.63k
  VIterator vfind(const T &V) const {
240
3.66k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I31
)
241
31
      if (*I == V)
242
0
        return I;
243
3.63k
    return Vector.end();
244
3.63k
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::vfind(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const
Line
Count
Source
239
1.84k
  VIterator vfind(const T &V) const {
240
2.32k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I484
)
241
484
      if (*I == V)
242
0
        return I;
243
1.84k
    return Vector.end();
244
1.84k
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
239
2.20k
  VIterator vfind(const T &V) const {
240
3.18k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I977
)
241
1.48k
      if (*I == V)
242
503
        return I;
243
2.20k
    
return Vector.end()1.70k
;
244
2.20k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::vfind(llvm::DWARFDie const&) const
Line
Count
Source
239
28.9k
  VIterator vfind(const T &V) const {
240
29.6k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I648
)
241
650
      if (*I == V)
242
2
        return I;
243
28.9k
    
return Vector.end()28.9k
;
244
28.9k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
114
  VIterator vfind(const T &V) const {
240
149
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I35
)
241
89
      if (*I == V)
242
54
        return I;
243
114
    
return Vector.end()60
;
244
114
  }
245
};
246
247
/// If this set is of pointer values, transparently switch over to using
248
/// SmallPtrSet for performance.
249
template <typename PointeeType, unsigned N>
250
class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
251
252
} // end namespace llvm
253
254
#endif // LLVM_ADT_SMALLSET_H