Coverage Report

Created: 2019-02-15 18:59

/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
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file defines the SmallSet class.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_ADT_SMALLSET_H
14
#define LLVM_ADT_SMALLSET_H
15
16
#include "llvm/ADT/None.h"
17
#include "llvm/ADT/SmallPtrSet.h"
18
#include "llvm/ADT/SmallVector.h"
19
#include "llvm/ADT/iterator.h"
20
#include "llvm/Support/Compiler.h"
21
#include "llvm/Support/type_traits.h"
22
#include <cstddef>
23
#include <functional>
24
#include <set>
25
#include <type_traits>
26
#include <utility>
27
28
namespace llvm {
29
30
/// SmallSetIterator - This class implements a const_iterator for SmallSet by
31
/// delegating to the underlying SmallVector or Set iterators.
32
template <typename T, unsigned N, typename C>
33
class SmallSetIterator
34
    : public iterator_facade_base<SmallSetIterator<T, N, C>,
35
                                  std::forward_iterator_tag, T> {
36
private:
37
  using SetIterTy = typename std::set<T, C>::const_iterator;
38
  using VecIterTy = typename SmallVector<T, N>::const_iterator;
39
  using SelfTy = SmallSetIterator<T, N, C>;
40
41
  /// Iterators to the parts of the SmallSet containing the data. They are set
42
  /// depending on isSmall.
43
  union {
44
    SetIterTy SetIter;
45
    VecIterTy VecIter;
46
  };
47
48
  bool isSmall;
49
50
public:
51
0
  SmallSetIterator(SetIterTy SetIter) : SetIter(SetIter), isSmall(false) {}
52
53
1.16M
  SmallSetIterator(VecIterTy VecIter) : VecIter(VecIter), isSmall(true) {}
54
55
  // Spell out destructor, copy/move constructor and assignment operators for
56
  // MSVC STL, where set<T>::const_iterator is not trivially copy constructible.
57
1.16M
  ~SmallSetIterator() {
58
1.16M
    if (isSmall)
59
1.16M
      VecIter.~VecIterTy();
60
0
    else
61
0
      SetIter.~SetIterTy();
62
1.16M
  }
63
64
  SmallSetIterator(const SmallSetIterator &Other) : isSmall(Other.isSmall) {
65
    if (isSmall)
66
      VecIter = Other.VecIter;
67
    else
68
      // Use placement new, to make sure SetIter is properly constructed, even
69
      // if it is not trivially copy-able (e.g. in MSVC).
70
      new (&SetIter) SetIterTy(Other.SetIter);
71
  }
72
73
  SmallSetIterator(SmallSetIterator &&Other) : isSmall(Other.isSmall) {
74
    if (isSmall)
75
      VecIter = std::move(Other.VecIter);
76
    else
77
      // Use placement new, to make sure SetIter is properly constructed, even
78
      // if it is not trivially copy-able (e.g. in MSVC).
79
      new (&SetIter) SetIterTy(std::move(Other.SetIter));
80
  }
81
82
  SmallSetIterator& operator=(const SmallSetIterator& Other) {
83
    // Call destructor for SetIter, so it gets properly destroyed if it is
84
    // not trivially destructible in case we are setting VecIter.
85
    if (!isSmall)
86
      SetIter.~SetIterTy();
87
88
    isSmall = Other.isSmall;
89
    if (isSmall)
90
      VecIter = Other.VecIter;
91
    else
92
      new (&SetIter) SetIterTy(Other.SetIter);
93
    return *this;
94
  }
95
96
  SmallSetIterator& operator=(SmallSetIterator&& Other) {
97
    // Call destructor for SetIter, so it gets properly destroyed if it is
98
    // not trivially destructible in case we are setting VecIter.
99
    if (!isSmall)
100
      SetIter.~SetIterTy();
101
102
    isSmall = Other.isSmall;
103
    if (isSmall)
104
      VecIter = std::move(Other.VecIter);
105
    else
106
      new (&SetIter) SetIterTy(std::move(Other.SetIter));
107
    return *this;
108
  }
109
110
622k
  bool operator==(const SmallSetIterator &RHS) const {
111
622k
    if (isSmall != RHS.isSmall)
112
0
      return false;
113
622k
    if (isSmall)
114
622k
      return VecIter == RHS.VecIter;
115
18.4E
    return SetIter == RHS.SetIter;
116
18.4E
  }
117
118
40.2k
  SmallSetIterator &operator++() { // Preincrement
119
40.2k
    if (isSmall)
120
40.2k
      VecIter++;
121
0
    else
122
0
      SetIter++;
123
40.2k
    return *this;
124
40.2k
  }
125
126
40.2k
  const T &operator*() const { return isSmall ? *VecIter : 
*SetIter0
; }
127
};
128
129
/// SmallSet - This maintains a set of unique values, optimizing for the case
130
/// when the set is small (less than N).  In this case, the set can be
131
/// maintained with no mallocs.  If the set gets large, we expand to using an
132
/// std::set to maintain reasonable lookup times.
133
template <typename T, unsigned N, typename C = std::less<T>>
134
class SmallSet {
135
  /// Use a SmallVector to hold the elements here (even though it will never
136
  /// reach its 'large' stage) to avoid calling the default ctors of elements
137
  /// we will never use.
138
  SmallVector<T, N> Vector;
139
  std::set<T, C> Set;
140
141
  using VIterator = typename SmallVector<T, N>::const_iterator;
142
  using mutable_iterator = typename SmallVector<T, N>::iterator;
143
144
  // In small mode SmallPtrSet uses linear search for the elements, so it is
145
  // not a good idea to choose this value too high. You may consider using a
146
  // DenseSet<> instead if you expect many elements in the set.
147
  static_assert(N <= 32, "N should be small");
148
149
public:
150
  using size_type = size_t;
151
  using const_iterator = SmallSetIterator<T, N, C>;
152
153
93.5M
  SmallSet() = default;
llvm::SmallSet<int, 4u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
30.4k
  SmallSet() = default;
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
153
345k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
41.1M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
13.2M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
15.7M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
927k
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
153
4.36k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
18.2M
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
153
120
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
153
4.47k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
50
  SmallSet() = default;
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
153
2.16k
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
153
33.9k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::SmallSet()
Line
Count
Source
153
32.5k
  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
153
13.3k
  SmallSet() = default;
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
153
484
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::SmallSet()
Line
Count
Source
153
1.12M
  SmallSet() = default;
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::SmallSet()
Line
Count
Source
153
600
  SmallSet() = default;
llvm::SmallSet<int, 16u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
503k
  SmallSet() = default;
llvm::SmallSet<int, 32u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
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
153
32.4k
  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
153
175k
  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
153
101
  SmallSet() = default;
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
153
206k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::SmallSet()
Line
Count
Source
153
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
153
747k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSet()
Line
Count
Source
153
582k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
153
112
  SmallSet() = default;
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::SmallSet()
Line
Count
Source
153
171
  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
153
171
  SmallSet() = default;
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::SmallSet()
Line
Count
Source
153
28.6k
  SmallSet() = default;
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::SmallSet()
Line
Count
Source
153
21.3k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::SmallSet()
Line
Count
Source
153
293
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
153
65.0k
  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
153
11.3k
  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
153
2
  SmallSet() = default;
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::SmallSet()
Line
Count
Source
153
20
  SmallSet() = default;
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::SmallSet()
Line
Count
Source
153
1.64k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
153
972
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
153
7
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
153
13
  SmallSet() = default;
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::SmallSet()
Line
Count
Source
153
14.9k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
48
  SmallSet() = default;
154
155
28.1M
  LLVM_NODISCARD bool empty() const {
156
28.1M
    return Vector.empty() && 
Set.empty()26.2M
;
157
28.1M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
258
  LLVM_NODISCARD bool empty() const {
156
258
    return Vector.empty() && 
Set.empty()0
;
157
258
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
950k
  LLVM_NODISCARD bool empty() const {
156
950k
    return Vector.empty() && 
Set.empty()85.0k
;
157
950k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
1.28M
  LLVM_NODISCARD bool empty() const {
156
1.28M
    return Vector.empty() && 
Set.empty()667k
;
157
1.28M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
24.9M
  LLVM_NODISCARD bool empty() const {
156
24.9M
    return Vector.empty() && 
Set.empty()24.5M
;
157
24.9M
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::empty() const
Line
Count
Source
155
16.9k
  LLVM_NODISCARD bool empty() const {
156
16.9k
    return Vector.empty() && 
Set.empty()14.6k
;
157
16.9k
  }
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
155
371
  LLVM_NODISCARD bool empty() const {
156
371
    return Vector.empty() && 
Set.empty()2
;
157
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
155
947k
  LLVM_NODISCARD bool empty() const {
156
947k
    return Vector.empty() && 
Set.empty()947k
;
157
947k
  }
158
159
364k
  size_type size() const {
160
364k
    return isSmall() ? 
Vector.size()359k
:
Set.size()4.63k
;
161
364k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::size() const
Line
Count
Source
159
313k
  size_type size() const {
160
313k
    return isSmall() ? 
Vector.size()313k
:
Set.size()26
;
161
313k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::size() const
Line
Count
Source
159
16.2k
  size_type size() const {
160
16.2k
    return isSmall() ? 
Vector.size()15.7k
:
Set.size()456
;
161
16.2k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
159
31.2k
  size_type size() const {
160
31.2k
    return isSmall() ? 
Vector.size()27.1k
:
Set.size()4.15k
;
161
31.2k
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
159
2.62k
  size_type size() const {
160
2.62k
    return isSmall() ? Vector.size() : 
Set.size()0
;
161
2.62k
  }
162
163
  /// count - Return 1 if the element is in the set, 0 otherwise.
164
58.1M
  size_type count(const T &V) const {
165
58.1M
    if (isSmall()) {
166
54.3M
      // Since the collection is small, just do a linear search.
167
54.3M
      return vfind(V) == Vector.end() ? 
041.8M
:
112.4M
;
168
54.3M
    } else {
169
3.86M
      return Set.count(V);
170
3.86M
    }
171
58.1M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
2.36k
  size_type count(const T &V) const {
165
2.36k
    if (isSmall()) {
166
2.06k
      // Since the collection is small, just do a linear search.
167
2.06k
      return vfind(V) == Vector.end() ? 
01.64k
:
1425
;
168
2.06k
    } else {
169
299
      return Set.count(V);
170
299
    }
171
2.36k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
3.21M
  size_type count(const T &V) const {
165
3.21M
    if (isSmall()) {
166
3.21M
      // Since the collection is small, just do a linear search.
167
3.21M
      return vfind(V) == Vector.end() ? 
02.61M
:
1601k
;
168
3.21M
    } else {
169
1.80k
      return Set.count(V);
170
1.80k
    }
171
3.21M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
16.0M
  size_type count(const T &V) const {
165
16.0M
    if (isSmall()) {
166
16.0M
      // Since the collection is small, just do a linear search.
167
16.0M
      return vfind(V) == Vector.end() ? 
015.9M
:
1139k
;
168
16.0M
    } else {
169
7.07k
      return Set.count(V);
170
7.07k
    }
171
16.0M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
16.0M
  size_type count(const T &V) const {
165
16.0M
    if (isSmall()) {
166
14.4M
      // Since the collection is small, just do a linear search.
167
14.4M
      return vfind(V) == Vector.end() ? 
012.9M
:
11.43M
;
168
14.4M
    } else {
169
1.59M
      return Set.count(V);
170
1.59M
    }
171
16.0M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
3.18M
  size_type count(const T &V) const {
165
3.18M
    if (isSmall()) {
166
1.05M
      // Since the collection is small, just do a linear search.
167
1.05M
      return vfind(V) == Vector.end() ? 
0588k
:
1467k
;
168
2.12M
    } else {
169
2.12M
      return Set.count(V);
170
2.12M
    }
171
3.18M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::count(unsigned long long const&) const
Line
Count
Source
164
2.42k
  size_type count(const T &V) const {
165
2.42k
    if (isSmall()) {
166
2.42k
      // Since the collection is small, just do a linear search.
167
2.42k
      return vfind(V) == Vector.end() ? 
02.40k
:
119
;
168
2.42k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
2.42k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
18.7M
  size_type count(const T &V) const {
165
18.7M
    if (isSmall()) {
166
18.7M
      // Since the collection is small, just do a linear search.
167
18.7M
      return vfind(V) == Vector.end() ? 
09.19M
:
19.58M
;
168
18.7M
    } else {
169
138
      return Set.count(V);
170
138
    }
171
18.7M
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
78
  size_type count(const T &V) const {
165
78
    if (isSmall()) {
166
72
      // Since the collection is small, just do a linear search.
167
72
      return vfind(V) == Vector.end() ? 
066
:
16
;
168
72
    } else {
169
6
      return Set.count(V);
170
6
    }
171
78
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
164
3.17k
  size_type count(const T &V) const {
165
3.17k
    if (isSmall()) {
166
2.94k
      // Since the collection is small, just do a linear search.
167
2.94k
      return vfind(V) == Vector.end() ? 
02.07k
:
1870
;
168
2.94k
    } else {
169
230
      return Set.count(V);
170
230
    }
171
3.17k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::count(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
164
889
  size_type count(const T &V) const {
165
889
    if (isSmall()) {
166
889
      // Since the collection is small, just do a linear search.
167
889
      return vfind(V) == Vector.end() ? 
0884
:
15
;
168
889
    } else {
169
0
      return Set.count(V);
170
0
    }
171
889
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::count(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
164
15.5k
  size_type count(const T &V) const {
165
15.5k
    if (isSmall()) {
166
14.9k
      // Since the collection is small, just do a linear search.
167
14.9k
      return vfind(V) == Vector.end() ? 
014.8k
:
144
;
168
14.9k
    } else {
169
636
      return Set.count(V);
170
636
    }
171
15.5k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
164
235
  size_type count(const T &V) const {
165
235
    if (isSmall()) {
166
235
      // Since the collection is small, just do a linear search.
167
235
      return vfind(V) == Vector.end() ? 
0215
:
120
;
168
235
    } else {
169
0
      return Set.count(V);
170
0
    }
171
235
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::count(llvm::SlotIndex const&) const
Line
Count
Source
164
897
  size_type count(const T &V) const {
165
897
    if (isSmall()) {
166
897
      // Since the collection is small, just do a linear search.
167
897
      return vfind(V) == Vector.end() ? 
0636
:
1261
;
168
897
    } else {
169
0
      return Set.count(V);
170
0
    }
171
897
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
249k
  size_type count(const T &V) const {
165
249k
    if (isSmall()) {
166
249k
      // Since the collection is small, just do a linear search.
167
249k
      return vfind(V) == Vector.end() ? 
0243k
:
16.03k
;
168
249k
    } else {
169
48
      return Set.count(V);
170
48
    }
171
249k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
227k
  size_type count(const T &V) const {
165
227k
    if (isSmall()) {
166
222k
      // Since the collection is small, just do a linear search.
167
222k
      return vfind(V) == Vector.end() ? 
0177k
:
144.8k
;
168
222k
    } else {
169
5.53k
      return Set.count(V);
170
5.53k
    }
171
227k
  }
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
164
372k
  size_type count(const T &V) const {
165
372k
    if (isSmall()) {
166
244k
      // Since the collection is small, just do a linear search.
167
244k
      return vfind(V) == Vector.end() ? 
0110k
:
1133k
;
168
244k
    } else {
169
127k
      return Set.count(V);
170
127k
    }
171
372k
  }
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
164
4.89k
  size_type count(const T &V) const {
165
4.89k
    if (isSmall()) {
166
4.89k
      // Since the collection is small, just do a linear search.
167
4.89k
      return vfind(V) == Vector.end() ? 
01.53k
:
13.35k
;
168
4.89k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
4.89k
  }
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
164
1.07k
  size_type count(const T &V) const {
165
1.07k
    if (isSmall()) {
166
880
      // Since the collection is small, just do a linear search.
167
880
      return vfind(V) == Vector.end() ? 
0872
:
18
;
168
880
    } else {
169
190
      return Set.count(V);
170
190
    }
171
1.07k
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::count(clang::CudaArch const&) const
Line
Count
Source
164
60
  size_type count(const T &V) const {
165
60
    if (isSmall()) {
166
60
      // Since the collection is small, just do a linear search.
167
60
      return vfind(V) == Vector.end() ? 
055
:
15
;
168
60
    } else {
169
0
      return Set.count(V);
170
0
    }
171
60
  }
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
164
100
  size_type count(const T &V) const {
165
100
    if (isSmall()) {
166
100
      // Since the collection is small, just do a linear search.
167
100
      return vfind(V) == Vector.end() ? 
061
:
139
;
168
100
    } else {
169
0
      return Set.count(V);
170
0
    }
171
100
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::count(clang::Selector const&) const
Line
Count
Source
164
33
  size_type count(const T &V) const {
165
33
    if (isSmall()) {
166
33
      // Since the collection is small, just do a linear search.
167
33
      return vfind(V) == Vector.end() ? 
03
:
130
;
168
33
    } else {
169
0
      return Set.count(V);
170
0
    }
171
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
164
364
  size_type count(const T &V) const {
165
364
    if (isSmall()) {
166
362
      // Since the collection is small, just do a linear search.
167
362
      return vfind(V) == Vector.end() ? 0 : 
10
;
168
362
    } else {
169
2
      return Set.count(V);
170
2
    }
171
364
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::count(clang::SourceLocation const&) const
Line
Count
Source
164
1.96k
  size_type count(const T &V) const {
165
1.96k
    if (isSmall()) {
166
1.04k
      // Since the collection is small, just do a linear search.
167
1.04k
      return vfind(V) == Vector.end() ? 
0524
:
1522
;
168
1.04k
    } else {
169
921
      return Set.count(V);
170
921
    }
171
1.96k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::count(llvm::DWARFDie const&) const
Line
Count
Source
164
15.2k
  size_type count(const T &V) const {
165
15.2k
    if (isSmall()) {
166
15.2k
      // Since the collection is small, just do a linear search.
167
15.2k
      return vfind(V) == Vector.end() ? 
015.2k
:
12
;
168
15.2k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
15.2k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
60
  size_type count(const T &V) const {
165
60
    if (isSmall()) {
166
60
      // Since the collection is small, just do a linear search.
167
60
      return vfind(V) == Vector.end() ? 
03
:
157
;
168
60
    } else {
169
0
      return Set.count(V);
170
0
    }
171
60
  }
172
173
  /// insert - Insert an element into the set if it isn't already there.
174
  /// Returns true if the element is inserted (it was not in the set before).
175
  /// The first value of the returned pair is unused and provided for
176
  /// partial compatibility with the standard library self-associative container
177
  /// concept.
178
  // FIXME: Add iterators that abstract over the small and large form, and then
179
  // return those here.
180
106M
  std::pair<NoneType, bool> insert(const T &V) {
181
106M
    if (!isSmall())
182
13.3M
      return std::make_pair(None, Set.insert(V).second);
183
93.4M
184
93.4M
    VIterator I = vfind(V);
185
93.4M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
22.2M
      return std::make_pair(None, false);
187
71.1M
    if (Vector.size() < N) {
188
69.9M
      Vector.push_back(V);
189
69.9M
      return std::make_pair(None, true);
190
69.9M
    }
191
1.25M
192
1.25M
    // Otherwise, grow from vector to set.
193
7.31M
    
while (1.25M
!Vector.empty()) {
194
6.05M
      Set.insert(Vector.back());
195
6.05M
      Vector.pop_back();
196
6.05M
    }
197
1.25M
    Set.insert(V);
198
1.25M
    return std::make_pair(None, true);
199
1.25M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
180
589
  std::pair<NoneType, bool> insert(const T &V) {
181
589
    if (!isSmall())
182
65
      return std::make_pair(None, Set.insert(V).second);
183
524
184
524
    VIterator I = vfind(V);
185
524
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
110
      return std::make_pair(None, false);
187
414
    if (Vector.size() < N) {
188
402
      Vector.push_back(V);
189
402
      return std::make_pair(None, true);
190
402
    }
191
12
192
12
    // Otherwise, grow from vector to set.
193
60
    
while (12
!Vector.empty()) {
194
48
      Set.insert(Vector.back());
195
48
      Vector.pop_back();
196
48
    }
197
12
    Set.insert(V);
198
12
    return std::make_pair(None, true);
199
12
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
180
537k
  std::pair<NoneType, bool> insert(const T &V) {
181
537k
    if (!isSmall())
182
21.1k
      return std::make_pair(None, Set.insert(V).second);
183
516k
184
516k
    VIterator I = vfind(V);
185
516k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
5.79k
      return std::make_pair(None, false);
187
510k
    if (Vector.size() < N) {
188
507k
      Vector.push_back(V);
189
507k
      return std::make_pair(None, true);
190
507k
    }
191
3.21k
192
3.21k
    // Otherwise, grow from vector to set.
193
16.0k
    
while (3.21k
!Vector.empty()) {
194
12.8k
      Set.insert(Vector.back());
195
12.8k
      Vector.pop_back();
196
12.8k
    }
197
3.21k
    Set.insert(V);
198
3.21k
    return std::make_pair(None, true);
199
3.21k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
45.6M
  std::pair<NoneType, bool> insert(const T &V) {
181
45.6M
    if (!isSmall())
182
19.3k
      return std::make_pair(None, Set.insert(V).second);
183
45.6M
184
45.6M
    VIterator I = vfind(V);
185
45.6M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
16.5M
      return std::make_pair(None, false);
187
29.0M
    if (Vector.size() < N) {
188
29.0M
      Vector.push_back(V);
189
29.0M
      return std::make_pair(None, true);
190
29.0M
    }
191
2.63k
192
2.63k
    // Otherwise, grow from vector to set.
193
23.9k
    
while (2.63k
!Vector.empty()) {
194
21.3k
      Set.insert(Vector.back());
195
21.3k
      Vector.pop_back();
196
21.3k
    }
197
2.63k
    Set.insert(V);
198
2.63k
    return std::make_pair(None, true);
199
2.63k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
430k
  std::pair<NoneType, bool> insert(const T &V) {
181
430k
    if (!isSmall())
182
14.6k
      return std::make_pair(None, Set.insert(V).second);
183
416k
184
416k
    VIterator I = vfind(V);
185
416k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
113k
      return std::make_pair(None, false);
187
302k
    if (Vector.size() < N) {
188
302k
      Vector.push_back(V);
189
302k
      return std::make_pair(None, true);
190
302k
    }
191
81
192
81
    // Otherwise, grow from vector to set.
193
1.37k
    
while (81
!Vector.empty()) {
194
1.29k
      Set.insert(Vector.back());
195
1.29k
      Vector.pop_back();
196
1.29k
    }
197
81
    Set.insert(V);
198
81
    return std::make_pair(None, true);
199
81
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
15.1M
  std::pair<NoneType, bool> insert(const T &V) {
181
15.1M
    if (!isSmall())
182
3.11M
      return std::make_pair(None, Set.insert(V).second);
183
12.0M
184
12.0M
    VIterator I = vfind(V);
185
12.0M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1.21M
      return std::make_pair(None, false);
187
10.8M
    if (Vector.size() < N) {
188
9.86M
      Vector.push_back(V);
189
9.86M
      return std::make_pair(None, true);
190
9.86M
    }
191
1.00M
192
1.00M
    // Otherwise, grow from vector to set.
193
5.01M
    
while (1.00M
!Vector.empty()) {
194
4.01M
      Set.insert(Vector.back());
195
4.01M
      Vector.pop_back();
196
4.01M
    }
197
1.00M
    Set.insert(V);
198
1.00M
    return std::make_pair(None, true);
199
1.00M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
3.46M
  std::pair<NoneType, bool> insert(const T &V) {
181
3.46M
    if (!isSmall())
182
1.76M
      return std::make_pair(None, Set.insert(V).second);
183
1.69M
184
1.69M
    VIterator I = vfind(V);
185
1.69M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
139k
      return std::make_pair(None, false);
187
1.55M
    if (Vector.size() < N) {
188
1.39M
      Vector.push_back(V);
189
1.39M
      return std::make_pair(None, true);
190
1.39M
    }
191
156k
192
156k
    // Otherwise, grow from vector to set.
193
468k
    
while (156k
!Vector.empty()) {
194
312k
      Set.insert(Vector.back());
195
312k
      Vector.pop_back();
196
312k
    }
197
156k
    Set.insert(V);
198
156k
    return std::make_pair(None, true);
199
156k
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::insert(unsigned long long const&)
Line
Count
Source
180
2.39k
  std::pair<NoneType, bool> insert(const T &V) {
181
2.39k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
2.39k
184
2.39k
    VIterator I = vfind(V);
185
2.39k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
2.39k
    if (Vector.size() < N) {
188
2.39k
      Vector.push_back(V);
189
2.39k
      return std::make_pair(None, true);
190
2.39k
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
34.1M
  std::pair<NoneType, bool> insert(const T &V) {
181
34.1M
    if (!isSmall())
182
4.99M
      return std::make_pair(None, Set.insert(V).second);
183
29.1M
184
29.1M
    VIterator I = vfind(V);
185
29.1M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
3.01M
      return std::make_pair(None, false);
187
26.1M
    if (Vector.size() < N) {
188
26.1M
      Vector.push_back(V);
189
26.1M
      return std::make_pair(None, true);
190
26.1M
    }
191
39.8k
192
39.8k
    // Otherwise, grow from vector to set.
193
1.31M
    
while (39.8k
!Vector.empty()) {
194
1.27M
      Set.insert(Vector.back());
195
1.27M
      Vector.pop_back();
196
1.27M
    }
197
39.8k
    Set.insert(V);
198
39.8k
    return std::make_pair(None, true);
199
39.8k
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
180
151
  std::pair<NoneType, bool> insert(const T &V) {
181
151
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
151
184
151
    VIterator I = vfind(V);
185
151
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1
      return std::make_pair(None, false);
187
150
    if (Vector.size() < N) {
188
150
      Vector.push_back(V);
189
150
      return std::make_pair(None, true);
190
150
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::insert(unsigned long long const&)
Line
Count
Source
180
69
  std::pair<NoneType, bool> insert(const T &V) {
181
69
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
69
184
69
    VIterator I = vfind(V);
185
69
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
69
    if (Vector.size() < N) {
188
69
      Vector.push_back(V);
189
69
      return std::make_pair(None, true);
190
69
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
12
  std::pair<NoneType, bool> insert(const T &V) {
181
12
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
12
184
12
    VIterator I = vfind(V);
185
12
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
12
    if (Vector.size() < N) {
188
9
      Vector.push_back(V);
189
9
      return std::make_pair(None, true);
190
9
    }
191
3
192
3
    // Otherwise, grow from vector to set.
193
6
    
while (3
!Vector.empty()) {
194
3
      Set.insert(Vector.back());
195
3
      Vector.pop_back();
196
3
    }
197
3
    Set.insert(V);
198
3
    return std::make_pair(None, true);
199
3
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
180
13.3k
  std::pair<NoneType, bool> insert(const T &V) {
181
13.3k
    if (!isSmall())
182
2.52k
      return std::make_pair(None, Set.insert(V).second);
183
10.8k
184
10.8k
    VIterator I = vfind(V);
185
10.8k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
4.41k
      return std::make_pair(None, false);
187
6.38k
    if (Vector.size() < N) {
188
6.29k
      Vector.push_back(V);
189
6.29k
      return std::make_pair(None, true);
190
6.29k
    }
191
89
192
89
    // Otherwise, grow from vector to set.
193
801
    
while (89
!Vector.empty()) {
194
712
      Set.insert(Vector.back());
195
712
      Vector.pop_back();
196
712
    }
197
89
    Set.insert(V);
198
89
    return std::make_pair(None, true);
199
89
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
180
347k
  std::pair<NoneType, bool> insert(const T &V) {
181
347k
    if (!isSmall())
182
39.7k
      return std::make_pair(None, Set.insert(V).second);
183
307k
184
307k
    VIterator I = vfind(V);
185
307k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
187k
      return std::make_pair(None, false);
187
120k
    if (Vector.size() < N) {
188
115k
      Vector.push_back(V);
189
115k
      return std::make_pair(None, true);
190
115k
    }
191
4.13k
192
4.13k
    // Otherwise, grow from vector to set.
193
37.1k
    
while (4.13k
!Vector.empty()) {
194
33.0k
      Set.insert(Vector.back());
195
33.0k
      Vector.pop_back();
196
33.0k
    }
197
4.13k
    Set.insert(V);
198
4.13k
    return std::make_pair(None, true);
199
4.13k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::insert(llvm::AssertingVH<llvm::MemoryPhi> const&)
Line
Count
Source
180
31
  std::pair<NoneType, bool> insert(const T &V) {
181
31
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
31
184
31
    VIterator I = vfind(V);
185
31
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
31
    if (Vector.size() < N) {
188
31
      Vector.push_back(V);
189
31
      return std::make_pair(None, true);
190
31
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
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
180
13.4k
  std::pair<NoneType, bool> insert(const T &V) {
181
13.4k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
13.4k
184
13.4k
    VIterator I = vfind(V);
185
13.4k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
13.4k
    if (Vector.size() < N) {
188
13.4k
      Vector.push_back(V);
189
13.4k
      return std::make_pair(None, true);
190
13.4k
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::insert(llvm::AssertingVH<llvm::Value> const&)
Line
Count
Source
180
186
  std::pair<NoneType, bool> insert(const T &V) {
181
186
    if (!isSmall())
182
66
      return std::make_pair(None, Set.insert(V).second);
183
120
184
120
    VIterator I = vfind(V);
185
120
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
120
    if (Vector.size() < N) {
188
91
      Vector.push_back(V);
189
91
      return std::make_pair(None, true);
190
91
    }
191
29
192
29
    // Otherwise, grow from vector to set.
193
87
    
while (29
!Vector.empty()) {
194
58
      Set.insert(Vector.back());
195
58
      Vector.pop_back();
196
58
    }
197
29
    Set.insert(V);
198
29
    return std::make_pair(None, true);
199
29
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
180
37
  std::pair<NoneType, bool> insert(const T &V) {
181
37
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
37
184
37
    VIterator I = vfind(V);
185
37
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
5
      return std::make_pair(None, false);
187
32
    if (Vector.size() < N) {
188
32
      Vector.push_back(V);
189
32
      return std::make_pair(None, true);
190
32
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::insert(llvm::SlotIndex const&)
Line
Count
Source
180
261
  std::pair<NoneType, bool> insert(const T &V) {
181
261
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
261
184
261
    VIterator I = vfind(V);
185
261
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
261
    if (Vector.size() < N) {
188
261
      Vector.push_back(V);
189
261
      return std::make_pair(None, true);
190
261
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
180
6.07k
  std::pair<NoneType, bool> insert(const T &V) {
181
6.07k
    if (!isSmall())
182
6
      return std::make_pair(None, Set.insert(V).second);
183
6.06k
184
6.06k
    VIterator I = vfind(V);
185
6.06k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
6.06k
    if (Vector.size() < N) {
188
6.06k
      Vector.push_back(V);
189
6.06k
      return std::make_pair(None, true);
190
6.06k
    }
191
2
192
2
    // Otherwise, grow from vector to set.
193
34
    
while (2
!Vector.empty()) {
194
32
      Set.insert(Vector.back());
195
32
      Vector.pop_back();
196
32
    }
197
2
    Set.insert(V);
198
2
    return std::make_pair(None, true);
199
2
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
180
20.3k
  std::pair<NoneType, bool> insert(const T &V) {
181
20.3k
    if (!isSmall())
182
500
      return std::make_pair(None, Set.insert(V).second);
183
19.8k
184
19.8k
    VIterator I = vfind(V);
185
19.8k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
19.8k
    if (Vector.size() < N) {
188
19.8k
      Vector.push_back(V);
189
19.8k
      return std::make_pair(None, true);
190
19.8k
    }
191
25
192
25
    // Otherwise, grow from vector to set.
193
825
    
while (25
!Vector.empty()) {
194
800
      Set.insert(Vector.back());
195
800
      Vector.pop_back();
196
800
    }
197
25
    Set.insert(V);
198
25
    return std::make_pair(None, true);
199
25
  }
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
180
355k
  std::pair<NoneType, bool> insert(const T &V) {
181
355k
    if (!isSmall())
182
74.3k
      return std::make_pair(None, Set.insert(V).second);
183
280k
184
280k
    VIterator I = vfind(V);
185
280k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
73.1k
      return std::make_pair(None, false);
187
207k
    if (Vector.size() < N) {
188
204k
      Vector.push_back(V);
189
204k
      return std::make_pair(None, true);
190
204k
    }
191
3.52k
192
3.52k
    // Otherwise, grow from vector to set.
193
31.7k
    
while (3.52k
!Vector.empty()) {
194
28.2k
      Set.insert(Vector.back());
195
28.2k
      Vector.pop_back();
196
28.2k
    }
197
3.52k
    Set.insert(V);
198
3.52k
    return std::make_pair(None, true);
199
3.52k
  }
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
180
653k
  std::pair<NoneType, bool> insert(const T &V) {
181
653k
    if (!isSmall())
182
89.2k
      return std::make_pair(None, Set.insert(V).second);
183
564k
184
564k
    VIterator I = vfind(V);
185
564k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
564k
    if (Vector.size() < N) {
188
522k
      Vector.push_back(V);
189
522k
      return std::make_pair(None, true);
190
522k
    }
191
41.9k
192
41.9k
    // Otherwise, grow from vector to set.
193
251k
    
while (41.9k
!Vector.empty()) {
194
209k
      Set.insert(Vector.back());
195
209k
      Vector.pop_back();
196
209k
    }
197
41.9k
    Set.insert(V);
198
41.9k
    return std::make_pair(None, true);
199
41.9k
  }
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
180
696
  std::pair<NoneType, bool> insert(const T &V) {
181
696
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
696
184
696
    VIterator I = vfind(V);
185
696
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
696
    if (Vector.size() < N) {
188
696
      Vector.push_back(V);
189
696
      return std::make_pair(None, true);
190
696
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
180
230k
  std::pair<NoneType, bool> insert(const T &V) {
181
230k
    if (!isSmall())
182
454
      return std::make_pair(None, Set.insert(V).second);
183
230k
184
230k
    VIterator I = vfind(V);
185
230k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
32.2k
      return std::make_pair(None, false);
187
198k
    if (Vector.size() < N) {
188
197k
      Vector.push_back(V);
189
197k
      return std::make_pair(None, true);
190
197k
    }
191
78
192
78
    // Otherwise, grow from vector to set.
193
702
    
while (78
!Vector.empty()) {
194
624
      Set.insert(Vector.back());
195
624
      Vector.pop_back();
196
624
    }
197
78
    Set.insert(V);
198
78
    return std::make_pair(None, true);
199
78
  }
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
180
4.79M
  std::pair<NoneType, bool> insert(const T &V) {
181
4.79M
    if (!isSmall())
182
3.19M
      return std::make_pair(None, Set.insert(V).second);
183
1.59M
184
1.59M
    VIterator I = vfind(V);
185
1.59M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
958k
      return std::make_pair(None, false);
187
639k
    if (Vector.size() < N) {
188
635k
      Vector.push_back(V);
189
635k
      return std::make_pair(None, true);
190
635k
    }
191
4.43k
192
4.43k
    // Otherwise, grow from vector to set.
193
146k
    
while (4.43k
!Vector.empty()) {
194
141k
      Set.insert(Vector.back());
195
141k
      Vector.pop_back();
196
141k
    }
197
4.43k
    Set.insert(V);
198
4.43k
    return std::make_pair(None, true);
199
4.43k
  }
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
180
858k
  std::pair<NoneType, bool> insert(const T &V) {
181
858k
    if (!isSmall())
182
344
      return std::make_pair(None, Set.insert(V).second);
183
858k
184
858k
    VIterator I = vfind(V);
185
858k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
673
      return std::make_pair(None, false);
187
857k
    if (Vector.size() < N) {
188
857k
      Vector.push_back(V);
189
857k
      return std::make_pair(None, true);
190
857k
    }
191
100
192
100
    // Otherwise, grow from vector to set.
193
3.26k
    
while (100
!Vector.empty()) {
194
3.16k
      Set.insert(Vector.back());
195
3.16k
      Vector.pop_back();
196
3.16k
    }
197
100
    Set.insert(V);
198
100
    return std::make_pair(None, true);
199
100
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::insert(llvm::AssertingVH<llvm::Function> const&)
Line
Count
Source
180
40.2k
  std::pair<NoneType, bool> insert(const T &V) {
181
40.2k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
40.2k
184
40.2k
    VIterator I = vfind(V);
185
40.2k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
40.2k
    if (Vector.size() < N) {
188
40.2k
      Vector.push_back(V);
189
40.2k
      return std::make_pair(None, true);
190
40.2k
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
180
169
  std::pair<NoneType, bool> insert(const T &V) {
181
169
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
169
184
169
    VIterator I = vfind(V);
185
169
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
34
      return std::make_pair(None, false);
187
135
    if (Vector.size() < N) {
188
135
      Vector.push_back(V);
189
135
      return std::make_pair(None, true);
190
135
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::insert(clang::FileID const&)
Line
Count
Source
180
1.08k
  std::pair<NoneType, bool> insert(const T &V) {
181
1.08k
    if (!isSmall())
182
97
      return std::make_pair(None, Set.insert(V).second);
183
984
184
984
    VIterator I = vfind(V);
185
984
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
693
      return std::make_pair(None, false);
187
291
    if (Vector.size() < N) {
188
285
      Vector.push_back(V);
189
285
      return std::make_pair(None, true);
190
285
    }
191
6
192
6
    // Otherwise, grow from vector to set.
193
54
    
while (6
!Vector.empty()) {
194
48
      Set.insert(Vector.back());
195
48
      Vector.pop_back();
196
48
    }
197
6
    Set.insert(V);
198
6
    return std::make_pair(None, true);
199
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
180
139
  std::pair<NoneType, bool> insert(const T &V) {
181
139
    if (!isSmall())
182
21
      return std::make_pair(None, Set.insert(V).second);
183
118
184
118
    VIterator I = vfind(V);
185
118
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
118
    if (Vector.size() < N) {
188
114
      Vector.push_back(V);
189
114
      return std::make_pair(None, true);
190
114
    }
191
4
192
4
    // Otherwise, grow from vector to set.
193
36
    
while (4
!Vector.empty()) {
194
32
      Set.insert(Vector.back());
195
32
      Vector.pop_back();
196
32
    }
197
4
    Set.insert(V);
198
4
    return std::make_pair(None, true);
199
4
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::insert(clang::CudaArch const&)
Line
Count
Source
180
7
  std::pair<NoneType, bool> insert(const T &V) {
181
7
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
7
184
7
    VIterator I = vfind(V);
185
7
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
7
    if (Vector.size() < N) {
188
7
      Vector.push_back(V);
189
7
      return std::make_pair(None, true);
190
7
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::insert(clang::DeclarationName const&)
Line
Count
Source
180
3.65k
  std::pair<NoneType, bool> insert(const T &V) {
181
3.65k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
3.65k
184
3.65k
    VIterator I = vfind(V);
185
3.65k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
3.65k
    if (Vector.size() < N) {
188
3.65k
      Vector.push_back(V);
189
3.65k
      return std::make_pair(None, true);
190
3.65k
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
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
180
115
  std::pair<NoneType, bool> insert(const T &V) {
181
115
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
115
184
115
    VIterator I = vfind(V);
185
115
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
4
      return std::make_pair(None, false);
187
111
    if (Vector.size() < N) {
188
111
      Vector.push_back(V);
189
111
      return std::make_pair(None, true);
190
111
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
180
14.7k
  std::pair<NoneType, bool> insert(const T &V) {
181
14.7k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
14.7k
184
14.7k
    VIterator I = vfind(V);
185
14.7k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
6.54k
      return std::make_pair(None, false);
187
8.19k
    if (Vector.size() < N) {
188
8.19k
      Vector.push_back(V);
189
8.19k
      return std::make_pair(None, true);
190
8.19k
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
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
180
14
  std::pair<NoneType, bool> insert(const T &V) {
181
14
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
14
184
14
    VIterator I = vfind(V);
185
14
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
14
    if (Vector.size() < N) {
188
14
      Vector.push_back(V);
189
14
      return std::make_pair(None, true);
190
14
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
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
180
261
  std::pair<NoneType, bool> insert(const T &V) {
181
261
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
261
184
261
    VIterator I = vfind(V);
185
261
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
56
      return std::make_pair(None, false);
187
205
    if (Vector.size() < N) {
188
205
      Vector.push_back(V);
189
205
      return std::make_pair(None, true);
190
205
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::insert(clang::Selector const&)
Line
Count
Source
180
90
  std::pair<NoneType, bool> insert(const T &V) {
181
90
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
90
184
90
    VIterator I = vfind(V);
185
90
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
90
    if (Vector.size() < N) {
188
90
      Vector.push_back(V);
189
90
      return std::make_pair(None, true);
190
90
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::insert(clang::CanonicalDeclPtr<clang::FunctionDecl> const&)
Line
Count
Source
180
1.79k
  std::pair<NoneType, bool> insert(const T &V) {
181
1.79k
    if (!isSmall())
182
2
      return std::make_pair(None, Set.insert(V).second);
183
1.79k
184
1.79k
    VIterator I = vfind(V);
185
1.79k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
1.79k
    if (Vector.size() < N) {
188
1.79k
      Vector.push_back(V);
189
1.79k
      return std::make_pair(None, true);
190
1.79k
    }
191
3
192
3
    // Otherwise, grow from vector to set.
193
15
    
while (3
!Vector.empty()) {
194
12
      Set.insert(Vector.back());
195
12
      Vector.pop_back();
196
12
    }
197
3
    Set.insert(V);
198
3
    return std::make_pair(None, true);
199
3
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
180
1.40k
  std::pair<NoneType, bool> insert(const T &V) {
181
1.40k
    if (!isSmall())
182
169
      return std::make_pair(None, Set.insert(V).second);
183
1.23k
184
1.23k
    VIterator I = vfind(V);
185
1.23k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
1.23k
    if (Vector.size() < N) {
188
1.15k
      Vector.push_back(V);
189
1.15k
      return std::make_pair(None, true);
190
1.15k
    }
191
72
192
72
    // Otherwise, grow from vector to set.
193
216
    
while (72
!Vector.empty()) {
194
144
      Set.insert(Vector.back());
195
144
      Vector.pop_back();
196
144
    }
197
72
    Set.insert(V);
198
72
    return std::make_pair(None, true);
199
72
  }
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
180
13
  std::pair<NoneType, bool> insert(const T &V) {
181
13
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
13
184
13
    VIterator I = vfind(V);
185
13
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
13
    if (Vector.size() < N) {
188
13
      Vector.push_back(V);
189
13
      return std::make_pair(None, true);
190
13
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
180
14
  std::pair<NoneType, bool> insert(const T &V) {
181
14
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
14
184
14
    VIterator I = vfind(V);
185
14
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1
      return std::make_pair(None, false);
187
13
    if (Vector.size() < N) {
188
13
      Vector.push_back(V);
189
13
      return std::make_pair(None, true);
190
13
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::insert(llvm::DWARFDie const&)
Line
Count
Source
180
15.2k
  std::pair<NoneType, bool> insert(const T &V) {
181
15.2k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
15.2k
184
15.2k
    VIterator I = vfind(V);
185
15.2k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
15.2k
    if (Vector.size() < N) {
188
15.2k
      Vector.push_back(V);
189
15.2k
      return std::make_pair(None, true);
190
15.2k
    }
191
1
192
1
    // Otherwise, grow from vector to set.
193
4
    
while (1
!Vector.empty()) {
194
3
      Set.insert(Vector.back());
195
3
      Vector.pop_back();
196
3
    }
197
1
    Set.insert(V);
198
1
    return std::make_pair(None, true);
199
1
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
64
  std::pair<NoneType, bool> insert(const T &V) {
181
64
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
64
184
64
    VIterator I = vfind(V);
185
64
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
2
      return std::make_pair(None, false);
187
62
    if (Vector.size() < N) {
188
62
      Vector.push_back(V);
189
62
      return std::make_pair(None, true);
190
62
    }
191
0
192
0
    // Otherwise, grow from vector to set.
193
0
    while (!Vector.empty()) {
194
0
      Set.insert(Vector.back());
195
0
      Vector.pop_back();
196
0
    }
197
0
    Set.insert(V);
198
0
    return std::make_pair(None, true);
199
0
  }
200
201
  template <typename IterT>
202
84.5k
  void insert(IterT I, IterT E) {
203
770k
    for (; I != E; 
++I685k
)
204
685k
      insert(*I);
205
84.5k
  }
void llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert<unsigned short*>(unsigned short*, unsigned short*)
Line
Count
Source
202
6
  void insert(IterT I, IterT E) {
203
8
    for (; I != E; 
++I2
)
204
2
      insert(*I);
205
6
  }
void llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert<unsigned int const*>(unsigned int const*, unsigned int const*)
Line
Count
Source
202
84.5k
  void insert(IterT I, IterT E) {
203
770k
    for (; I != E; 
++I685k
)
204
685k
      insert(*I);
205
84.5k
  }
206
207
957k
  bool erase(const T &V) {
208
957k
    if (!isSmall())
209
472k
      return Set.erase(V);
210
882k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 485k
I != E;
++I397k
)
211
469k
      if (*I == V) {
212
72.6k
        Vector.erase(I);
213
72.6k
        return true;
214
72.6k
      }
215
485k
    
return false412k
;
216
485k
  }
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
207
899k
  bool erase(const T &V) {
208
899k
    if (!isSmall())
209
459k
      return Set.erase(V);
210
831k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 440k
I != E;
++I391k
)
211
444k
      if (*I == V) {
212
53.1k
        Vector.erase(I);
213
53.1k
        return true;
214
53.1k
      }
215
440k
    
return false387k
;
216
440k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
4.02k
  bool erase(const T &V) {
208
4.02k
    if (!isSmall())
209
400
      return Set.erase(V);
210
4.40k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 3.62k
I != E;
++I785
)
211
937
      if (*I == V) {
212
152
        Vector.erase(I);
213
152
        return true;
214
152
      }
215
3.62k
    
return false3.46k
;
216
3.62k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
31.1k
  bool erase(const T &V) {
208
31.1k
    if (!isSmall())
209
12.9k
      return Set.erase(V);
210
20.7k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 18.2k
I != E;
++I2.55k
)
211
17.7k
      if (*I == V) {
212
15.1k
        Vector.erase(I);
213
15.1k
        return true;
214
15.1k
      }
215
18.2k
    
return false3.09k
;
216
18.2k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
14.5k
  bool erase(const T &V) {
208
14.5k
    if (!isSmall())
209
0
      return Set.erase(V);
210
16.5k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 14.5k
I != E;
++I2.04k
)
211
2.57k
      if (*I == V) {
212
528
        Vector.erase(I);
213
528
        return true;
214
528
      }
215
14.5k
    
return false14.0k
;
216
14.5k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::erase(clang::DeclarationName const&)
Line
Count
Source
207
8.45k
  bool erase(const T &V) {
208
8.45k
    if (!isSmall())
209
0
      return Set.erase(V);
210
8.47k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 8.45k
I != E;
++I16
)
211
3.67k
      if (*I == V) {
212
3.65k
        Vector.erase(I);
213
3.65k
        return true;
214
3.65k
      }
215
8.45k
    
return false4.80k
;
216
8.45k
  }
217
218
8.72M
  void clear() {
219
8.72M
    Vector.clear();
220
8.72M
    Set.clear();
221
8.72M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
24.5k
  void clear() {
219
24.5k
    Vector.clear();
220
24.5k
    Set.clear();
221
24.5k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
23.9k
  void clear() {
219
23.9k
    Vector.clear();
220
23.9k
    Set.clear();
221
23.9k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
5.71M
  void clear() {
219
5.71M
    Vector.clear();
220
5.71M
    Set.clear();
221
5.71M
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::clear()
Line
Count
Source
218
122
  void clear() {
219
122
    Vector.clear();
220
122
    Set.clear();
221
122
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
1.10M
  void clear() {
219
1.10M
    Vector.clear();
220
1.10M
    Set.clear();
221
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
218
1.07M
  void clear() {
219
1.07M
    Vector.clear();
220
1.07M
    Set.clear();
221
1.07M
  }
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
218
283
  void clear() {
219
283
    Vector.clear();
220
283
    Set.clear();
221
283
  }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::clear()
Line
Count
Source
218
102k
  void clear() {
219
102k
    Vector.clear();
220
102k
    Set.clear();
221
102k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::clear()
Line
Count
Source
218
102k
  void clear() {
219
102k
    Vector.clear();
220
102k
    Set.clear();
221
102k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::clear()
Line
Count
Source
218
582k
  void clear() {
219
582k
    Vector.clear();
220
582k
    Set.clear();
221
582k
  }
222
223
582k
  const_iterator begin() const {
224
582k
    if (isSmall())
225
582k
      return {Vector.begin()};
226
18.4E
    return {Set.begin()};
227
18.4E
  }
228
229
582k
  const_iterator end() const {
230
582k
    if (isSmall())
231
582k
      return {Vector.end()};
232
2
    return {Set.end()};
233
2
  }
234
235
private:
236
167M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 4u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
2.97k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
236
851k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
48.8M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
16.9M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
32.1M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
6.66M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
236
4.82k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
52.9M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
314
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
236
69
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
90
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
236
16.5k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
236
378k
  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
236
920
  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
236
15.7k
  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
236
13.4k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
236
272
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::isSmall() const
Line
Count
Source
236
1.15k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 16u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
255k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 32u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
248k
  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
236
355k
  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
236
1.02M
  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
236
5.58k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
236
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
236
4.79M
  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
236
858k
  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
236
1.20M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
236
169
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::isSmall() const
Line
Count
Source
236
1.08k
  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
236
1.20k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::isSmall() const
Line
Count
Source
236
67
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::isSmall() const
Line
Count
Source
236
12.1k
  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
236
115
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
236
17.3k
  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
236
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
236
261
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::isSmall() const
Line
Count
Source
236
123
  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
236
2.16k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
236
3.36k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
13
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
14
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::isSmall() const
Line
Count
Source
236
30.4k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
124
  bool isSmall() const { return Set.empty(); }
237
238
147M
  VIterator vfind(const T &V) const {
239
369M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I221M
)
240
256M
      if (*I == V)
241
34.7M
        return I;
242
147M
    
return Vector.end()113M
;
243
147M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
2.59k
  VIterator vfind(const T &V) const {
239
3.57k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I981
)
240
1.51k
      if (*I == V)
241
535
        return I;
242
2.59k
    
return Vector.end()2.05k
;
243
2.59k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
238
516k
  VIterator vfind(const T &V) const {
239
786k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I269k
)
240
275k
      if (*I == V)
241
5.79k
        return I;
242
516k
    
return Vector.end()510k
;
243
516k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
48.8M
  VIterator vfind(const T &V) const {
239
123M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I74.4M
)
240
91.6M
      if (*I == V)
241
17.1M
        return I;
242
48.8M
    
return Vector.end()31.6M
;
243
48.8M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
16.4M
  VIterator vfind(const T &V) const {
239
19.6M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3.12M
)
240
3.37M
      if (*I == V)
241
252k
        return I;
242
16.4M
    
return Vector.end()16.2M
;
243
16.4M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
26.4M
  VIterator vfind(const T &V) const {
239
49.2M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I22.7M
)
240
25.3M
      if (*I == V)
241
2.64M
        return I;
242
26.4M
    
return Vector.end()23.8M
;
243
26.4M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
2.74M
  VIterator vfind(const T &V) const {
239
4.45M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.70M
)
240
2.31M
      if (*I == V)
241
607k
        return I;
242
2.74M
    
return Vector.end()2.14M
;
243
2.74M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
238
4.82k
  VIterator vfind(const T &V) const {
239
5.31k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I489
)
240
508
      if (*I == V)
241
19
        return I;
242
4.82k
    
return Vector.end()4.80k
;
243
4.82k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
47.9M
  VIterator vfind(const T &V) const {
239
153M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I105M
)
240
118M
      if (*I == V)
241
12.6M
        return I;
242
47.9M
    
return Vector.end()35.3M
;
243
47.9M
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
314
  VIterator vfind(const T &V) const {
239
838
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I524
)
240
529
      if (*I == V)
241
5
        return I;
242
314
    
return Vector.end()309
;
243
314
  }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
238
69
  VIterator vfind(const T &V) const {
239
71
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2
)
240
2
      if (*I == V)
241
0
        return I;
242
69
    return Vector.end();
243
69
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
84
  VIterator vfind(const T &V) const {
239
89
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
240
11
      if (*I == V)
241
6
        return I;
242
84
    
return Vector.end()78
;
243
84
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
238
13.7k
  VIterator vfind(const T &V) const {
239
47.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I34.2k
)
240
39.5k
      if (*I == V)
241
5.28k
        return I;
242
13.7k
    
return Vector.end()8.46k
;
243
13.7k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
238
307k
  VIterator vfind(const T &V) const {
239
741k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I433k
)
240
621k
      if (*I == V)
241
187k
        return I;
242
307k
    
return Vector.end()120k
;
243
307k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::vfind(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
238
920
  VIterator vfind(const T &V) const {
239
945
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I25
)
240
30
      if (*I == V)
241
5
        return I;
242
920
    
return Vector.end()915
;
243
920
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::vfind(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
238
15.0k
  VIterator vfind(const T &V) const {
239
17.4k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.45k
)
240
2.50k
      if (*I == V)
241
44
        return I;
242
15.0k
    
return Vector.end()14.9k
;
243
15.0k
  }
llvm::SmallSet<std::__1::pair<llvm::PHINode*, llvm::PHINode*>, 8u, std::__1::less<std::__1::pair<llvm::PHINode*, llvm::PHINode*> > >::vfind(std::__1::pair<llvm::PHINode*, llvm::PHINode*> const&) const
Line
Count
Source
238
13.4k
  VIterator vfind(const T &V) const {
239
13.4k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I22
)
240
22
      if (*I == V)
241
0
        return I;
242
13.4k
    return Vector.end();
243
13.4k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
238
272
  VIterator vfind(const T &V) const {
239
304
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I32
)
240
57
      if (*I == V)
241
25
        return I;
242
272
    
return Vector.end()247
;
243
272
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::vfind(llvm::SlotIndex const&) const
Line
Count
Source
238
1.15k
  VIterator vfind(const T &V) const {
239
1.36k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I204
)
240
465
      if (*I == V)
241
261
        return I;
242
1.15k
    
return Vector.end()897
;
243
1.15k
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
255k
  VIterator vfind(const T &V) const {
239
288k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I32.9k
)
240
39.0k
      if (*I == V)
241
6.03k
        return I;
242
255k
    
return Vector.end()249k
;
243
255k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
242k
  VIterator vfind(const T &V) const {
239
741k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I499k
)
240
544k
      if (*I == V)
241
44.8k
        return I;
242
242k
    
return Vector.end()197k
;
243
242k
  }
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
238
280k
  VIterator vfind(const T &V) const {
239
696k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I415k
)
240
488k
      if (*I == V)
241
73.1k
        return I;
242
280k
    
return Vector.end()207k
;
243
280k
  }
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
238
808k
  VIterator vfind(const T &V) const {
239
1.99M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.18M
)
240
1.32M
      if (*I == V)
241
133k
        return I;
242
808k
    
return Vector.end()675k
;
243
808k
  }
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
238
5.58k
  VIterator vfind(const T &V) const {
239
27.0k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I21.4k
)
240
24.8k
      if (*I == V)
241
3.35k
        return I;
242
5.58k
    
return Vector.end()2.23k
;
243
5.58k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
238
230k
  VIterator vfind(const T &V) const {
239
517k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I287k
)
240
319k
      if (*I == V)
241
32.2k
        return I;
242
230k
    
return Vector.end()198k
;
243
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
238
1.59M
  VIterator vfind(const T &V) const {
239
11.9M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I10.3M
)
240
11.3M
      if (*I == V)
241
958k
        return I;
242
1.59M
    
return Vector.end()639k
;
243
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
238
858k
  VIterator vfind(const T &V) const {
239
1.20M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I351k
)
240
351k
      if (*I == V)
241
673
        return I;
242
858k
    
return Vector.end()857k
;
243
858k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::vfind(llvm::AssertingVH<llvm::Function> const&) const
Line
Count
Source
238
40.2k
  VIterator vfind(const T &V) const {
239
54.4k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I14.2k
)
240
14.2k
      if (*I == V)
241
0
        return I;
242
40.2k
    return Vector.end();
243
40.2k
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
238
169
  VIterator vfind(const T &V) const {
239
197
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I28
)
240
62
      if (*I == V)
241
34
        return I;
242
169
    
return Vector.end()135
;
243
169
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::vfind(clang::FileID const&) const
Line
Count
Source
238
984
  VIterator vfind(const T &V) const {
239
1.80k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I820
)
240
1.51k
      if (*I == V)
241
693
        return I;
242
984
    
return Vector.end()291
;
243
984
  }
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
238
998
  VIterator vfind(const T &V) const {
239
2.46k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.46k
)
240
1.47k
      if (*I == V)
241
8
        return I;
242
998
    
return Vector.end()990
;
243
998
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::vfind(clang::CudaArch const&) const
Line
Count
Source
238
67
  VIterator vfind(const T &V) const {
239
70
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3
)
240
8
      if (*I == V)
241
5
        return I;
242
67
    
return Vector.end()62
;
243
67
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::vfind(clang::DeclarationName const&) const
Line
Count
Source
238
3.65k
  VIterator vfind(const T &V) const {
239
3.68k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I31
)
240
31
      if (*I == V)
241
0
        return I;
242
3.65k
    return Vector.end();
243
3.65k
  }
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
238
115
  VIterator vfind(const T &V) const {
239
262
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I147
)
240
151
      if (*I == V)
241
4
        return I;
242
115
    
return Vector.end()111
;
243
115
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
238
14.7k
  VIterator vfind(const T &V) const {
239
26.3k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I11.6k
)
240
18.1k
      if (*I == V)
241
6.54k
        return I;
242
14.7k
    
return Vector.end()8.19k
;
243
14.7k
  }
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
238
114
  VIterator vfind(const T &V) const {
239
583
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I469
)
240
508
      if (*I == V)
241
39
        return I;
242
114
    
return Vector.end()75
;
243
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
238
261
  VIterator vfind(const T &V) const {
239
266
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
240
61
      if (*I == V)
241
56
        return I;
242
261
    
return Vector.end()205
;
243
261
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::vfind(clang::Selector const&) const
Line
Count
Source
238
123
  VIterator vfind(const T &V) const {
239
656
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I533
)
240
563
      if (*I == V)
241
30
        return I;
242
123
    
return Vector.end()93
;
243
123
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::vfind(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const
Line
Count
Source
238
2.15k
  VIterator vfind(const T &V) const {
239
2.79k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I633
)
240
633
      if (*I == V)
241
0
        return I;
242
2.15k
    return Vector.end();
243
2.15k
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
238
2.27k
  VIterator vfind(const T &V) const {
239
3.27k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I999
)
240
1.52k
      if (*I == V)
241
522
        return I;
242
2.27k
    
return Vector.end()1.75k
;
243
2.27k
  }
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
13
  VIterator vfind(const T &V) const {
239
20
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I7
)
240
7
      if (*I == V)
241
0
        return I;
242
13
    return Vector.end();
243
13
  }
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
14
  VIterator vfind(const T &V) const {
239
14
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I0
)
240
1
      if (*I == V)
241
1
        return I;
242
14
    
return Vector.end()13
;
243
14
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::vfind(llvm::DWARFDie const&) const
Line
Count
Source
238
30.4k
  VIterator vfind(const T &V) const {
239
30.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I554
)
240
556
      if (*I == V)
241
2
        return I;
242
30.4k
    
return Vector.end()30.4k
;
243
30.4k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
124
  VIterator vfind(const T &V) const {
239
159
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I35
)
240
94
      if (*I == V)
241
59
        return I;
242
124
    
return Vector.end()65
;
243
124
  }
244
};
245
246
/// If this set is of pointer values, transparently switch over to using
247
/// SmallPtrSet for performance.
248
template <typename PointeeType, unsigned N>
249
class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
250
251
} // end namespace llvm
252
253
#endif // LLVM_ADT_SMALLSET_H