Coverage Report

Created: 2018-11-16 02:38

/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
9
    else
62
9
      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
622k
  bool operator==(const SmallSetIterator &RHS) const {
112
622k
    if (isSmall != RHS.isSmall)
113
0
      return false;
114
622k
    if (isSmall)
115
622k
      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
92.0M
  SmallSet() = default;
llvm::SmallSet<int, 4u, std::__1::less<int> >::SmallSet()
Line
Count
Source
154
31.5k
  SmallSet() = default;
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
154
344k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
40.7M
  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.7M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
920k
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
154
4.36k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
17.9M
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
154
4.27k
  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.09k
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
154
28.7k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::SmallSet()
Line
Count
Source
154
32.2k
  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.1k
  SmallSet() = default;
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
154
484
  SmallSet() = default;
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::SmallSet()
Line
Count
Source
154
556
  SmallSet() = default;
llvm::SmallSet<int, 16u, std::__1::less<int> >::SmallSet()
Line
Count
Source
154
507k
  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
32.1k
  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
176k
  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
92
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::SmallSet()
Line
Count
Source
154
1.11M
  SmallSet() = default;
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
154
207k
  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
752k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSet()
Line
Count
Source
154
581k
  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.7k
  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
293
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
154
53.9k
  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
21.1k
  SmallSet() = default;
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::SmallSet()
Line
Count
Source
154
1.47k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
154
942
  SmallSet() = default;
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::SmallSet()
Line
Count
Source
154
14.7k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
154
48
  SmallSet() = default;
155
156
27.6M
  LLVM_NODISCARD bool empty() const {
157
27.6M
    return Vector.empty() && 
Set.empty()26.2M
;
158
27.6M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
257
  LLVM_NODISCARD bool empty() const {
157
257
    return Vector.empty() && 
Set.empty()0
;
158
257
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
990k
  LLVM_NODISCARD bool empty() const {
157
990k
    return Vector.empty() && 
Set.empty()478k
;
158
990k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
990k
  LLVM_NODISCARD bool empty() const {
157
990k
    return Vector.empty() && 
Set.empty()486k
;
158
990k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
156
24.7M
  LLVM_NODISCARD bool empty() const {
157
24.7M
    return Vector.empty() && 
Set.empty()24.4M
;
158
24.7M
  }
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()875k
;
158
875k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::empty() const
Line
Count
Source
156
16.8k
  LLVM_NODISCARD bool empty() const {
157
16.8k
    return Vector.empty() && 
Set.empty()14.5k
;
158
16.8k
  }
159
160
360k
  size_type size() const {
161
360k
    return isSmall() ? 
Vector.size()355k
:
Set.size()4.61k
;
162
360k
  }
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()471
;
162
15.5k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
160
26.2k
  size_type size() const {
161
26.2k
    return isSmall() ? 
Vector.size()22.1k
:
Set.size()4.11k
;
162
26.2k
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
160
2.54k
  size_type size() const {
161
2.54k
    return isSmall() ? Vector.size() : 
Set.size()0
;
162
2.54k
  }
163
164
  /// count - Return 1 if the element is in the set, 0 otherwise.
165
42.4M
  size_type count(const T &V) const {
166
42.4M
    if (isSmall()) {
167
38.7M
      // Since the collection is small, just do a linear search.
168
38.7M
      return vfind(V) == Vector.end() ? 
026.4M
:
112.2M
;
169
38.7M
    } else {
170
3.74M
      return Set.count(V);
171
3.74M
    }
172
42.4M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
165
2.36k
  size_type count(const T &V) const {
166
2.36k
    if (isSmall()) {
167
2.06k
      // Since the collection is small, just do a linear search.
168
2.06k
      return vfind(V) == Vector.end() ? 
01.64k
:
1425
;
169
2.06k
    } else {
170
299
      return Set.count(V);
171
299
    }
172
2.36k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
3.15M
  size_type count(const T &V) const {
166
3.15M
    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.15M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
1.02M
  size_type count(const T &V) const {
166
1.02M
    if (isSmall()) {
167
1.01M
      // Since the collection is small, just do a linear search.
168
1.01M
      return vfind(V) == Vector.end() ? 
0873k
:
1141k
;
169
1.01M
    } else {
170
6.92k
      return Set.count(V);
171
6.92k
    }
172
1.02M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
15.5M
  size_type count(const T &V) const {
166
15.5M
    if (isSmall()) {
167
14.0M
      // Since the collection is small, just do a linear search.
168
14.0M
      return vfind(V) == Vector.end() ? 
012.6M
:
11.32M
;
169
14.0M
    } else {
170
1.51M
      return Set.count(V);
171
1.51M
    }
172
15.5M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
3.13M
  size_type count(const T &V) const {
166
3.13M
    if (isSmall()) {
167
1.04M
      // Since the collection is small, just do a linear search.
168
1.04M
      return vfind(V) == Vector.end() ? 
0582k
:
1461k
;
169
2.09M
    } else {
170
2.09M
      return Set.count(V);
171
2.09M
    }
172
3.13M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::count(unsigned long long const&) const
Line
Count
Source
165
2.42k
  size_type count(const T &V) const {
166
2.42k
    if (isSmall()) {
167
2.42k
      // Since the collection is small, just do a linear search.
168
2.42k
      return vfind(V) == Vector.end() ? 
02.40k
:
119
;
169
2.42k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
2.42k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
18.7M
  size_type count(const T &V) const {
166
18.7M
    if (isSmall()) {
167
18.7M
      // Since the collection is small, just do a linear search.
168
18.7M
      return vfind(V) == Vector.end() ? 
09.21M
:
19.57M
;
169
18.7M
    } else {
170
131
      return Set.count(V);
171
131
    }
172
18.7M
  }
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
3.08k
  size_type count(const T &V) const {
166
3.08k
    if (isSmall()) {
167
2.87k
      // Since the collection is small, just do a linear search.
168
2.87k
      return vfind(V) == Vector.end() ? 
02.01k
:
1858
;
169
2.87k
    } else {
170
211
      return Set.count(V);
171
211
    }
172
3.08k
  }
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
56
  size_type count(const T &V) const {
166
56
    if (isSmall()) {
167
56
      // Since the collection is small, just do a linear search.
168
56
      return vfind(V) == Vector.end() ? 
053
:
13
;
169
56
    } else {
170
0
      return Set.count(V);
171
0
    }
172
56
  }
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.6k
  size_type count(const T &V) const {
166
14.6k
    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
829
      return Set.count(V);
171
829
    }
172
14.6k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
165
235
  size_type count(const T &V) const {
166
235
    if (isSmall()) {
167
235
      // Since the collection is small, just do a linear search.
168
235
      return vfind(V) == Vector.end() ? 
0215
:
120
;
169
235
    } else {
170
0
      return Set.count(V);
171
0
    }
172
235
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::count(llvm::SlotIndex const&) const
Line
Count
Source
165
839
  size_type count(const T &V) const {
166
839
    if (isSmall()) {
167
839
      // Since the collection is small, just do a linear search.
168
839
      return vfind(V) == Vector.end() ? 
0584
:
1255
;
169
839
    } else {
170
0
      return Set.count(V);
171
0
    }
172
839
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
165
233k
  size_type count(const T &V) const {
166
233k
    if (isSmall()) {
167
233k
      // Since the collection is small, just do a linear search.
168
233k
      return vfind(V) == Vector.end() ? 
0227k
:
15.69k
;
169
233k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
233k
  }
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
211k
      // Since the collection is small, just do a linear search.
168
211k
      return vfind(V) == Vector.end() ? 
0175k
:
135.3k
;
169
211k
    } else {
170
5.03k
      return Set.count(V);
171
5.03k
    }
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
377k
  size_type count(const T &V) const {
166
377k
    if (isSmall()) {
167
255k
      // Since the collection is small, just do a linear search.
168
255k
      return vfind(V) == Vector.end() ? 
0117k
:
1138k
;
169
255k
    } else {
170
122k
      return Set.count(V);
171
122k
    }
172
377k
  }
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.86k
  size_type count(const T &V) const {
166
4.86k
    if (isSmall()) {
167
4.86k
      // Since the collection is small, just do a linear search.
168
4.86k
      return vfind(V) == Vector.end() ? 
01.52k
:
13.33k
;
169
4.86k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
4.86k
  }
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
56
  size_type count(const T &V) const {
166
56
    if (isSmall()) {
167
56
      // Since the collection is small, just do a linear search.
168
56
      return vfind(V) == Vector.end() ? 
051
:
15
;
169
56
    } else {
170
0
      return Set.count(V);
171
0
    }
172
56
  }
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
278
  size_type count(const T &V) const {
166
278
    if (isSmall()) {
167
276
      // Since the collection is small, just do a linear search.
168
276
      return vfind(V) == Vector.end() ? 0 : 
10
;
169
276
    } else {
170
2
      return Set.count(V);
171
2
    }
172
278
  }
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.02k
      // Since the collection is small, just do a linear search.
168
1.02k
      return vfind(V) == Vector.end() ? 
0516
:
1504
;
169
1.02k
    } 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
15.0k
  size_type count(const T &V) const {
166
15.0k
    if (isSmall()) {
167
15.0k
      // Since the collection is small, just do a linear search.
168
15.0k
      return vfind(V) == Vector.end() ? 
015.0k
:
12
;
169
15.0k
    } else {
170
0
      return Set.count(V);
171
0
    }
172
15.0k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
165
60
  size_type count(const T &V) const {
166
60
    if (isSmall()) {
167
60
      // Since the collection is small, just do a linear search.
168
60
      return vfind(V) == Vector.end() ? 
03
:
157
;
169
60
    } else {
170
0
      return Set.count(V);
171
0
    }
172
60
  }
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
15.1M
      return std::make_pair(None, Set.insert(V).second);
184
92.6M
185
92.6M
    VIterator I = vfind(V);
186
92.6M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
21.7M
      return std::make_pair(None, false);
188
70.8M
    if (Vector.size() < N) {
189
69.2M
      Vector.push_back(V);
190
69.2M
      return std::make_pair(None, true);
191
69.2M
    }
192
1.63M
193
1.63M
    // Otherwise, grow from vector to set.
194
9.15M
    
while (1.63M
!Vector.empty()) {
195
7.52M
      Set.insert(Vector.back());
196
7.52M
      Vector.pop_back();
197
7.52M
    }
198
1.63M
    Set.insert(V);
199
1.63M
    return std::make_pair(None, true);
200
1.63M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
181
589
  std::pair<NoneType, bool> insert(const T &V) {
182
589
    if (!isSmall())
183
65
      return std::make_pair(None, Set.insert(V).second);
184
524
185
524
    VIterator I = vfind(V);
186
524
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
110
      return std::make_pair(None, false);
188
414
    if (Vector.size() < N) {
189
402
      Vector.push_back(V);
190
402
      return std::make_pair(None, true);
191
402
    }
192
12
193
12
    // Otherwise, grow from vector to set.
194
60
    
while (12
!Vector.empty()) {
195
48
      Set.insert(Vector.back());
196
48
      Vector.pop_back();
197
48
    }
198
12
    Set.insert(V);
199
12
    return std::make_pair(None, true);
200
12
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
181
535k
  std::pair<NoneType, bool> insert(const T &V) {
182
535k
    if (!isSmall())
183
24.1k
      return std::make_pair(None, Set.insert(V).second);
184
511k
185
511k
    VIterator I = vfind(V);
186
511k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
5.85k
      return std::make_pair(None, false);
188
505k
    if (Vector.size() < N) {
189
502k
      Vector.push_back(V);
190
502k
      return std::make_pair(None, true);
191
502k
    }
192
3.11k
193
3.11k
    // Otherwise, grow from vector to set.
194
15.5k
    
while (3.11k
!Vector.empty()) {
195
12.4k
      Set.insert(Vector.back());
196
12.4k
      Vector.pop_back();
197
12.4k
    }
198
3.11k
    Set.insert(V);
199
3.11k
    return std::make_pair(None, true);
200
3.11k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
44.7M
  std::pair<NoneType, bool> insert(const T &V) {
182
44.7M
    if (!isSmall())
183
21.2k
      return std::make_pair(None, Set.insert(V).second);
184
44.6M
185
44.6M
    VIterator I = vfind(V);
186
44.6M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
16.1M
      return std::make_pair(None, false);
188
28.5M
    if (Vector.size() < N) {
189
28.5M
      Vector.push_back(V);
190
28.5M
      return std::make_pair(None, true);
191
28.5M
    }
192
2.90k
193
2.90k
    // Otherwise, grow from vector to set.
194
26.3k
    
while (2.90k
!Vector.empty()) {
195
23.4k
      Set.insert(Vector.back());
196
23.4k
      Vector.pop_back();
197
23.4k
    }
198
2.90k
    Set.insert(V);
199
2.90k
    return std::make_pair(None, true);
200
2.90k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
409k
  std::pair<NoneType, bool> insert(const T &V) {
182
409k
    if (!isSmall())
183
2.37k
      return std::make_pair(None, Set.insert(V).second);
184
407k
185
407k
    VIterator I = vfind(V);
186
407k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
110k
      return std::make_pair(None, false);
188
297k
    if (Vector.size() < N) {
189
296k
      Vector.push_back(V);
190
296k
      return std::make_pair(None, true);
191
296k
    }
192
57
193
57
    // Otherwise, grow from vector to set.
194
969
    
while (57
!Vector.empty()) {
195
912
      Set.insert(Vector.back());
196
912
      Vector.pop_back();
197
912
    }
198
57
    Set.insert(V);
199
57
    return std::make_pair(None, true);
200
57
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
17.7M
  std::pair<NoneType, bool> insert(const T &V) {
182
17.7M
    if (!isSmall())
183
5.31M
      return std::make_pair(None, Set.insert(V).second);
184
12.3M
185
12.3M
    VIterator I = vfind(V);
186
12.3M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
1.12M
      return std::make_pair(None, false);
188
11.2M
    if (Vector.size() < N) {
189
9.88M
      Vector.push_back(V);
190
9.88M
      return std::make_pair(None, true);
191
9.88M
    }
192
1.38M
193
1.38M
    // Otherwise, grow from vector to set.
194
6.90M
    
while (1.38M
!Vector.empty()) {
195
5.52M
      Set.insert(Vector.back());
196
5.52M
      Vector.pop_back();
197
5.52M
    }
198
1.38M
    Set.insert(V);
199
1.38M
    return std::make_pair(None, true);
200
1.38M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
181
3.42M
  std::pair<NoneType, bool> insert(const T &V) {
182
3.42M
    if (!isSmall())
183
1.74M
      return std::make_pair(None, Set.insert(V).second);
184
1.68M
185
1.68M
    VIterator I = vfind(V);
186
1.68M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
143k
      return std::make_pair(None, false);
188
1.53M
    if (Vector.size() < N) {
189
1.38M
      Vector.push_back(V);
190
1.38M
      return std::make_pair(None, true);
191
1.38M
    }
192
152k
193
152k
    // Otherwise, grow from vector to set.
194
458k
    
while (152k
!Vector.empty()) {
195
305k
      Set.insert(Vector.back());
196
305k
      Vector.pop_back();
197
305k
    }
198
152k
    Set.insert(V);
199
152k
    return std::make_pair(None, true);
200
152k
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::insert(unsigned long long const&)
Line
Count
Source
181
2.39k
  std::pair<NoneType, bool> insert(const T &V) {
182
2.39k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
2.39k
185
2.39k
    VIterator I = vfind(V);
186
2.39k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
2.39k
    if (Vector.size() < N) {
189
2.39k
      Vector.push_back(V);
190
2.39k
      return std::make_pair(None, true);
191
2.39k
    }
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.6M
  std::pair<NoneType, bool> insert(const T &V) {
182
33.6M
    if (!isSmall())
183
4.63M
      return std::make_pair(None, Set.insert(V).second);
184
28.9M
185
28.9M
    VIterator I = vfind(V);
186
28.9M
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
3.01M
      return std::make_pair(None, false);
188
25.9M
    if (Vector.size() < N) {
189
25.9M
      Vector.push_back(V);
190
25.9M
      return std::make_pair(None, true);
191
25.9M
    }
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 long long, 8u, std::__1::less<unsigned long long> >::insert(unsigned long long 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
0
      return std::make_pair(None, false);
188
59
    if (Vector.size() < N) {
189
59
      Vector.push_back(V);
190
59
      return std::make_pair(None, true);
191
59
    }
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, 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
13.0k
  std::pair<NoneType, bool> insert(const T &V) {
182
13.0k
    if (!isSmall())
183
2.40k
      return std::make_pair(None, Set.insert(V).second);
184
10.6k
185
10.6k
    VIterator I = vfind(V);
186
10.6k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
4.34k
      return std::make_pair(None, false);
188
6.26k
    if (Vector.size() < N) {
189
6.18k
      Vector.push_back(V);
190
6.18k
      return std::make_pair(None, true);
191
6.18k
    }
192
84
193
84
    // Otherwise, grow from vector to set.
194
756
    
while (84
!Vector.empty()) {
195
672
      Set.insert(Vector.back());
196
672
      Vector.pop_back();
197
672
    }
198
84
    Set.insert(V);
199
84
    return std::make_pair(None, true);
200
84
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
181
285k
  std::pair<NoneType, bool> insert(const T &V) {
182
285k
    if (!isSmall())
183
40.9k
      return std::make_pair(None, Set.insert(V).second);
184
244k
185
244k
    VIterator I = vfind(V);
186
244k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
135k
      return std::make_pair(None, false);
188
108k
    if (Vector.size() < N) {
189
104k
      Vector.push_back(V);
190
104k
      return std::make_pair(None, true);
191
104k
    }
192
4.09k
193
4.09k
    // Otherwise, grow from vector to set.
194
36.8k
    
while (4.09k
!Vector.empty()) {
195
32.7k
      Set.insert(Vector.back());
196
32.7k
      Vector.pop_back();
197
32.7k
    }
198
4.09k
    Set.insert(V);
199
4.09k
    return std::make_pair(None, true);
200
4.09k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::insert(llvm::AssertingVH<llvm::MemoryPhi> 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<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
15.1k
  std::pair<NoneType, bool> insert(const T &V) {
182
15.1k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
15.1k
185
15.1k
    VIterator I = vfind(V);
186
15.1k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
15.1k
    if (Vector.size() < N) {
189
15.1k
      Vector.push_back(V);
190
15.1k
      return std::make_pair(None, true);
191
15.1k
    }
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
189
  std::pair<NoneType, bool> insert(const T &V) {
182
189
    if (!isSmall())
183
69
      return std::make_pair(None, Set.insert(V).second);
184
120
185
120
    VIterator I = vfind(V);
186
120
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
120
    if (Vector.size() < N) {
189
91
      Vector.push_back(V);
190
91
      return std::make_pair(None, true);
191
91
    }
192
29
193
29
    // Otherwise, grow from vector to set.
194
87
    
while (29
!Vector.empty()) {
195
58
      Set.insert(Vector.back());
196
58
      Vector.pop_back();
197
58
    }
198
29
    Set.insert(V);
199
29
    return std::make_pair(None, true);
200
29
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
181
37
  std::pair<NoneType, bool> insert(const T &V) {
182
37
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
37
185
37
    VIterator I = vfind(V);
186
37
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
5
      return std::make_pair(None, false);
188
32
    if (Vector.size() < N) {
189
32
      Vector.push_back(V);
190
32
      return std::make_pair(None, true);
191
32
    }
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::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::insert(llvm::SlotIndex const&)
Line
Count
Source
181
255
  std::pair<NoneType, bool> insert(const T &V) {
182
255
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
255
185
255
    VIterator I = vfind(V);
186
255
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
255
    if (Vector.size() < N) {
189
255
      Vector.push_back(V);
190
255
      return std::make_pair(None, true);
191
255
    }
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.69k
  std::pair<NoneType, bool> insert(const T &V) {
182
5.69k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
5.69k
185
5.69k
    VIterator I = vfind(V);
186
5.69k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
5.69k
    if (Vector.size() < N) {
189
5.69k
      Vector.push_back(V);
190
5.69k
      return std::make_pair(None, true);
191
5.69k
    }
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.6k
  std::pair<NoneType, bool> insert(const T &V) {
182
17.6k
    if (!isSmall())
183
443
      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
22
193
22
    // Otherwise, grow from vector to set.
194
726
    
while (22
!Vector.empty()) {
195
704
      Set.insert(Vector.back());
196
704
      Vector.pop_back();
197
704
    }
198
22
    Set.insert(V);
199
22
    return std::make_pair(None, true);
200
22
  }
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
434k
  std::pair<NoneType, bool> insert(const T &V) {
182
434k
    if (!isSmall())
183
86.2k
      return std::make_pair(None, Set.insert(V).second);
184
348k
185
348k
    VIterator I = vfind(V);
186
348k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
88.3k
      return std::make_pair(None, false);
188
259k
    if (Vector.size() < N) {
189
255k
      Vector.push_back(V);
190
255k
      return std::make_pair(None, true);
191
255k
    }
192
4.24k
193
4.24k
    // Otherwise, grow from vector to set.
194
38.1k
    
while (4.24k
!Vector.empty()) {
195
33.9k
      Set.insert(Vector.back());
196
33.9k
      Vector.pop_back();
197
33.9k
    }
198
4.24k
    Set.insert(V);
199
4.24k
    return std::make_pair(None, true);
200
4.24k
  }
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
622k
  std::pair<NoneType, bool> insert(const T &V) {
182
622k
    if (!isSmall())
183
69.7k
      return std::make_pair(None, Set.insert(V).second);
184
552k
185
552k
    VIterator I = vfind(V);
186
552k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
552k
    if (Vector.size() < N) {
189
514k
      Vector.push_back(V);
190
514k
      return std::make_pair(None, true);
191
514k
    }
192
38.0k
193
38.0k
    // Otherwise, grow from vector to set.
194
228k
    
while (38.0k
!Vector.empty()) {
195
190k
      Set.insert(Vector.back());
196
190k
      Vector.pop_back();
197
190k
    }
198
38.0k
    Set.insert(V);
199
38.0k
    return std::make_pair(None, true);
200
38.0k
  }
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
690
  std::pair<NoneType, bool> insert(const T &V) {
182
690
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
690
185
690
    VIterator I = vfind(V);
186
690
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
690
    if (Vector.size() < N) {
189
690
      Vector.push_back(V);
190
690
      return std::make_pair(None, true);
191
690
    }
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
230k
185
230k
    VIterator I = vfind(V);
186
230k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
32.1k
      return std::make_pair(None, false);
188
198k
    if (Vector.size() < N) {
189
198k
      Vector.push_back(V);
190
198k
      return std::make_pair(None, true);
191
198k
    }
192
77
193
77
    // Otherwise, grow from vector to set.
194
693
    
while (77
!Vector.empty()) {
195
616
      Set.insert(Vector.back());
196
616
      Vector.pop_back();
197
616
    }
198
77
    Set.insert(V);
199
77
    return std::make_pair(None, true);
200
77
  }
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.19M
      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
956k
      return std::make_pair(None, false);
188
637k
    if (Vector.size() < N) {
189
632k
      Vector.push_back(V);
190
632k
      return std::make_pair(None, true);
191
632k
    }
192
4.36k
193
4.36k
    // Otherwise, grow from vector to set.
194
144k
    
while (4.36k
!Vector.empty()) {
195
139k
      Set.insert(Vector.back());
196
139k
      Vector.pop_back();
197
139k
    }
198
4.36k
    Set.insert(V);
199
4.36k
    return std::make_pair(None, true);
200
4.36k
  }
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
675
      return std::make_pair(None, false);
188
865k
    if (Vector.size() < N) {
189
864k
      Vector.push_back(V);
190
864k
      return std::make_pair(None, true);
191
864k
    }
192
99
193
99
    // Otherwise, grow from vector to set.
194
3.26k
    
while (99
!Vector.empty()) {
195
3.16k
      Set.insert(Vector.back());
196
3.16k
      Vector.pop_back();
197
3.16k
    }
198
99
    Set.insert(V);
199
99
    return std::make_pair(None, true);
200
99
  }
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 (Vector.size() < N) {
189
40.6k
      Vector.push_back(V);
190
40.6k
      return std::make_pair(None, true);
191
40.6k
    }
192
1
193
1
    // Otherwise, grow from vector to set.
194
1
    while (!Vector.empty()) {
195
0
      Set.insert(Vector.back());
196
0
      Vector.pop_back();
197
0
    }
198
1
    Set.insert(V);
199
1
    return std::make_pair(None, true);
200
1
  }
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.6k
  std::pair<NoneType, bool> insert(const T &V) {
182
13.6k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
13.6k
185
13.6k
    VIterator I = vfind(V);
186
13.6k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
6.57k
      return std::make_pair(None, false);
188
7.11k
    if (Vector.size() < N) {
189
7.11k
      Vector.push_back(V);
190
7.11k
      return std::make_pair(None, true);
191
7.11k
    }
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
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
53
      return std::make_pair(None, false);
188
196
    if (Vector.size() < N) {
189
196
      Vector.push_back(V);
190
196
      return std::make_pair(None, true);
191
196
    }
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.59k
  std::pair<NoneType, bool> insert(const T &V) {
182
1.59k
    if (!isSmall())
183
2
      return std::make_pair(None, Set.insert(V).second);
184
1.59k
185
1.59k
    VIterator I = vfind(V);
186
1.59k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
1.59k
    if (Vector.size() < N) {
189
1.59k
      Vector.push_back(V);
190
1.59k
      return std::make_pair(None, true);
191
1.59k
    }
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.36k
  std::pair<NoneType, bool> insert(const T &V) {
182
1.36k
    if (!isSmall())
183
169
      return std::make_pair(None, Set.insert(V).second);
184
1.19k
185
1.19k
    VIterator I = vfind(V);
186
1.19k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
1.19k
    if (Vector.size() < N) {
189
1.12k
      Vector.push_back(V);
190
1.12k
      return std::make_pair(None, true);
191
1.12k
    }
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
15.0k
  std::pair<NoneType, bool> insert(const T &V) {
182
15.0k
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
15.0k
185
15.0k
    VIterator I = vfind(V);
186
15.0k
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
0
      return std::make_pair(None, false);
188
15.0k
    if (Vector.size() < N) {
189
15.0k
      Vector.push_back(V);
190
15.0k
      return std::make_pair(None, true);
191
15.0k
    }
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
64
  std::pair<NoneType, bool> insert(const T &V) {
182
64
    if (!isSmall())
183
0
      return std::make_pair(None, Set.insert(V).second);
184
64
185
64
    VIterator I = vfind(V);
186
64
    if (I != Vector.end())    // Don't reinsert if it already exists.
187
2
      return std::make_pair(None, false);
188
62
    if (Vector.size() < N) {
189
62
      Vector.push_back(V);
190
62
      return std::make_pair(None, true);
191
62
    }
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
84.9k
  void insert(IterT I, IterT E) {
204
708k
    for (; I != E; 
++I623k
)
205
623k
      insert(*I);
206
84.9k
  }
207
208
914k
  bool erase(const T &V) {
209
914k
    if (!isSmall())
210
475k
      return Set.erase(V);
211
816k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 439k
I != E;
++I377k
)
212
421k
      if (*I == V) {
213
43.7k
        Vector.erase(I);
214
43.7k
        return true;
215
43.7k
      }
216
439k
    
return false395k
;
217
439k
  }
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
878k
  bool erase(const T &V) {
209
878k
    if (!isSmall())
210
474k
      return Set.erase(V);
211
775k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 403k
I != E;
++I371k
)
212
403k
      if (*I == V) {
213
31.4k
        Vector.erase(I);
214
31.4k
        return true;
215
31.4k
      }
216
403k
    
return false371k
;
217
403k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
3.62k
  bool erase(const T &V) {
209
3.62k
    if (!isSmall())
210
0
      return Set.erase(V);
211
4.51k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 3.62k
I != E;
++I889
)
212
1.12k
      if (*I == V) {
213
240
        Vector.erase(I);
214
240
        return true;
215
240
      }
216
3.62k
    
return false3.38k
;
217
3.62k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
11.1k
  bool erase(const T &V) {
209
11.1k
    if (!isSmall())
210
265
      return Set.erase(V);
211
13.2k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 10.8k
I != E;
++I2.38k
)
212
10.2k
      if (*I == V) {
213
7.88k
        Vector.erase(I);
214
7.88k
        return true;
215
7.88k
      }
216
10.8k
    
return false2.96k
;
217
10.8k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
208
13.2k
  bool erase(const T &V) {
209
13.2k
    if (!isSmall())
210
0
      return Set.erase(V);
211
15.3k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 13.2k
I != E;
++I2.11k
)
212
2.65k
      if (*I == V) {
213
544
        Vector.erase(I);
214
544
        return true;
215
544
      }
216
13.2k
    
return false12.6k
;
217
13.2k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::erase(clang::DeclarationName const&)
Line
Count
Source
208
8.40k
  bool erase(const T &V) {
209
8.40k
    if (!isSmall())
210
0
      return Set.erase(V);
211
8.42k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 8.40k
I != E;
++I18
)
212
3.65k
      if (*I == V) {
213
3.63k
        Vector.erase(I);
214
3.63k
        return true;
215
3.63k
      }
216
8.40k
    
return false4.76k
;
217
8.40k
  }
218
219
8.77M
  void clear() {
220
8.77M
    Vector.clear();
221
8.77M
    Set.clear();
222
8.77M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
24.9k
  void clear() {
220
24.9k
    Vector.clear();
221
24.9k
    Set.clear();
222
24.9k
  }
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.74M
  void clear() {
220
5.74M
    Vector.clear();
221
5.74M
    Set.clear();
222
5.74M
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::clear()
Line
Count
Source
219
64
  void clear() {
220
64
    Vector.clear();
221
64
    Set.clear();
222
64
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
219
1.10M
  void clear() {
220
1.10M
    Vector.clear();
221
1.10M
    Set.clear();
222
1.10M
  }
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.08M
  void clear() {
220
1.08M
    Vector.clear();
221
1.08M
    Set.clear();
222
1.08M
  }
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
259
  void clear() {
220
259
    Vector.clear();
221
259
    Set.clear();
222
259
  }
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
581k
  void clear() {
220
581k
    Vector.clear();
221
581k
    Set.clear();
222
581k
  }
223
224
581k
  const_iterator begin() const {
225
581k
    if (isSmall())
226
581k
      return {Vector.begin()};
227
0
    return {Set.begin()};
228
0
  }
229
230
581k
  const_iterator end() const {
231
581k
    if (isSmall())
232
581k
      return {Vector.end()};
233
0
    return {Set.end()};
234
0
  }
235
236
private:
237
152M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 4u, std::__1::less<int> >::isSmall() const
Line
Count
Source
237
2.97k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
237
851k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
47.8M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
1.44M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
34.1M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
6.56M
  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.82k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
52.4M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
237
59
  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
16.0k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
237
311k
  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
70
  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.8k
  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
15.1k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
237
272
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::isSmall() const
Line
Count
Source
237
1.09k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 16u, std::__1::less<int> >::isSmall() const
Line
Count
Source
237
239k
  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
434k
  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
999k
  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.55k
  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
63
  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
16.2k
  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
249
  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.87k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
237
3.30k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::isSmall() const
Line
Count
Source
237
30.1k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
237
124
  bool isSmall() const { return Set.empty(); }
238
239
131M
  VIterator vfind(const T &V) const {
240
349M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I218M
)
241
252M
      if (*I == V)
242
34.0M
        return I;
243
131M
    
return Vector.end()97.3M
;
244
131M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
2.59k
  VIterator vfind(const T &V) const {
240
3.57k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I981
)
241
1.51k
      if (*I == V)
242
535
        return I;
243
2.59k
    
return Vector.end()2.05k
;
244
2.59k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
239
511k
  VIterator vfind(const T &V) const {
240
775k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I264k
)
241
270k
      if (*I == V)
242
5.85k
        return I;
243
511k
    
return Vector.end()505k
;
244
511k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
47.8M
  VIterator vfind(const T &V) const {
240
120M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I72.8M
)
241
89.5M
      if (*I == V)
242
16.6M
        return I;
243
47.8M
    
return Vector.end()31.1M
;
244
47.8M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
1.42M
  VIterator vfind(const T &V) const {
240
4.45M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3.03M
)
241
3.28M
      if (*I == V)
242
251k
        return I;
243
1.42M
    
return Vector.end()1.17M
;
244
1.42M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
26.4M
  VIterator vfind(const T &V) const {
240
49.6M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I23.2M
)
241
25.7M
      if (*I == V)
242
2.45M
        return I;
243
26.4M
    
return Vector.end()23.9M
;
244
26.4M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
2.72M
  VIterator vfind(const T &V) const {
240
4.42M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.70M
)
241
2.30M
      if (*I == V)
242
604k
        return I;
243
2.72M
    
return Vector.end()2.11M
;
244
2.72M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
239
4.82k
  VIterator vfind(const T &V) const {
240
5.31k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I489
)
241
508
      if (*I == V)
242
19
        return I;
243
4.82k
    
return Vector.end()4.80k
;
244
4.82k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
47.7M
  VIterator vfind(const T &V) const {
240
151M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I103M
)
241
116M
      if (*I == V)
242
12.5M
        return I;
243
47.7M
    
return Vector.end()35.1M
;
244
47.7M
  }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
239
59
  VIterator vfind(const T &V) const {
240
59
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I0
)
241
0
      if (*I == V)
242
0
        return I;
243
59
    return Vector.end();
244
59
  }
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
13.4k
  VIterator vfind(const T &V) const {
240
47.1k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I33.6k
)
241
38.8k
      if (*I == V)
242
5.20k
        return I;
243
13.4k
    
return Vector.end()8.28k
;
244
13.4k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
239
244k
  VIterator vfind(const T &V) const {
240
637k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I393k
)
241
528k
      if (*I == V)
242
135k
        return I;
243
244k
    
return Vector.end()108k
;
244
244k
  }
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
70
  VIterator vfind(const T &V) const {
240
82
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I12
)
241
15
      if (*I == V)
242
3
        return I;
243
70
    
return Vector.end()67
;
244
70
  }
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
13.9k
  VIterator vfind(const T &V) const {
240
16.4k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.45k
)
241
2.50k
      if (*I == V)
242
44
        return I;
243
13.9k
    
return Vector.end()13.9k
;
244
13.9k
  }
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
15.1k
  VIterator vfind(const T &V) const {
240
15.1k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I30
)
241
30
      if (*I == V)
242
0
        return I;
243
15.1k
    return Vector.end();
244
15.1k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
239
272
  VIterator vfind(const T &V) const {
240
304
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I32
)
241
57
      if (*I == V)
242
25
        return I;
243
272
    
return Vector.end()247
;
244
272
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::vfind(llvm::SlotIndex const&) const
Line
Count
Source
239
1.09k
  VIterator vfind(const T &V) const {
240
1.29k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I205
)
241
460
      if (*I == V)
242
255
        return I;
243
1.09k
    
return Vector.end()839
;
244
1.09k
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
239k
  VIterator vfind(const T &V) const {
240
264k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I25.2k
)
241
30.9k
      if (*I == V)
242
5.69k
        return I;
243
239k
    
return Vector.end()233k
;
244
239k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
239
228k
  VIterator vfind(const T &V) const {
240
640k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I412k
)
241
447k
      if (*I == V)
242
35.3k
        return I;
243
228k
    
return Vector.end()192k
;
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
348k
  VIterator vfind(const T &V) const {
240
894k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I546k
)
241
634k
      if (*I == V)
242
88.3k
        return I;
243
348k
    
return Vector.end()259k
;
244
348k
  }
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
807k
  VIterator vfind(const T &V) const {
240
1.96M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.15M
)
241
1.29M
      if (*I == V)
242
138k
        return I;
243
807k
    
return Vector.end()669k
;
244
807k
  }
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.55k
  VIterator vfind(const T &V) const {
240
26.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I21.4k
)
241
24.7k
      if (*I == V)
242
3.33k
        return I;
243
5.55k
    
return Vector.end()2.21k
;
244
5.55k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
239
230k
  VIterator vfind(const T &V) const {
240
517k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I287k
)
241
319k
      if (*I == V)
242
32.1k
        return I;
243
230k
    
return Vector.end()198k
;
244
230k
  }
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.59M
  VIterator vfind(const T &V) const {
240
11.8M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I10.2M
)
241
11.2M
      if (*I == V)
242
956k
        return I;
243
1.59M
    
return Vector.end()637k
;
244
1.59M
  }
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
354k
      if (*I == V)
242
675
        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
54.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I14.3k
)
241
14.3k
      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
63
  VIterator vfind(const T &V) const {
240
66
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3
)
241
8
      if (*I == V)
242
5
        return I;
243
63
    
return Vector.end()58
;
244
63
  }
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.6k
  VIterator vfind(const T &V) const {
240
21.5k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I7.83k
)
241
14.4k
      if (*I == V)
242
6.57k
        return I;
243
13.6k
    
return Vector.end()7.11k
;
244
13.6k
  }
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
249
  VIterator vfind(const T &V) const {
240
254
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
241
58
      if (*I == V)
242
53
        return I;
243
249
    
return Vector.end()196
;
244
249
  }
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.87k
  VIterator vfind(const T &V) const {
240
2.37k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I506
)
241
506
      if (*I == V)
242
0
        return I;
243
1.87k
    return Vector.end();
244
1.87k
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
239
2.21k
  VIterator vfind(const T &V) const {
240
3.19k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I977
)
241
1.48k
      if (*I == V)
242
504
        return I;
243
2.21k
    
return Vector.end()1.70k
;
244
2.21k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::vfind(llvm::DWARFDie const&) const
Line
Count
Source
239
30.1k
  VIterator vfind(const T &V) const {
240
30.8k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I674
)
241
676
      if (*I == V)
242
2
        return I;
243
30.1k
    
return Vector.end()30.1k
;
244
30.1k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
239
124
  VIterator vfind(const T &V) const {
240
159
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I35
)
241
94
      if (*I == V)
242
59
        return I;
243
124
    
return Vector.end()65
;
244
124
  }
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