Coverage Report

Created: 2018-07-20 23:04

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/ADT/SmallSet.h
Line
Count
Source
1
//===- llvm/ADT/SmallSet.h - 'Normally small' sets --------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// This file defines the SmallSet class.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_ADT_SMALLSET_H
15
#define LLVM_ADT_SMALLSET_H
16
17
#include "llvm/ADT/None.h"
18
#include "llvm/ADT/SmallPtrSet.h"
19
#include "llvm/ADT/SmallVector.h"
20
#include "llvm/Support/Compiler.h"
21
#include <cstddef>
22
#include <functional>
23
#include <set>
24
#include <utility>
25
26
namespace llvm {
27
28
/// SmallSet - This maintains a set of unique values, optimizing for the case
29
/// when the set is small (less than N).  In this case, the set can be
30
/// maintained with no mallocs.  If the set gets large, we expand to using an
31
/// std::set to maintain reasonable lookup times.
32
///
33
/// Note that this set does not provide a way to iterate over members in the
34
/// set.
35
template <typename T, unsigned N, typename C = std::less<T>>
36
class SmallSet {
37
  /// Use a SmallVector to hold the elements here (even though it will never
38
  /// reach its 'large' stage) to avoid calling the default ctors of elements
39
  /// we will never use.
40
  SmallVector<T, N> Vector;
41
  std::set<T, C> Set;
42
43
  using VIterator = typename SmallVector<T, N>::const_iterator;
44
  using mutable_iterator = typename SmallVector<T, N>::iterator;
45
46
  // In small mode SmallPtrSet uses linear search for the elements, so it is
47
  // not a good idea to choose this value too high. You may consider using a
48
  // DenseSet<> instead if you expect many elements in the set.
49
  static_assert(N <= 32, "N should be small");
50
51
public:
52
  using size_type = size_t;
53
54
89.1M
  SmallSet() = default;
llvm::SmallSet<int, 4u, std::__1::less<int> >::SmallSet()
Line
Count
Source
54
31.1k
  SmallSet() = default;
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
54
321k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
39.9M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
11.1M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
16.2M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
858k
  SmallSet() = default;
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::SmallSet()
Line
Count
Source
54
4.19k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
17.5M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
48
  SmallSet() = default;
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
54
1.97k
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
54
24.6k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::SmallSet()
Line
Count
Source
54
30.8k
  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
54
16.8k
  SmallSet() = default;
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::SmallSet()
Line
Count
Source
54
534
  SmallSet() = default;
llvm::SmallSet<int, 16u, std::__1::less<int> >::SmallSet()
Line
Count
Source
54
484k
  SmallSet() = default;
llvm::SmallSet<int, 32u, std::__1::less<int> >::SmallSet()
Line
Count
Source
54
148k
  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
54
30.7k
  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
54
81
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::SmallSet()
Line
Count
Source
54
1.06M
  SmallSet() = default;
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
54
202k
  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
54
100k
  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
54
728k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
54
112
  SmallSet() = default;
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::SmallSet()
Line
Count
Source
54
167
  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
54
167
  SmallSet() = default;
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::SmallSet()
Line
Count
Source
54
26.5k
  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
54
292
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
54
27.6k
  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
54
10.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
54
2
  SmallSet() = default;
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::SmallSet()
Line
Count
Source
54
20
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
54
76
  SmallSet() = default;
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::SmallSet()
Line
Count
Source
54
20.3k
  SmallSet() = default;
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::SmallSet()
Line
Count
Source
54
1.38k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
54
934
  SmallSet() = default;
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::SmallSet()
Line
Count
Source
54
15.2k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
54
34
  SmallSet() = default;
55
56
26.9M
  LLVM_NODISCARD bool empty() const {
57
26.9M
    return Vector.empty() && 
Set.empty()25.5M
;
58
26.9M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
56
260
  LLVM_NODISCARD bool empty() const {
57
260
    return Vector.empty() && 
Set.empty()0
;
58
260
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
56
973k
  LLVM_NODISCARD bool empty() const {
57
973k
    return Vector.empty() && 
Set.empty()471k
;
58
973k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
56
972k
  LLVM_NODISCARD bool empty() const {
57
972k
    return Vector.empty() && 
Set.empty()472k
;
58
972k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
56
24.1M
  LLVM_NODISCARD bool empty() const {
57
24.1M
    return Vector.empty() && 
Set.empty()23.7M
;
58
24.1M
  }
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
56
371
  LLVM_NODISCARD bool empty() const {
57
371
    return Vector.empty() && 
Set.empty()2
;
58
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
56
822k
  LLVM_NODISCARD bool empty() const {
57
822k
    return Vector.empty() && 
Set.empty()822k
;
58
822k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::empty() const
Line
Count
Source
56
16.5k
  LLVM_NODISCARD bool empty() const {
57
16.5k
    return Vector.empty() && 
Set.empty()14.2k
;
58
16.5k
  }
59
60
353k
  size_type size() const {
61
353k
    return isSmall() ? 
Vector.size()349k
:
Set.size()3.93k
;
62
353k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::size() const
Line
Count
Source
60
313k
  size_type size() const {
61
313k
    return isSmall() ? 
Vector.size()313k
:
Set.size()26
;
62
313k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::size() const
Line
Count
Source
60
15.4k
  size_type size() const {
61
15.4k
    return isSmall() ? 
Vector.size()15.0k
:
Set.size()434
;
62
15.4k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
60
22.5k
  size_type size() const {
61
22.5k
    return isSmall() ? 
Vector.size()19.0k
:
Set.size()3.47k
;
62
22.5k
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
60
2.22k
  size_type size() const {
61
2.22k
    return isSmall() ? Vector.size() : 
Set.size()0
;
62
2.22k
  }
63
64
  /// count - Return 1 if the element is in the set, 0 otherwise.
65
40.6M
  size_type count(const T &V) const {
66
40.6M
    if (isSmall()) {
67
37.3M
      // Since the collection is small, just do a linear search.
68
37.3M
      return vfind(V) == Vector.end() ? 
025.4M
:
111.8M
;
69
37.3M
    } else {
70
3.39M
      return Set.count(V);
71
3.39M
    }
72
40.6M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
65
2.43k
  size_type count(const T &V) const {
66
2.43k
    if (isSmall()) {
67
2.12k
      // Since the collection is small, just do a linear search.
68
2.12k
      return vfind(V) == Vector.end() ? 
01.69k
:
1432
;
69
2.12k
    } else {
70
311
      return Set.count(V);
71
311
    }
72
2.43k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
3.11M
  size_type count(const T &V) const {
66
3.11M
    if (isSmall()) {
67
3.10M
      // Since the collection is small, just do a linear search.
68
3.10M
      return vfind(V) == Vector.end() ? 
02.53M
:
1578k
;
69
3.10M
    } else {
70
1.57k
      return Set.count(V);
71
1.57k
    }
72
3.11M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
991k
  size_type count(const T &V) const {
66
991k
    if (isSmall()) {
67
985k
      // Since the collection is small, just do a linear search.
68
985k
      return vfind(V) == Vector.end() ? 
0848k
:
1136k
;
69
985k
    } else {
70
6.15k
      return Set.count(V);
71
6.15k
    }
72
991k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
14.8M
  size_type count(const T &V) const {
66
14.8M
    if (isSmall()) {
67
13.3M
      // Since the collection is small, just do a linear search.
68
13.3M
      return vfind(V) == Vector.end() ? 
012.1M
:
11.22M
;
69
13.3M
    } else {
70
1.48M
      return Set.count(V);
71
1.48M
    }
72
14.8M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
2.85M
  size_type count(const T &V) const {
66
2.85M
    if (isSmall()) {
67
971k
      // Since the collection is small, just do a linear search.
68
971k
      return vfind(V) == Vector.end() ? 
0549k
:
1422k
;
69
1.88M
    } else {
70
1.88M
      return Set.count(V);
71
1.88M
    }
72
2.85M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::count(unsigned long long const&) const
Line
Count
Source
65
2.30k
  size_type count(const T &V) const {
66
2.30k
    if (isSmall()) {
67
2.30k
      // Since the collection is small, just do a linear search.
68
2.30k
      return vfind(V) == Vector.end() ? 
02.28k
:
115
;
69
2.30k
    } else {
70
0
      return Set.count(V);
71
0
    }
72
2.30k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
18.4M
  size_type count(const T &V) const {
66
18.4M
    if (isSmall()) {
67
18.4M
      // Since the collection is small, just do a linear search.
68
18.4M
      return vfind(V) == Vector.end() ? 
08.99M
:
19.44M
;
69
18.4M
    } else {
70
7.09k
      return Set.count(V);
71
7.09k
    }
72
18.4M
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
73
  size_type count(const T &V) const {
66
73
    if (isSmall()) {
67
67
      // Since the collection is small, just do a linear search.
68
67
      return vfind(V) == Vector.end() ? 
061
:
16
;
69
67
    } else {
70
6
      return Set.count(V);
71
6
    }
72
73
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
65
2.90k
  size_type count(const T &V) const {
66
2.90k
    if (isSmall()) {
67
2.69k
      // Since the collection is small, just do a linear search.
68
2.69k
      return vfind(V) == Vector.end() ? 
01.88k
:
1807
;
69
2.69k
    } else {
70
209
      return Set.count(V);
71
209
    }
72
2.90k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::count(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
65
52
  size_type count(const T &V) const {
66
52
    if (isSmall()) {
67
52
      // Since the collection is small, just do a linear search.
68
52
      return vfind(V) == Vector.end() ? 
049
:
13
;
69
52
    } else {
70
0
      return Set.count(V);
71
0
    }
72
52
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::count(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
65
5.75k
  size_type count(const T &V) const {
66
5.75k
    if (isSmall()) {
67
4.96k
      // Since the collection is small, just do a linear search.
68
4.96k
      return vfind(V) == Vector.end() ? 
04.92k
:
144
;
69
4.96k
    } else {
70
786
      return Set.count(V);
71
786
    }
72
5.75k
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::count(llvm::SlotIndex const&) const
Line
Count
Source
65
814
  size_type count(const T &V) const {
66
814
    if (isSmall()) {
67
814
      // Since the collection is small, just do a linear search.
68
814
      return vfind(V) == Vector.end() ? 
0568
:
1246
;
69
814
    } else {
70
0
      return Set.count(V);
71
0
    }
72
814
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
65
223k
  size_type count(const T &V) const {
66
223k
    if (isSmall()) {
67
223k
      // Since the collection is small, just do a linear search.
68
223k
      return vfind(V) == Vector.end() ? 
0217k
:
15.59k
;
69
223k
    } else {
70
0
      return Set.count(V);
71
0
    }
72
223k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
65
204k
  size_type count(const T &V) const {
66
204k
    if (isSmall()) {
67
199k
      // Since the collection is small, just do a linear search.
68
199k
      return vfind(V) == Vector.end() ? 
0165k
:
134.4k
;
69
199k
    } else {
70
5.06k
      return Set.count(V);
71
5.06k
    }
72
204k
  }
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
65
4.41k
  size_type count(const T &V) const {
66
4.41k
    if (isSmall()) {
67
4.41k
      // Since the collection is small, just do a linear search.
68
4.41k
      return vfind(V) == Vector.end() ? 
01.31k
:
13.10k
;
69
4.41k
    } else {
70
0
      return Set.count(V);
71
0
    }
72
4.41k
  }
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
65
1.05k
  size_type count(const T &V) const {
66
1.05k
    if (isSmall()) {
67
869
      // Since the collection is small, just do a linear search.
68
869
      return vfind(V) == Vector.end() ? 
0861
:
18
;
69
869
    } else {
70
190
      return Set.count(V);
71
190
    }
72
1.05k
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::count(clang::CudaArch const&) const
Line
Count
Source
65
55
  size_type count(const T &V) const {
66
55
    if (isSmall()) {
67
55
      // Since the collection is small, just do a linear search.
68
55
      return vfind(V) == Vector.end() ? 
050
:
15
;
69
55
    } else {
70
0
      return Set.count(V);
71
0
    }
72
55
  }
llvm::SmallSet<std::__1::pair<clang::IdentifierInfo const*, clang::Selector>, 12u, std::__1::less<std::__1::pair<clang::IdentifierInfo const*, clang::Selector> > >::count(std::__1::pair<clang::IdentifierInfo const*, clang::Selector> const&) const
Line
Count
Source
65
100
  size_type count(const T &V) const {
66
100
    if (isSmall()) {
67
100
      // Since the collection is small, just do a linear search.
68
100
      return vfind(V) == Vector.end() ? 
061
:
139
;
69
100
    } else {
70
0
      return Set.count(V);
71
0
    }
72
100
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::count(clang::Selector const&) const
Line
Count
Source
65
33
  size_type count(const T &V) const {
66
33
    if (isSmall()) {
67
33
      // Since the collection is small, just do a linear search.
68
33
      return vfind(V) == Vector.end() ? 
03
:
130
;
69
33
    } else {
70
0
      return Set.count(V);
71
0
    }
72
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
65
195
  size_type count(const T &V) const {
66
195
    if (isSmall()) {
67
193
      // Since the collection is small, just do a linear search.
68
193
      return vfind(V) == Vector.end() ? 0 : 
10
;
69
193
    } else {
70
2
      return Set.count(V);
71
2
    }
72
195
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::count(clang::SourceLocation const&) const
Line
Count
Source
65
1.93k
  size_type count(const T &V) const {
66
1.93k
    if (isSmall()) {
67
1.01k
      // Since the collection is small, just do a linear search.
68
1.01k
      return vfind(V) == Vector.end() ? 
0514
:
1501
;
69
1.01k
    } else {
70
921
      return Set.count(V);
71
921
    }
72
1.93k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::count(llvm::DWARFDie const&) const
Line
Count
Source
65
15.6k
  size_type count(const T &V) const {
66
15.6k
    if (isSmall()) {
67
15.6k
      // Since the collection is small, just do a linear search.
68
15.6k
      return vfind(V) == Vector.end() ? 
015.5k
:
12
;
69
15.6k
    } else {
70
0
      return Set.count(V);
71
0
    }
72
15.6k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
65
40
  size_type count(const T &V) const {
66
40
    if (isSmall()) {
67
40
      // Since the collection is small, just do a linear search.
68
40
      return vfind(V) == Vector.end() ? 
03
:
137
;
69
40
    } else {
70
0
      return Set.count(V);
71
0
    }
72
40
  }
73
74
  /// insert - Insert an element into the set if it isn't already there.
75
  /// Returns true if the element is inserted (it was not in the set before).
76
  /// The first value of the returned pair is unused and provided for
77
  /// partial compatibility with the standard library self-associative container
78
  /// concept.
79
  // FIXME: Add iterators that abstract over the small and large form, and then
80
  // return those here.
81
106M
  std::pair<NoneType, bool> insert(const T &V) {
82
106M
    if (!isSmall())
83
15.5M
      return std::make_pair(None, Set.insert(V).second);
84
90.8M
85
90.8M
    VIterator I = vfind(V);
86
90.8M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
21.7M
      return std::make_pair(None, false);
88
69.1M
    if (Vector.size() < N) {
89
67.5M
      Vector.push_back(V);
90
67.5M
      return std::make_pair(None, true);
91
67.5M
    }
92
1.56M
93
1.56M
    // Otherwise, grow from vector to set.
94
8.80M
    
while (1.56M
!Vector.empty()) {
95
7.24M
      Set.insert(Vector.back());
96
7.24M
      Vector.pop_back();
97
7.24M
    }
98
1.56M
    Set.insert(V);
99
1.56M
    return std::make_pair(None, true);
100
1.56M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
81
598
  std::pair<NoneType, bool> insert(const T &V) {
82
598
    if (!isSmall())
83
65
      return std::make_pair(None, Set.insert(V).second);
84
533
85
533
    VIterator I = vfind(V);
86
533
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
114
      return std::make_pair(None, false);
88
419
    if (Vector.size() < N) {
89
407
      Vector.push_back(V);
90
407
      return std::make_pair(None, true);
91
407
    }
92
12
93
12
    // Otherwise, grow from vector to set.
94
60
    
while (12
!Vector.empty()) {
95
48
      Set.insert(Vector.back());
96
48
      Vector.pop_back();
97
48
    }
98
12
    Set.insert(V);
99
12
    return std::make_pair(None, true);
100
12
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
81
480k
  std::pair<NoneType, bool> insert(const T &V) {
82
480k
    if (!isSmall())
83
15.9k
      return std::make_pair(None, Set.insert(V).second);
84
464k
85
464k
    VIterator I = vfind(V);
86
464k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
5.82k
      return std::make_pair(None, false);
88
458k
    if (Vector.size() < N) {
89
455k
      Vector.push_back(V);
90
455k
      return std::make_pair(None, true);
91
455k
    }
92
2.68k
93
2.68k
    // Otherwise, grow from vector to set.
94
13.4k
    
while (2.68k
!Vector.empty()) {
95
10.7k
      Set.insert(Vector.back());
96
10.7k
      Vector.pop_back();
97
10.7k
    }
98
2.68k
    Set.insert(V);
99
2.68k
    return std::make_pair(None, true);
100
2.68k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
45.6M
  std::pair<NoneType, bool> insert(const T &V) {
82
45.6M
    if (!isSmall())
83
1.01M
      return std::make_pair(None, Set.insert(V).second);
84
44.6M
85
44.6M
    VIterator I = vfind(V);
86
44.6M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
16.1M
      return std::make_pair(None, false);
88
28.4M
    if (Vector.size() < N) {
89
28.4M
      Vector.push_back(V);
90
28.4M
      return std::make_pair(None, true);
91
28.4M
    }
92
14.2k
93
14.2k
    // Otherwise, grow from vector to set.
94
128k
    
while (14.2k
!Vector.empty()) {
95
114k
      Set.insert(Vector.back());
96
114k
      Vector.pop_back();
97
114k
    }
98
14.2k
    Set.insert(V);
99
14.2k
    return std::make_pair(None, true);
100
14.2k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
395k
  std::pair<NoneType, bool> insert(const T &V) {
82
395k
    if (!isSmall())
83
2.36k
      return std::make_pair(None, Set.insert(V).second);
84
393k
85
393k
    VIterator I = vfind(V);
86
393k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
106k
      return std::make_pair(None, false);
88
286k
    if (Vector.size() < N) {
89
286k
      Vector.push_back(V);
90
286k
      return std::make_pair(None, true);
91
286k
    }
92
52
93
52
    // Otherwise, grow from vector to set.
94
884
    
while (52
!Vector.empty()) {
95
832
      Set.insert(Vector.back());
96
832
      Vector.pop_back();
97
832
    }
98
52
    Set.insert(V);
99
52
    return std::make_pair(None, true);
100
52
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
17.2M
  std::pair<NoneType, bool> insert(const T &V) {
82
17.2M
    if (!isSmall())
83
5.19M
      return std::make_pair(None, Set.insert(V).second);
84
12.0M
85
12.0M
    VIterator I = vfind(V);
86
12.0M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
1.11M
      return std::make_pair(None, false);
88
10.9M
    if (Vector.size() < N) {
89
9.58M
      Vector.push_back(V);
90
9.58M
      return std::make_pair(None, true);
91
9.58M
    }
92
1.35M
93
1.35M
    // Otherwise, grow from vector to set.
94
6.76M
    
while (1.35M
!Vector.empty()) {
95
5.41M
      Set.insert(Vector.back());
96
5.41M
      Vector.pop_back();
97
5.41M
    }
98
1.35M
    Set.insert(V);
99
1.35M
    return std::make_pair(None, true);
100
1.35M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
3.14M
  std::pair<NoneType, bool> insert(const T &V) {
82
3.14M
    if (!isSmall())
83
1.56M
      return std::make_pair(None, Set.insert(V).second);
84
1.57M
85
1.57M
    VIterator I = vfind(V);
86
1.57M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
134k
      return std::make_pair(None, false);
88
1.44M
    if (Vector.size() < N) {
89
1.30M
      Vector.push_back(V);
90
1.30M
      return std::make_pair(None, true);
91
1.30M
    }
92
140k
93
140k
    // Otherwise, grow from vector to set.
94
420k
    
while (140k
!Vector.empty()) {
95
280k
      Set.insert(Vector.back());
96
280k
      Vector.pop_back();
97
280k
    }
98
140k
    Set.insert(V);
99
140k
    return std::make_pair(None, true);
100
140k
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::insert(unsigned long long const&)
Line
Count
Source
81
2.28k
  std::pair<NoneType, bool> insert(const T &V) {
82
2.28k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
2.28k
85
2.28k
    VIterator I = vfind(V);
86
2.28k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
2.28k
    if (Vector.size() < N) {
89
2.28k
      Vector.push_back(V);
90
2.28k
      return std::make_pair(None, true);
91
2.28k
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
32.9M
  std::pair<NoneType, bool> insert(const T &V) {
82
32.9M
    if (!isSmall())
83
4.46M
      return std::make_pair(None, Set.insert(V).second);
84
28.4M
85
28.4M
    VIterator I = vfind(V);
86
28.4M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
2.97M
      return std::make_pair(None, false);
88
25.4M
    if (Vector.size() < N) {
89
25.4M
      Vector.push_back(V);
90
25.4M
      return std::make_pair(None, true);
91
25.4M
    }
92
38.2k
93
38.2k
    // Otherwise, grow from vector to set.
94
1.26M
    
while (38.2k
!Vector.empty()) {
95
1.22M
      Set.insert(Vector.back());
96
1.22M
      Vector.pop_back();
97
1.22M
    }
98
38.2k
    Set.insert(V);
99
38.2k
    return std::make_pair(None, true);
100
38.2k
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
12
  std::pair<NoneType, bool> insert(const T &V) {
82
12
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
12
85
12
    VIterator I = vfind(V);
86
12
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
12
    if (Vector.size() < N) {
89
9
      Vector.push_back(V);
90
9
      return std::make_pair(None, true);
91
9
    }
92
3
93
3
    // Otherwise, grow from vector to set.
94
6
    
while (3
!Vector.empty()) {
95
3
      Set.insert(Vector.back());
96
3
      Vector.pop_back();
97
3
    }
98
3
    Set.insert(V);
99
3
    return std::make_pair(None, true);
100
3
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
81
12.3k
  std::pair<NoneType, bool> insert(const T &V) {
82
12.3k
    if (!isSmall())
83
2.40k
      return std::make_pair(None, Set.insert(V).second);
84
9.89k
85
9.89k
    VIterator I = vfind(V);
86
9.89k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
4.07k
      return std::make_pair(None, false);
88
5.82k
    if (Vector.size() < N) {
89
5.73k
      Vector.push_back(V);
90
5.73k
      return std::make_pair(None, true);
91
5.73k
    }
92
85
93
85
    // Otherwise, grow from vector to set.
94
765
    
while (85
!Vector.empty()) {
95
680
      Set.insert(Vector.back());
96
680
      Vector.pop_back();
97
680
    }
98
85
    Set.insert(V);
99
85
    return std::make_pair(None, true);
100
85
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
81
258k
  std::pair<NoneType, bool> insert(const T &V) {
82
258k
    if (!isSmall())
83
35.6k
      return std::make_pair(None, Set.insert(V).second);
84
223k
85
223k
    VIterator I = vfind(V);
86
223k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
129k
      return std::make_pair(None, false);
88
93.4k
    if (Vector.size() < N) {
89
90.0k
      Vector.push_back(V);
90
90.0k
      return std::make_pair(None, true);
91
90.0k
    }
92
3.45k
93
3.45k
    // Otherwise, grow from vector to set.
94
31.1k
    
while (3.45k
!Vector.empty()) {
95
27.6k
      Set.insert(Vector.back());
96
27.6k
      Vector.pop_back();
97
27.6k
    }
98
3.45k
    Set.insert(V);
99
3.45k
    return std::make_pair(None, true);
100
3.45k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::insert(llvm::AssertingVH<llvm::MemoryPhi> const&)
Line
Count
Source
81
13
  std::pair<NoneType, bool> insert(const T &V) {
82
13
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
13
85
13
    VIterator I = vfind(V);
86
13
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
13
    if (Vector.size() < N) {
89
13
      Vector.push_back(V);
90
13
      return std::make_pair(None, true);
91
13
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
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
81
16.8k
  std::pair<NoneType, bool> insert(const T &V) {
82
16.8k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
16.8k
85
16.8k
    VIterator I = vfind(V);
86
16.8k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
16.8k
    if (Vector.size() < N) {
89
16.8k
      Vector.push_back(V);
90
16.8k
      return std::make_pair(None, true);
91
16.8k
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::insert(llvm::AssertingVH<llvm::Value> const&)
Line
Count
Source
81
122
  std::pair<NoneType, bool> insert(const T &V) {
82
122
    if (!isSmall())
83
45
      return std::make_pair(None, Set.insert(V).second);
84
77
85
77
    VIterator I = vfind(V);
86
77
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
77
    if (Vector.size() < N) {
89
61
      Vector.push_back(V);
90
61
      return std::make_pair(None, true);
91
61
    }
92
16
93
16
    // Otherwise, grow from vector to set.
94
48
    
while (16
!Vector.empty()) {
95
32
      Set.insert(Vector.back());
96
32
      Vector.pop_back();
97
32
    }
98
16
    Set.insert(V);
99
16
    return std::make_pair(None, true);
100
16
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::insert(llvm::SlotIndex const&)
Line
Count
Source
81
246
  std::pair<NoneType, bool> insert(const T &V) {
82
246
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
246
85
246
    VIterator I = vfind(V);
86
246
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
246
    if (Vector.size() < N) {
89
246
      Vector.push_back(V);
90
246
      return std::make_pair(None, true);
91
246
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
81
5.59k
  std::pair<NoneType, bool> insert(const T &V) {
82
5.59k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
5.59k
85
5.59k
    VIterator I = vfind(V);
86
5.59k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
5.59k
    if (Vector.size() < N) {
89
5.59k
      Vector.push_back(V);
90
5.59k
      return std::make_pair(None, true);
91
5.59k
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
81
17.2k
  std::pair<NoneType, bool> insert(const T &V) {
82
17.2k
    if (!isSmall())
83
503
      return std::make_pair(None, Set.insert(V).second);
84
16.7k
85
16.7k
    VIterator I = vfind(V);
86
16.7k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
16.7k
    if (Vector.size() < N) {
89
16.7k
      Vector.push_back(V);
90
16.7k
      return std::make_pair(None, true);
91
16.7k
    }
92
23
93
23
    // Otherwise, grow from vector to set.
94
759
    
while (23
!Vector.empty()) {
95
736
      Set.insert(Vector.back());
96
736
      Vector.pop_back();
97
736
    }
98
23
    Set.insert(V);
99
23
    return std::make_pair(None, true);
100
23
  }
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
81
418k
  std::pair<NoneType, bool> insert(const T &V) {
82
418k
    if (!isSmall())
83
81.5k
      return std::make_pair(None, Set.insert(V).second);
84
336k
85
336k
    VIterator I = vfind(V);
86
336k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
85.9k
      return std::make_pair(None, false);
88
250k
    if (Vector.size() < N) {
89
246k
      Vector.push_back(V);
90
246k
      return std::make_pair(None, true);
91
246k
    }
92
3.99k
93
3.99k
    // Otherwise, grow from vector to set.
94
35.9k
    
while (3.99k
!Vector.empty()) {
95
31.9k
      Set.insert(Vector.back());
96
31.9k
      Vector.pop_back();
97
31.9k
    }
98
3.99k
    Set.insert(V);
99
3.99k
    return std::make_pair(None, true);
100
3.99k
  }
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
81
648
  std::pair<NoneType, bool> insert(const T &V) {
82
648
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
648
85
648
    VIterator I = vfind(V);
86
648
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
648
    if (Vector.size() < N) {
89
648
      Vector.push_back(V);
90
648
      return std::make_pair(None, true);
91
648
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::insert(long long const&)
Line
Count
Source
81
226k
  std::pair<NoneType, bool> insert(const T &V) {
82
226k
    if (!isSmall())
83
448
      return std::make_pair(None, Set.insert(V).second);
84
226k
85
226k
    VIterator I = vfind(V);
86
226k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
31.7k
      return std::make_pair(None, false);
88
194k
    if (Vector.size() < N) {
89
194k
      Vector.push_back(V);
90
194k
      return std::make_pair(None, true);
91
194k
    }
92
74
93
74
    // Otherwise, grow from vector to set.
94
666
    
while (74
!Vector.empty()) {
95
592
      Set.insert(Vector.back());
96
592
      Vector.pop_back();
97
592
    }
98
74
    Set.insert(V);
99
74
    return std::make_pair(None, true);
100
74
  }
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
81
4.73M
  std::pair<NoneType, bool> insert(const T &V) {
82
4.73M
    if (!isSmall())
83
3.14M
      return std::make_pair(None, Set.insert(V).second);
84
1.58M
85
1.58M
    VIterator I = vfind(V);
86
1.58M
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
951k
      return std::make_pair(None, false);
88
632k
    if (Vector.size() < N) {
89
628k
      Vector.push_back(V);
90
628k
      return std::make_pair(None, true);
91
628k
    }
92
4.32k
93
4.32k
    // Otherwise, grow from vector to set.
94
142k
    
while (4.32k
!Vector.empty()) {
95
138k
      Set.insert(Vector.back());
96
138k
      Vector.pop_back();
97
138k
    }
98
4.32k
    Set.insert(V);
99
4.32k
    return std::make_pair(None, true);
100
4.32k
  }
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
81
839k
  std::pair<NoneType, bool> insert(const T &V) {
82
839k
    if (!isSmall())
83
335
      return std::make_pair(None, Set.insert(V).second);
84
839k
85
839k
    VIterator I = vfind(V);
86
839k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
650
      return std::make_pair(None, false);
88
838k
    if (Vector.size() < N) {
89
838k
      Vector.push_back(V);
90
838k
      return std::make_pair(None, true);
91
838k
    }
92
99
93
99
    // Otherwise, grow from vector to set.
94
3.26k
    
while (99
!Vector.empty()) {
95
3.16k
      Set.insert(Vector.back());
96
3.16k
      Vector.pop_back();
97
3.16k
    }
98
99
    Set.insert(V);
99
99
    return std::make_pair(None, true);
100
99
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
81
169
  std::pair<NoneType, bool> insert(const T &V) {
82
169
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
169
85
169
    VIterator I = vfind(V);
86
169
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
34
      return std::make_pair(None, false);
88
135
    if (Vector.size() < N) {
89
135
      Vector.push_back(V);
90
135
      return std::make_pair(None, true);
91
135
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::insert(clang::FileID const&)
Line
Count
Source
81
1.07k
  std::pair<NoneType, bool> insert(const T &V) {
82
1.07k
    if (!isSmall())
83
97
      return std::make_pair(None, Set.insert(V).second);
84
973
85
973
    VIterator I = vfind(V);
86
973
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
687
      return std::make_pair(None, false);
88
286
    if (Vector.size() < N) {
89
280
      Vector.push_back(V);
90
280
      return std::make_pair(None, true);
91
280
    }
92
6
93
6
    // Otherwise, grow from vector to set.
94
54
    
while (6
!Vector.empty()) {
95
48
      Set.insert(Vector.back());
96
48
      Vector.pop_back();
97
48
    }
98
6
    Set.insert(V);
99
6
    return std::make_pair(None, true);
100
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
81
138
  std::pair<NoneType, bool> insert(const T &V) {
82
138
    if (!isSmall())
83
21
      return std::make_pair(None, Set.insert(V).second);
84
117
85
117
    VIterator I = vfind(V);
86
117
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
117
    if (Vector.size() < N) {
89
113
      Vector.push_back(V);
90
113
      return std::make_pair(None, true);
91
113
    }
92
4
93
4
    // Otherwise, grow from vector to set.
94
36
    
while (4
!Vector.empty()) {
95
32
      Set.insert(Vector.back());
96
32
      Vector.pop_back();
97
32
    }
98
4
    Set.insert(V);
99
4
    return std::make_pair(None, true);
100
4
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::insert(clang::CudaArch const&)
Line
Count
Source
81
7
  std::pair<NoneType, bool> insert(const T &V) {
82
7
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
7
85
7
    VIterator I = vfind(V);
86
7
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
7
    if (Vector.size() < N) {
89
7
      Vector.push_back(V);
90
7
      return std::make_pair(None, true);
91
7
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
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
81
115
  std::pair<NoneType, bool> insert(const T &V) {
82
115
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
115
85
115
    VIterator I = vfind(V);
86
115
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
4
      return std::make_pair(None, false);
88
111
    if (Vector.size() < N) {
89
111
      Vector.push_back(V);
90
111
      return std::make_pair(None, true);
91
111
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
81
11.8k
  std::pair<NoneType, bool> insert(const T &V) {
82
11.8k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
11.8k
85
11.8k
    VIterator I = vfind(V);
86
11.8k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
5.88k
      return std::make_pair(None, false);
88
5.94k
    if (Vector.size() < N) {
89
5.94k
      Vector.push_back(V);
90
5.94k
      return std::make_pair(None, true);
91
5.94k
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
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
81
14
  std::pair<NoneType, bool> insert(const T &V) {
82
14
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
14
85
14
    VIterator I = vfind(V);
86
14
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
14
    if (Vector.size() < N) {
89
14
      Vector.push_back(V);
90
14
      return std::make_pair(None, true);
91
14
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
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
81
198
  std::pair<NoneType, bool> insert(const T &V) {
82
198
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
198
85
198
    VIterator I = vfind(V);
86
198
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
3
      return std::make_pair(None, false);
88
195
    if (Vector.size() < N) {
89
195
      Vector.push_back(V);
90
195
      return std::make_pair(None, true);
91
195
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::insert(clang::Selector const&)
Line
Count
Source
81
90
  std::pair<NoneType, bool> insert(const T &V) {
82
90
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
90
85
90
    VIterator I = vfind(V);
86
90
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
90
    if (Vector.size() < N) {
89
90
      Vector.push_back(V);
90
90
      return std::make_pair(None, true);
91
90
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
81
85
  std::pair<NoneType, bool> insert(const T &V) {
82
85
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
85
85
85
    VIterator I = vfind(V);
86
85
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
1
      return std::make_pair(None, false);
88
84
    if (Vector.size() < N) {
89
84
      Vector.push_back(V);
90
84
      return std::make_pair(None, true);
91
84
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::insert(clang::DeclarationName const&)
Line
Count
Source
81
3.61k
  std::pair<NoneType, bool> insert(const T &V) {
82
3.61k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
3.61k
85
3.61k
    VIterator I = vfind(V);
86
3.61k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
3.61k
    if (Vector.size() < N) {
89
3.61k
      Vector.push_back(V);
90
3.61k
      return std::make_pair(None, true);
91
3.61k
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::insert(clang::CanonicalDeclPtr<clang::FunctionDecl> const&)
Line
Count
Source
81
1.49k
  std::pair<NoneType, bool> insert(const T &V) {
82
1.49k
    if (!isSmall())
83
2
      return std::make_pair(None, Set.insert(V).second);
84
1.49k
85
1.49k
    VIterator I = vfind(V);
86
1.49k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
1.49k
    if (Vector.size() < N) {
89
1.48k
      Vector.push_back(V);
90
1.48k
      return std::make_pair(None, true);
91
1.48k
    }
92
3
93
3
    // Otherwise, grow from vector to set.
94
15
    
while (3
!Vector.empty()) {
95
12
      Set.insert(Vector.back());
96
12
      Vector.pop_back();
97
12
    }
98
3
    Set.insert(V);
99
3
    return std::make_pair(None, true);
100
3
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
81
1.35k
  std::pair<NoneType, bool> insert(const T &V) {
82
1.35k
    if (!isSmall())
83
169
      return std::make_pair(None, Set.insert(V).second);
84
1.18k
85
1.18k
    VIterator I = vfind(V);
86
1.18k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
1.18k
    if (Vector.size() < N) {
89
1.11k
      Vector.push_back(V);
90
1.11k
      return std::make_pair(None, true);
91
1.11k
    }
92
72
93
72
    // Otherwise, grow from vector to set.
94
216
    
while (72
!Vector.empty()) {
95
144
      Set.insert(Vector.back());
96
144
      Vector.pop_back();
97
144
    }
98
72
    Set.insert(V);
99
72
    return std::make_pair(None, true);
100
72
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::insert(llvm::DWARFDie const&)
Line
Count
Source
81
15.5k
  std::pair<NoneType, bool> insert(const T &V) {
82
15.5k
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
15.5k
85
15.5k
    VIterator I = vfind(V);
86
15.5k
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
0
      return std::make_pair(None, false);
88
15.5k
    if (Vector.size() < N) {
89
15.5k
      Vector.push_back(V);
90
15.5k
      return std::make_pair(None, true);
91
15.5k
    }
92
1
93
1
    // Otherwise, grow from vector to set.
94
4
    
while (1
!Vector.empty()) {
95
3
      Set.insert(Vector.back());
96
3
      Vector.pop_back();
97
3
    }
98
1
    Set.insert(V);
99
1
    return std::make_pair(None, true);
100
1
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
81
44
  std::pair<NoneType, bool> insert(const T &V) {
82
44
    if (!isSmall())
83
0
      return std::make_pair(None, Set.insert(V).second);
84
44
85
44
    VIterator I = vfind(V);
86
44
    if (I != Vector.end())    // Don't reinsert if it already exists.
87
2
      return std::make_pair(None, false);
88
42
    if (Vector.size() < N) {
89
42
      Vector.push_back(V);
90
42
      return std::make_pair(None, true);
91
42
    }
92
0
93
0
    // Otherwise, grow from vector to set.
94
0
    while (!Vector.empty()) {
95
0
      Set.insert(Vector.back());
96
0
      Vector.pop_back();
97
0
    }
98
0
    Set.insert(V);
99
0
    return std::make_pair(None, true);
100
0
  }
101
102
  template <typename IterT>
103
82.1k
  void insert(IterT I, IterT E) {
104
682k
    for (; I != E; 
++I600k
)
105
600k
      insert(*I);
106
82.1k
  }
107
108
889k
  bool erase(const T &V) {
109
889k
    if (!isSmall())
110
461k
      return Set.erase(V);
111
795k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 427k
I != E;
++I367k
)
112
411k
      if (*I == V) {
113
43.6k
        Vector.erase(I);
114
43.6k
        return true;
115
43.6k
      }
116
427k
    
return false384k
;
117
427k
  }
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
108
855k
  bool erase(const T &V) {
109
855k
    if (!isSmall())
110
461k
      return Set.erase(V);
111
756k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 393k
I != E;
++I362k
)
112
394k
      if (*I == V) {
113
31.1k
        Vector.erase(I);
114
31.1k
        return true;
115
31.1k
      }
116
393k
    
return false362k
;
117
393k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
108
3.35k
  bool erase(const T &V) {
109
3.35k
    if (!isSmall())
110
0
      return Set.erase(V);
111
4.25k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 3.35k
I != E;
++I901
)
112
1.12k
      if (*I == V) {
113
228
        Vector.erase(I);
114
228
        return true;
115
228
      }
116
3.35k
    
return false3.12k
;
117
3.35k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
108
10.8k
  bool erase(const T &V) {
109
10.8k
    if (!isSmall())
110
265
      return Set.erase(V);
111
12.9k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 10.5k
I != E;
++I2.34k
)
112
10.2k
      if (*I == V) {
113
7.88k
        Vector.erase(I);
114
7.88k
        return true;
115
7.88k
      }
116
10.5k
    
return false2.68k
;
117
10.5k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
108
11.8k
  bool erase(const T &V) {
109
11.8k
    if (!isSmall())
110
0
      return Set.erase(V);
111
13.7k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 11.8k
I != E;
++I1.87k
)
112
2.56k
      if (*I == V) {
113
692
        Vector.erase(I);
114
692
        return true;
115
692
      }
116
11.8k
    
return false11.1k
;
117
11.8k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::erase(clang::DeclarationName const&)
Line
Count
Source
108
8.25k
  bool erase(const T &V) {
109
8.25k
    if (!isSmall())
110
0
      return Set.erase(V);
111
8.26k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 8.25k
I != E;
++I12
)
112
3.62k
      if (*I == V) {
113
3.61k
        Vector.erase(I);
114
3.61k
        return true;
115
3.61k
      }
116
8.25k
    
return false4.63k
;
117
8.25k
  }
118
119
7.96M
  void clear() {
120
7.96M
    Vector.clear();
121
7.96M
    Set.clear();
122
7.96M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
119
24.4k
  void clear() {
120
24.4k
    Vector.clear();
121
24.4k
    Set.clear();
122
24.4k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
119
24.2k
  void clear() {
120
24.2k
    Vector.clear();
121
24.2k
    Set.clear();
122
24.2k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
119
5.60M
  void clear() {
120
5.60M
    Vector.clear();
121
5.60M
    Set.clear();
122
5.60M
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::clear()
Line
Count
Source
119
59
  void clear() {
120
59
    Vector.clear();
121
59
    Set.clear();
122
59
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
119
1.06M
  void clear() {
120
1.06M
    Vector.clear();
121
1.06M
    Set.clear();
122
1.06M
  }
llvm::SmallSet<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*> > >::clear()
Line
Count
Source
119
1.03M
  void clear() {
120
1.03M
    Vector.clear();
121
1.03M
    Set.clear();
122
1.03M
  }
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
119
221
  void clear() {
120
221
    Vector.clear();
121
221
    Set.clear();
122
221
  }
llvm::SmallSet<std::__1::pair<unsigned long, long long>, 32u, std::__1::less<std::__1::pair<unsigned long, long long> > >::clear()
Line
Count
Source
119
100k
  void clear() {
120
100k
    Vector.clear();
121
100k
    Set.clear();
122
100k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::clear()
Line
Count
Source
119
100k
  void clear() {
120
100k
    Vector.clear();
121
100k
    Set.clear();
122
100k
  }
123
124
private:
125
148M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 4u, std::__1::less<int> >::isSmall() const
Line
Count
Source
125
3.05k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
125
794k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
48.7M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
1.39M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
32.9M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
6.01M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
125
4.59k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
51.3M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
85
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
125
15.2k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
125
281k
  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
125
65
  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
125
5.87k
  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
125
16.8k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::isSmall() const
Line
Count
Source
125
1.06k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 16u, std::__1::less<int> >::isSmall() const
Line
Count
Source
125
228k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 32u, std::__1::less<int> >::isSmall() const
Line
Count
Source
125
221k
  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
125
418k
  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
125
5.06k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
125
226k
  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
125
4.73M
  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
125
839k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
125
169
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::isSmall() const
Line
Count
Source
125
1.07k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<clang::SourceLocation, clang::SourceLocation>, 8u, std::__1::less<std::__1::pair<clang::SourceLocation, clang::SourceLocation> > >::isSmall() const
Line
Count
Source
125
1.19k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::isSmall() const
Line
Count
Source
125
62
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::isSmall() const
Line
Count
Source
125
115
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
125
14.0k
  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
125
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
125
198
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::isSmall() const
Line
Count
Source
125
123
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
125
85
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::isSmall() const
Line
Count
Source
125
11.8k
  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
125
1.68k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
125
3.28k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::isSmall() const
Line
Count
Source
125
31.2k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
125
84
  bool isSmall() const { return Set.empty(); }
126
127
128M
  VIterator vfind(const T &V) const {
128
343M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I214M
)
129
248M
      if (*I == V)
130
33.5M
        return I;
131
128M
    
return Vector.end()94.5M
;
132
128M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
127
2.65k
  VIterator vfind(const T &V) const {
128
3.67k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.02k
)
129
1.56k
      if (*I == V)
130
546
        return I;
131
2.65k
    
return Vector.end()2.11k
;
132
2.65k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
127
464k
  VIterator vfind(const T &V) const {
128
699k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I235k
)
129
241k
      if (*I == V)
130
5.82k
        return I;
131
464k
    
return Vector.end()458k
;
132
464k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
47.7M
  VIterator vfind(const T &V) const {
128
120M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I73.1M
)
129
89.9M
      if (*I == V)
130
16.7M
        return I;
131
47.7M
    
return Vector.end()30.9M
;
132
47.7M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
1.37M
  VIterator vfind(const T &V) const {
128
4.28M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.91M
)
129
3.15M
      if (*I == V)
130
243k
        return I;
131
1.37M
    
return Vector.end()1.13M
;
132
1.37M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
25.3M
  VIterator vfind(const T &V) const {
128
47.7M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I22.3M
)
129
24.7M
      if (*I == V)
130
2.34M
        return I;
131
25.3M
    
return Vector.end()23.0M
;
132
25.3M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
2.54M
  VIterator vfind(const T &V) const {
128
4.15M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.60M
)
129
2.16M
      if (*I == V)
130
556k
        return I;
131
2.54M
    
return Vector.end()1.99M
;
132
2.54M
  }
llvm::SmallSet<unsigned long long, 4u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
127
4.59k
  VIterator vfind(const T &V) const {
128
5.06k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I475
)
129
490
      if (*I == V)
130
15
        return I;
131
4.59k
    
return Vector.end()4.57k
;
132
4.59k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
46.8M
  VIterator vfind(const T &V) const {
128
149M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I102M
)
129
115M
      if (*I == V)
130
12.4M
        return I;
131
46.8M
    
return Vector.end()34.4M
;
132
46.8M
  }
llvm::SmallSet<unsigned int, 1u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
79
  VIterator vfind(const T &V) const {
128
84
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I5
)
129
11
      if (*I == V)
130
6
        return I;
131
79
    
return Vector.end()73
;
132
79
  }
llvm::SmallSet<unsigned short, 8u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
127
12.5k
  VIterator vfind(const T &V) const {
128
44.0k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I31.4k
)
129
36.3k
      if (*I == V)
130
4.88k
        return I;
131
12.5k
    
return Vector.end()7.70k
;
132
12.5k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
127
223k
  VIterator vfind(const T &V) const {
128
560k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I337k
)
129
467k
      if (*I == V)
130
129k
        return I;
131
223k
    
return Vector.end()93.4k
;
132
223k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::vfind(llvm::AssertingVH<llvm::MemoryPhi> const&) const
Line
Count
Source
127
65
  VIterator vfind(const T &V) const {
128
77
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I12
)
129
15
      if (*I == V)
130
3
        return I;
131
65
    
return Vector.end()62
;
132
65
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::vfind(llvm::AssertingVH<llvm::Value> const&) const
Line
Count
Source
127
5.04k
  VIterator vfind(const T &V) const {
128
7.21k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.17k
)
129
2.21k
      if (*I == V)
130
44
        return I;
131
5.04k
    
return Vector.end()5.00k
;
132
5.04k
  }
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
127
16.8k
  VIterator vfind(const T &V) const {
128
16.9k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I31
)
129
31
      if (*I == V)
130
0
        return I;
131
16.8k
    return Vector.end();
132
16.8k
  }
llvm::SmallSet<llvm::SlotIndex, 2u, std::__1::less<llvm::SlotIndex> >::vfind(llvm::SlotIndex const&) const
Line
Count
Source
127
1.06k
  VIterator vfind(const T &V) const {
128
1.26k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I200
)
129
446
      if (*I == V)
130
246
        return I;
131
1.06k
    
return Vector.end()814
;
132
1.06k
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
127
228k
  VIterator vfind(const T &V) const {
128
253k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I25.1k
)
129
30.7k
      if (*I == V)
130
5.59k
        return I;
131
228k
    
return Vector.end()223k
;
132
228k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
127
216k
  VIterator vfind(const T &V) const {
128
603k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I387k
)
129
421k
      if (*I == V)
130
34.4k
        return I;
131
216k
    
return Vector.end()181k
;
132
216k
  }
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
127
336k
  VIterator vfind(const T &V) const {
128
859k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I522k
)
129
608k
      if (*I == V)
130
85.9k
        return I;
131
336k
    
return Vector.end()250k
;
132
336k
  }
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
127
5.06k
  VIterator vfind(const T &V) const {
128
25.1k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I20.0k
)
129
23.1k
      if (*I == V)
130
3.10k
        return I;
131
5.06k
    
return Vector.end()1.96k
;
132
5.06k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
127
226k
  VIterator vfind(const T &V) const {
128
509k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I283k
)
129
314k
      if (*I == V)
130
31.7k
        return I;
131
226k
    
return Vector.end()194k
;
132
226k
  }
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
127
1.58M
  VIterator vfind(const T &V) const {
128
11.5M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I10.0M
)
129
10.9M
      if (*I == V)
130
951k
        return I;
131
1.58M
    
return Vector.end()632k
;
132
1.58M
  }
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
127
839k
  VIterator vfind(const T &V) const {
128
1.18M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I350k
)
129
351k
      if (*I == V)
130
650
        return I;
131
839k
    
return Vector.end()838k
;
132
839k
  }
llvm::SmallSet<clang::SourceLocation, 8u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
127
169
  VIterator vfind(const T &V) const {
128
197
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I28
)
129
62
      if (*I == V)
130
34
        return I;
131
169
    
return Vector.end()135
;
132
169
  }
llvm::SmallSet<clang::FileID, 8u, std::__1::less<clang::FileID> >::vfind(clang::FileID const&) const
Line
Count
Source
127
973
  VIterator vfind(const T &V) const {
128
1.79k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I819
)
129
1.50k
      if (*I == V)
130
687
        return I;
131
973
    
return Vector.end()286
;
132
973
  }
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
127
986
  VIterator vfind(const T &V) const {
128
2.44k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.46k
)
129
1.46k
      if (*I == V)
130
8
        return I;
131
986
    
return Vector.end()978
;
132
986
  }
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::vfind(clang::CudaArch const&) const
Line
Count
Source
127
62
  VIterator vfind(const T &V) const {
128
65
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3
)
129
8
      if (*I == V)
130
5
        return I;
131
62
    
return Vector.end()57
;
132
62
  }
llvm::SmallSet<std::__1::pair<llvm::SCEV const*, llvm::Type*>, 16u, std::__1::less<std::__1::pair<llvm::SCEV const*, llvm::Type*> > >::vfind(std::__1::pair<llvm::SCEV const*, llvm::Type*> const&) const
Line
Count
Source
127
115
  VIterator vfind(const T &V) const {
128
262
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I147
)
129
151
      if (*I == V)
130
4
        return I;
131
115
    
return Vector.end()111
;
132
115
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
127
11.8k
  VIterator vfind(const T &V) const {
128
18.4k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I6.66k
)
129
12.5k
      if (*I == V)
130
5.88k
        return I;
131
11.8k
    
return Vector.end()5.94k
;
132
11.8k
  }
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
127
114
  VIterator vfind(const T &V) const {
128
583
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I469
)
129
508
      if (*I == V)
130
39
        return I;
131
114
    
return Vector.end()75
;
132
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
127
198
  VIterator vfind(const T &V) const {
128
201
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3
)
129
6
      if (*I == V)
130
3
        return I;
131
198
    
return Vector.end()195
;
132
198
  }
llvm::SmallSet<clang::Selector, 16u, std::__1::less<clang::Selector> >::vfind(clang::Selector const&) const
Line
Count
Source
127
123
  VIterator vfind(const T &V) const {
128
656
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I533
)
129
563
      if (*I == V)
130
30
        return I;
131
123
    
return Vector.end()93
;
132
123
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
127
85
  VIterator vfind(const T &V) const {
128
99
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I14
)
129
15
      if (*I == V)
130
1
        return I;
131
85
    
return Vector.end()84
;
132
85
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::vfind(clang::DeclarationName const&) const
Line
Count
Source
127
3.61k
  VIterator vfind(const T &V) const {
128
3.64k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I31
)
129
31
      if (*I == V)
130
0
        return I;
131
3.61k
    return Vector.end();
132
3.61k
  }
llvm::SmallSet<clang::CanonicalDeclPtr<clang::FunctionDecl>, 4u, std::__1::less<clang::CanonicalDeclPtr<clang::FunctionDecl> > >::vfind(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const
Line
Count
Source
127
1.68k
  VIterator vfind(const T &V) const {
128
2.08k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I404
)
129
404
      if (*I == V)
130
0
        return I;
131
1.68k
    return Vector.end();
132
1.68k
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
127
2.19k
  VIterator vfind(const T &V) const {
128
3.16k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I971
)
129
1.47k
      if (*I == V)
130
501
        return I;
131
2.19k
    
return Vector.end()1.69k
;
132
2.19k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::vfind(llvm::DWARFDie const&) const
Line
Count
Source
127
31.2k
  VIterator vfind(const T &V) const {
128
31.8k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I654
)
129
656
      if (*I == V)
130
2
        return I;
131
31.2k
    
return Vector.end()31.1k
;
132
31.2k
  }
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
127
84
  VIterator vfind(const T &V) const {
128
107
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I23
)
129
62
      if (*I == V)
130
39
        return I;
131
84
    
return Vector.end()45
;
132
84
  }
133
};
134
135
/// If this set is of pointer values, transparently switch over to using
136
/// SmallPtrSet for performance.
137
template <typename PointeeType, unsigned N>
138
class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
139
140
} // end namespace llvm
141
142
#endif // LLVM_ADT_SMALLSET_H