Coverage Report

Created: 2019-07-24 05:18

/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
16.4k
  SmallSetIterator(SetIterTy SetIter) : SetIter(SetIter), isSmall(false) {}
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::SmallSetIterator(std::__1::__tree_const_iterator<llvm::DIExpression::FragmentInfo, std::__1::__tree_node<llvm::DIExpression::FragmentInfo, void*>*, long>)
Line
Count
Source
51
7.99k
  SmallSetIterator(SetIterTy SetIter) : SetIter(SetIter), isSmall(false) {}
Unexecuted instantiation: llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSetIterator(std::__1::__tree_const_iterator<llvm::AssertingVH<llvm::Function>, std::__1::__tree_node<llvm::AssertingVH<llvm::Function>, void*>*, long>)
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::SmallSetIterator(std::__1::__tree_const_iterator<unsigned long, std::__1::__tree_node<unsigned long, void*>*, long>)
Line
Count
Source
51
8.45k
  SmallSetIterator(SetIterTy SetIter) : SetIter(SetIter), isSmall(false) {}
52
53
1.18M
  SmallSetIterator(VecIterTy VecIter) : VecIter(VecIter), isSmall(true) {}
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::SmallSetIterator(llvm::DIExpression::FragmentInfo const*)
Line
Count
Source
53
138
  SmallSetIterator(VecIterTy VecIter) : VecIter(VecIter), isSmall(true) {}
llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSetIterator(llvm::AssertingVH<llvm::Function> const*)
Line
Count
Source
53
1.18M
  SmallSetIterator(VecIterTy VecIter) : VecIter(VecIter), isSmall(true) {}
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::SmallSetIterator(unsigned long const*)
Line
Count
Source
53
5.55k
  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.20M
  ~SmallSetIterator() {
58
1.20M
    if (isSmall)
59
1.18M
      VecIter.~VecIterTy();
60
16.4k
    else
61
16.4k
      SetIter.~SetIterTy();
62
1.20M
  }
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::~SmallSetIterator()
Line
Count
Source
57
8.12k
  ~SmallSetIterator() {
58
8.12k
    if (isSmall)
59
138
      VecIter.~VecIterTy();
60
7.99k
    else
61
7.99k
      SetIter.~SetIterTy();
62
8.12k
  }
llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::~SmallSetIterator()
Line
Count
Source
57
1.18M
  ~SmallSetIterator() {
58
1.18M
    if (isSmall)
59
1.18M
      VecIter.~VecIterTy();
60
3
    else
61
3
      SetIter.~SetIterTy();
62
1.18M
  }
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::~SmallSetIterator()
Line
Count
Source
57
14.0k
  ~SmallSetIterator() {
58
14.0k
    if (isSmall)
59
5.55k
      VecIter.~VecIterTy();
60
8.45k
    else
61
8.45k
      SetIter.~SetIterTy();
62
14.0k
  }
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
16.6M
  bool operator==(const SmallSetIterator &RHS) const {
111
16.6M
    if (isSmall != RHS.isSmall)
112
0
      return false;
113
16.6M
    if (isSmall)
114
635k
      return VecIter == RHS.VecIter;
115
16.0M
    return SetIter == RHS.SetIter;
116
16.0M
  }
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::operator==(llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> > const&) const
Line
Count
Source
110
8.00M
  bool operator==(const SmallSetIterator &RHS) const {
111
8.00M
    if (isSmall != RHS.isSmall)
112
0
      return false;
113
8.00M
    if (isSmall)
114
171
      return VecIter == RHS.VecIter;
115
8.00M
    return SetIter == RHS.SetIter;
116
8.00M
  }
llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::operator==(llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > > const&) const
Line
Count
Source
110
631k
  bool operator==(const SmallSetIterator &RHS) const {
111
631k
    if (isSmall != RHS.isSmall)
112
0
      return false;
113
631k
    if (isSmall)
114
631k
      return VecIter == RHS.VecIter;
115
0
    return SetIter == RHS.SetIter;
116
0
  }
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::operator==(llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> > const&) const
Line
Count
Source
110
8.00M
  bool operator==(const SmallSetIterator &RHS) const {
111
8.00M
    if (isSmall != RHS.isSmall)
112
0
      return false;
113
8.00M
    if (isSmall)
114
4.03k
      return VecIter == RHS.VecIter;
115
8.00M
    return SetIter == RHS.SetIter;
116
8.00M
  }
117
118
16.0M
  SmallSetIterator &operator++() { // Preincrement
119
16.0M
    if (isSmall)
120
41.6k
      VecIter++;
121
15.9M
    else
122
15.9M
      SetIter++;
123
16.0M
    return *this;
124
16.0M
  }
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::operator++()
Line
Count
Source
118
7.99M
  SmallSetIterator &operator++() { // Preincrement
119
7.99M
    if (isSmall)
120
102
      VecIter++;
121
7.99M
    else
122
7.99M
      SetIter++;
123
7.99M
    return *this;
124
7.99M
  }
llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::operator++()
Line
Count
Source
118
40.3k
  SmallSetIterator &operator++() { // Preincrement
119
40.3k
    if (isSmall)
120
40.3k
      VecIter++;
121
0
    else
122
0
      SetIter++;
123
40.3k
    return *this;
124
40.3k
  }
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::operator++()
Line
Count
Source
118
7.99M
  SmallSetIterator &operator++() { // Preincrement
119
7.99M
    if (isSmall)
120
1.25k
      VecIter++;
121
7.99M
    else
122
7.99M
      SetIter++;
123
7.99M
    return *this;
124
7.99M
  }
125
126
16.0M
  const T &operator*() const { return isSmall ? 
*VecIter41.6k
:
*SetIter15.9M
; }
llvm::SmallSetIterator<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::operator*() const
Line
Count
Source
126
7.99M
  const T &operator*() const { return isSmall ? 
*VecIter102
:
*SetIter7.99M
; }
llvm::SmallSetIterator<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::operator*() const
Line
Count
Source
126
40.3k
  const T &operator*() const { return isSmall ? *VecIter : 
*SetIter0
; }
llvm::SmallSetIterator<unsigned long, 1u, std::__1::less<unsigned long> >::operator*() const
Line
Count
Source
126
7.99M
  const T &operator*() const { return isSmall ? 
*VecIter1.25k
:
*SetIter7.99M
; }
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
103M
  SmallSet() = default;
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::SmallSet()
Line
Count
Source
153
34
  SmallSet() = default;
llvm::SmallSet<int, 4u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
33.2k
  SmallSet() = default;
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
153
347k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
39.9M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
11.8M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
15.2M
  SmallSet() = default;
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
912k
  SmallSet() = default;
llvm::SmallSet<llvm::FeatureBitset, 4u, std::__1::less<llvm::FeatureBitset> >::SmallSet()
Line
Count
Source
153
6.00k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
30.0M
  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
5.73k
  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.35k
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
153
36.0k
  SmallSet() = default;
llvm::SmallSet<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> > >::SmallSet()
Line
Count
Source
153
713k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Value>, 2u, std::__1::less<llvm::AssertingVH<llvm::Value> > >::SmallSet()
Line
Count
Source
153
34.6k
  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.7k
  SmallSet() = default;
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::SmallSet()
Line
Count
Source
153
474
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::SmallSet()
Line
Count
Source
153
1.15M
  SmallSet() = default;
llvm::SmallSet<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::SmallSet()
Line
Count
Source
153
791
  SmallSet() = default;
llvm::SmallSet<int, 16u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
527k
  SmallSet() = default;
llvm::SmallSet<int, 32u, std::__1::less<int> >::SmallSet()
Line
Count
Source
153
152k
  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
34.5k
  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
151k
  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
106
  SmallSet() = default;
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::SmallSet()
Line
Count
Source
153
208k
  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
103k
  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
743k
  SmallSet() = default;
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::SmallSet()
Line
Count
Source
153
591k
  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
179
  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
179
  SmallSet() = default;
llvm::SmallSet<clang::CudaArch, 4u, std::__1::less<clang::CudaArch> >::SmallSet()
Line
Count
Source
153
30.4k
  SmallSet() = default;
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::SmallSet()
Line
Count
Source
153
22.1k
  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
305
  SmallSet() = default;
llvm::SmallSet<unsigned long, 1u, std::__1::less<unsigned long> >::SmallSet()
Line
Count
Source
153
1.49k
  SmallSet() = default;
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::SmallSet()
Line
Count
Source
153
16.4k
  SmallSet() = default;
llvm::SmallSet<unsigned int, 5u, std::__1::less<unsigned int> >::SmallSet()
Line
Count
Source
153
48
  SmallSet() = default;
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::SmallSet()
Line
Count
Source
153
67.5k
  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.8k
  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.88k
  SmallSet() = default;
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::SmallSet()
Line
Count
Source
153
1.01k
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
153
15
  SmallSet() = default;
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::SmallSet()
Line
Count
Source
153
27
  SmallSet() = default;
llvm::SmallSet<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 8u, std::__1::less<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >::SmallSet()
Line
Count
Source
153
623
  SmallSet() = default;
154
155
26.4M
  LLVM_NODISCARD bool empty() const {
156
26.4M
    return Vector.empty() && 
Set.empty()25.0M
;
157
26.4M
  }
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::empty() const
Line
Count
Source
155
34
  LLVM_NODISCARD bool empty() const {
156
34
    return Vector.empty() && 
Set.empty()14
;
157
34
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
257
  LLVM_NODISCARD bool empty() const {
156
257
    return Vector.empty() && 
Set.empty()0
;
157
257
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
901k
  LLVM_NODISCARD bool empty() const {
156
901k
    return Vector.empty() && 
Set.empty()87.0k
;
157
901k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
781k
  LLVM_NODISCARD bool empty() const {
156
781k
    return Vector.empty() && 
Set.empty()494k
;
157
781k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::empty() const
Line
Count
Source
155
23.7M
  LLVM_NODISCARD bool empty() const {
156
23.7M
    return Vector.empty() && 
Set.empty()23.3M
;
157
23.7M
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::empty() const
Line
Count
Source
155
130
  LLVM_NODISCARD bool empty() const {
156
130
    return Vector.empty() && 
Set.empty()104
;
157
130
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::empty() const
Line
Count
Source
155
17.2k
  LLVM_NODISCARD bool empty() const {
156
17.2k
    return Vector.empty() && 
Set.empty()14.9k
;
157
17.2k
  }
llvm::SmallSet<unsigned long, 1u, std::__1::less<unsigned long> >::empty() const
Line
Count
Source
155
871
  LLVM_NODISCARD bool empty() const {
156
871
    return Vector.empty() && 
Set.empty()186
;
157
871
  }
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
1.03M
  LLVM_NODISCARD bool empty() const {
156
1.03M
    return Vector.empty() && 
Set.empty()1.03M
;
157
1.03M
  }
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
  }
158
159
371k
  size_type size() const {
160
371k
    return isSmall() ? 
Vector.size()366k
:
Set.size()4.67k
;
161
371k
  }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::size() const
Line
Count
Source
159
320k
  size_type size() const {
160
320k
    return isSmall() ? 
Vector.size()320k
:
Set.size()24
;
161
320k
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::size() const
Line
Count
Source
159
14.2k
  size_type size() const {
160
14.2k
    return isSmall() ? 
Vector.size()13.7k
:
Set.size()483
;
161
14.2k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
159
33.7k
  size_type size() const {
160
33.7k
    return isSmall() ? 
Vector.size()29.6k
:
Set.size()4.16k
;
161
33.7k
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::size() const
Line
Count
Source
159
2.86k
  size_type size() const {
160
2.86k
    return isSmall() ? Vector.size() : 
Set.size()0
;
161
2.86k
  }
162
163
  /// count - Return 1 if the element is in the set, 0 otherwise.
164
60.2M
  size_type count(const T &V) const {
165
60.2M
    if (isSmall()) {
166
56.0M
      // Since the collection is small, just do a linear search.
167
56.0M
      return vfind(V) == Vector.end() ? 
044.1M
:
111.9M
;
168
56.0M
    } else {
169
4.20M
      return Set.count(V);
170
4.20M
    }
171
60.2M
  }
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::count(llvm::Register const&) const
Line
Count
Source
164
48
  size_type count(const T &V) const {
165
48
    if (isSmall()) {
166
48
      // Since the collection is small, just do a linear search.
167
48
      return vfind(V) == Vector.end() ? 
026
:
122
;
168
48
    } else {
169
0
      return Set.count(V);
170
0
    }
171
48
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
2.39k
  size_type count(const T &V) const {
165
2.39k
    if (isSmall()) {
166
2.12k
      // Since the collection is small, just do a linear search.
167
2.12k
      return vfind(V) == Vector.end() ? 
01.69k
:
1433
;
168
2.12k
    } else {
169
272
      return Set.count(V);
170
272
    }
171
2.39k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
2.95M
  size_type count(const T &V) const {
165
2.95M
    if (isSmall()) {
166
2.95M
      // Since the collection is small, just do a linear search.
167
2.95M
      return vfind(V) == Vector.end() ? 
02.48M
:
1462k
;
168
2.95M
    } else {
169
1.81k
      return Set.count(V);
170
1.81k
    }
171
2.95M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
15.5M
  size_type count(const T &V) const {
165
15.5M
    if (isSmall()) {
166
15.5M
      // Since the collection is small, just do a linear search.
167
15.5M
      return vfind(V) == Vector.end() ? 
015.4M
:
1149k
;
168
15.5M
    } else {
169
7.06k
      return Set.count(V);
170
7.06k
    }
171
15.5M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
16.3M
  size_type count(const T &V) const {
165
16.3M
    if (isSmall()) {
166
14.7M
      // Since the collection is small, just do a linear search.
167
14.7M
      return vfind(V) == Vector.end() ? 
013.4M
:
11.23M
;
168
14.7M
    } else {
169
1.63M
      return Set.count(V);
170
1.63M
    }
171
16.3M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
3.23M
  size_type count(const T &V) const {
165
3.23M
    if (isSmall()) {
166
1.03M
      // Since the collection is small, just do a linear search.
167
1.03M
      return vfind(V) == Vector.end() ? 
0591k
:
1440k
;
168
2.20M
    } else {
169
2.20M
      return Set.count(V);
170
2.20M
    }
171
3.23M
  }
llvm::SmallSet<llvm::FeatureBitset, 4u, std::__1::less<llvm::FeatureBitset> >::count(llvm::FeatureBitset const&) const
Line
Count
Source
164
3.06k
  size_type count(const T &V) const {
165
3.06k
    if (isSmall()) {
166
3.06k
      // Since the collection is small, just do a linear search.
167
3.06k
      return vfind(V) == Vector.end() ? 
03.05k
:
115
;
168
3.06k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
3.06k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::count(unsigned int const&) const
Line
Count
Source
164
18.6M
  size_type count(const T &V) const {
165
18.6M
    if (isSmall()) {
166
18.6M
      // Since the collection is small, just do a linear search.
167
18.6M
      return vfind(V) == Vector.end() ? 
09.13M
:
19.48M
;
168
18.6M
    } else {
169
231
      return Set.count(V);
170
231
    }
171
18.6M
  }
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.42k
  size_type count(const T &V) const {
165
3.42k
    if (isSmall()) {
166
3.17k
      // Since the collection is small, just do a linear search.
167
3.17k
      return vfind(V) == Vector.end() ? 
02.25k
:
1920
;
168
3.17k
    } else {
169
249
      return Set.count(V);
170
249
    }
171
3.42k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> > >::count(std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> const&) const
Line
Count
Source
164
2.67M
  size_type count(const T &V) const {
165
2.67M
    if (isSmall()) {
166
2.46M
      // Since the collection is small, just do a linear search.
167
2.46M
      return vfind(V) == Vector.end() ? 
02.45M
:
113.0k
;
168
2.46M
    } else {
169
210k
      return Set.count(V);
170
210k
    }
171
2.67M
  }
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
1.25k
  size_type count(const T &V) const {
165
1.25k
    if (isSmall()) {
166
1.25k
      // Since the collection is small, just do a linear search.
167
1.25k
      return vfind(V) == Vector.end() ? 
01.25k
:
15
;
168
1.25k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
1.25k
  }
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
19.9k
  size_type count(const T &V) const {
165
19.9k
    if (isSmall()) {
166
6.04k
      // Since the collection is small, just do a linear search.
167
6.04k
      return vfind(V) == Vector.end() ? 
05.96k
:
184
;
168
13.8k
    } else {
169
13.8k
      return Set.count(V);
170
13.8k
    }
171
19.9k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::count(unsigned short const&) const
Line
Count
Source
164
229
  size_type count(const T &V) const {
165
229
    if (isSmall()) {
166
229
      // Since the collection is small, just do a linear search.
167
229
      return vfind(V) == Vector.end() ? 
0211
:
118
;
168
229
    } else {
169
0
      return Set.count(V);
170
0
    }
171
229
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
246k
  size_type count(const T &V) const {
165
246k
    if (isSmall()) {
166
246k
      // Since the collection is small, just do a linear search.
167
246k
      return vfind(V) == Vector.end() ? 
0240k
:
16.17k
;
168
246k
    } else {
169
47
      return Set.count(V);
170
47
    }
171
246k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::count(int const&) const
Line
Count
Source
164
212k
  size_type count(const T &V) const {
165
212k
    if (isSmall()) {
166
207k
      // Since the collection is small, just do a linear search.
167
207k
      return vfind(V) == Vector.end() ? 
0167k
:
139.9k
;
168
207k
    } else {
169
5.12k
      return Set.count(V);
170
5.12k
    }
171
212k
  }
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
329k
  size_type count(const T &V) const {
165
329k
    if (isSmall()) {
166
202k
      // Since the collection is small, just do a linear search.
167
202k
      return vfind(V) == Vector.end() ? 
086.3k
:
1115k
;
168
202k
    } else {
169
127k
      return Set.count(V);
170
127k
    }
171
329k
  }
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
5.08k
  size_type count(const T &V) const {
165
5.08k
    if (isSmall()) {
166
5.08k
      // Since the collection is small, just do a linear search.
167
5.08k
      return vfind(V) == Vector.end() ? 
01.60k
:
13.48k
;
168
5.08k
    } else {
169
0
      return Set.count(V);
170
0
    }
171
5.08k
  }
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
888
      // Since the collection is small, just do a linear search.
167
888
      return vfind(V) == Vector.end() ? 
0880
:
18
;
168
888
    } 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<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
  }
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
363
  size_type count(const T &V) const {
165
363
    if (isSmall()) {
166
360
      // Since the collection is small, just do a linear search.
167
360
      return vfind(V) == Vector.end() ? 0 : 
10
;
168
360
    } else {
169
3
      return Set.count(V);
170
3
    }
171
363
  }
llvm::SmallSet<clang::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::count(clang::SourceLocation const&) const
Line
Count
Source
164
844
  size_type count(const T &V) const {
165
844
    if (isSmall()) {
166
606
      // Since the collection is small, just do a linear search.
167
606
      return vfind(V) == Vector.end() ? 
0324
:
1282
;
168
606
    } else {
169
238
      return Set.count(V);
170
238
    }
171
844
  }
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
110M
  std::pair<NoneType, bool> insert(const T &V) {
181
110M
    if (!isSmall())
182
11.8M
      return std::make_pair(None, Set.insert(V).second);
183
98.2M
184
98.2M
    VIterator I = vfind(V);
185
98.2M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
22.3M
      return std::make_pair(None, false);
187
75.9M
    if (Vector.size() < N) {
188
75.0M
      Vector.push_back(V);
189
75.0M
      return std::make_pair(None, true);
190
75.0M
    }
191
949k
192
949k
    // Otherwise, grow from vector to set.
193
5.71M
    
while (949k
!Vector.empty()) {
194
4.76M
      Set.insert(Vector.back());
195
4.76M
      Vector.pop_back();
196
4.76M
    }
197
949k
    Set.insert(V);
198
949k
    return std::make_pair(None, true);
199
949k
  }
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::insert(llvm::Register const&)
Line
Count
Source
180
22
  std::pair<NoneType, bool> insert(const T &V) {
181
22
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
22
184
22
    VIterator I = vfind(V);
185
22
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
22
    if (Vector.size() < N) {
188
22
      Vector.push_back(V);
189
22
      return std::make_pair(None, true);
190
22
    }
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, 4u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
180
621
  std::pair<NoneType, bool> insert(const T &V) {
181
621
    if (!isSmall())
182
74
      return std::make_pair(None, Set.insert(V).second);
183
547
184
547
    VIterator I = vfind(V);
185
547
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
107
      return std::make_pair(None, false);
187
440
    if (Vector.size() < N) {
188
428
      Vector.push_back(V);
189
428
      return std::make_pair(None, true);
190
428
    }
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
539k
  std::pair<NoneType, bool> insert(const T &V) {
181
539k
    if (!isSmall())
182
23.0k
      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.44k
192
3.44k
    // Otherwise, grow from vector to set.
193
17.2k
    
while (3.44k
!Vector.empty()) {
194
13.7k
      Set.insert(Vector.back());
195
13.7k
      Vector.pop_back();
196
13.7k
    }
197
3.44k
    Set.insert(V);
198
3.44k
    return std::make_pair(None, true);
199
3.44k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
44.6M
  std::pair<NoneType, bool> insert(const T &V) {
181
44.6M
    if (!isSmall())
182
29.1k
      return std::make_pair(None, Set.insert(V).second);
183
44.6M
184
44.6M
    VIterator I = vfind(V);
185
44.6M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
16.2M
      return std::make_pair(None, false);
187
28.4M
    if (Vector.size() < N) {
188
28.4M
      Vector.push_back(V);
189
28.4M
      return std::make_pair(None, true);
190
28.4M
    }
191
3.03k
192
3.03k
    // Otherwise, grow from vector to set.
193
27.3k
    
while (3.03k
!Vector.empty()) {
194
24.2k
      Set.insert(Vector.back());
195
24.2k
      Vector.pop_back();
196
24.2k
    }
197
3.03k
    Set.insert(V);
198
3.03k
    return std::make_pair(None, true);
199
3.03k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
432k
  std::pair<NoneType, bool> insert(const T &V) {
181
432k
    if (!isSmall())
182
2.27k
      return std::make_pair(None, Set.insert(V).second);
183
430k
184
430k
    VIterator I = vfind(V);
185
430k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
120k
      return std::make_pair(None, false);
187
309k
    if (Vector.size() < N) {
188
309k
      Vector.push_back(V);
189
309k
      return std::make_pair(None, true);
190
309k
    }
191
62
192
62
    // Otherwise, grow from vector to set.
193
1.05k
    
while (62
!Vector.empty()) {
194
992
      Set.insert(Vector.back());
195
992
      Vector.pop_back();
196
992
    }
197
62
    Set.insert(V);
198
62
    return std::make_pair(None, true);
199
62
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
13.0M
  std::pair<NoneType, bool> insert(const T &V) {
181
13.0M
    if (!isSmall())
182
2.21M
      return std::make_pair(None, Set.insert(V).second);
183
10.8M
184
10.8M
    VIterator I = vfind(V);
185
10.8M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1.34M
      return std::make_pair(None, false);
187
9.51M
    if (Vector.size() < N) {
188
8.82M
      Vector.push_back(V);
189
8.82M
      return std::make_pair(None, true);
190
8.82M
    }
191
686k
192
686k
    // Otherwise, grow from vector to set.
193
3.43M
    
while (686k
!Vector.empty()) {
194
2.74M
      Set.insert(Vector.back());
195
2.74M
      Vector.pop_back();
196
2.74M
    }
197
686k
    Set.insert(V);
198
686k
    return std::make_pair(None, true);
199
686k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::insert(unsigned int const&)
Line
Count
Source
180
3.51M
  std::pair<NoneType, bool> insert(const T &V) {
181
3.51M
    if (!isSmall())
182
1.83M
      return std::make_pair(None, Set.insert(V).second);
183
1.67M
184
1.67M
    VIterator I = vfind(V);
185
1.67M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
138k
      return std::make_pair(None, false);
187
1.54M
    if (Vector.size() < N) {
188
1.38M
      Vector.push_back(V);
189
1.38M
      return std::make_pair(None, true);
190
1.38M
    }
191
157k
192
157k
    // Otherwise, grow from vector to set.
193
472k
    
while (157k
!Vector.empty()) {
194
315k
      Set.insert(Vector.back());
195
315k
      Vector.pop_back();
196
315k
    }
197
157k
    Set.insert(V);
198
157k
    return std::make_pair(None, true);
199
157k
  }
llvm::SmallSet<llvm::FeatureBitset, 4u, std::__1::less<llvm::FeatureBitset> >::insert(llvm::FeatureBitset const&)
Line
Count
Source
180
3.05k
  std::pair<NoneType, bool> insert(const T &V) {
181
3.05k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
3.05k
184
3.05k
    VIterator I = vfind(V);
185
3.05k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
3.05k
    if (Vector.size() < N) {
188
3.05k
      Vector.push_back(V);
189
3.05k
      return std::make_pair(None, true);
190
3.05k
    }
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
37.8M
  std::pair<NoneType, bool> insert(const T &V) {
181
37.8M
    if (!isSmall())
182
4.15M
      return std::make_pair(None, Set.insert(V).second);
183
33.7M
184
33.7M
    VIterator I = vfind(V);
185
33.7M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
3.15M
      return std::make_pair(None, false);
187
30.5M
    if (Vector.size() < N) {
188
30.5M
      Vector.push_back(V);
189
30.5M
      return std::make_pair(None, true);
190
30.5M
    }
191
36.5k
192
36.5k
    // Otherwise, grow from vector to set.
193
1.20M
    
while (36.5k
!Vector.empty()) {
194
1.17M
      Set.insert(Vector.back());
195
1.17M
      Vector.pop_back();
196
1.17M
    }
197
36.5k
    Set.insert(V);
198
36.5k
    return std::make_pair(None, true);
199
36.5k
  }
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
170
  std::pair<NoneType, bool> insert(const T &V) {
181
170
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
170
184
170
    VIterator I = vfind(V);
185
170
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
170
    if (Vector.size() < N) {
188
170
      Vector.push_back(V);
189
170
      return std::make_pair(None, true);
190
170
    }
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
14.2k
  std::pair<NoneType, bool> insert(const T &V) {
181
14.2k
    if (!isSmall())
182
2.61k
      return std::make_pair(None, Set.insert(V).second);
183
11.6k
184
11.6k
    VIterator I = vfind(V);
185
11.6k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
4.71k
      return std::make_pair(None, false);
187
6.88k
    if (Vector.size() < N) {
188
6.78k
      Vector.push_back(V);
189
6.78k
      return std::make_pair(None, true);
190
6.78k
    }
191
100
192
100
    // Otherwise, grow from vector to set.
193
916
    
while (100
!Vector.empty()) {
194
816
      Set.insert(Vector.back());
195
816
      Vector.pop_back();
196
816
    }
197
100
    Set.insert(V);
198
100
    return std::make_pair(None, true);
199
100
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
180
370k
  std::pair<NoneType, bool> insert(const T &V) {
181
370k
    if (!isSmall())
182
39.8k
      return std::make_pair(None, Set.insert(V).second);
183
330k
184
330k
    VIterator I = vfind(V);
185
330k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
206k
      return std::make_pair(None, false);
187
123k
    if (Vector.size() < N) {
188
119k
      Vector.push_back(V);
189
119k
      return std::make_pair(None, true);
190
119k
    }
191
4.14k
192
4.14k
    // Otherwise, grow from vector to set.
193
37.3k
    
while (4.14k
!Vector.empty()) {
194
33.1k
      Set.insert(Vector.back());
195
33.1k
      Vector.pop_back();
196
33.1k
    }
197
4.14k
    Set.insert(V);
198
4.14k
    return std::make_pair(None, true);
199
4.14k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> > >::insert(std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> const&)
Line
Count
Source
180
2.66M
  std::pair<NoneType, bool> insert(const T &V) {
181
2.66M
    if (!isSmall())
182
210k
      return std::make_pair(None, Set.insert(V).second);
183
2.45M
184
2.45M
    VIterator I = vfind(V);
185
2.45M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
2.45M
    if (Vector.size() < N) {
188
2.44M
      Vector.push_back(V);
189
2.44M
      return std::make_pair(None, true);
190
2.44M
    }
191
13.2k
192
13.2k
    // Otherwise, grow from vector to set.
193
119k
    
while (13.2k
!Vector.empty()) {
194
106k
      Set.insert(Vector.back());
195
106k
      Vector.pop_back();
196
106k
    }
197
13.2k
    Set.insert(V);
198
13.2k
    return std::make_pair(None, true);
199
13.2k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::insert(llvm::AssertingVH<llvm::MemoryPhi> const&)
Line
Count
Source
180
34
  std::pair<NoneType, bool> insert(const T &V) {
181
34
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
34
184
34
    VIterator I = vfind(V);
185
34
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
34
    if (Vector.size() < N) {
188
34
      Vector.push_back(V);
189
34
      return std::make_pair(None, true);
190
34
    }
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.7k
  std::pair<NoneType, bool> insert(const T &V) {
181
13.7k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
13.7k
184
13.7k
    VIterator I = vfind(V);
185
13.7k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
3
      return std::make_pair(None, false);
187
13.7k
    if (Vector.size() < N) {
188
13.7k
      Vector.push_back(V);
189
13.7k
      return std::make_pair(None, true);
190
13.7k
    }
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
1.70k
  std::pair<NoneType, bool> insert(const T &V) {
181
1.70k
    if (!isSmall())
182
1.29k
      return std::make_pair(None, Set.insert(V).second);
183
407
184
407
    VIterator I = vfind(V);
185
407
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
407
    if (Vector.size() < N) {
188
312
      Vector.push_back(V);
189
312
      return std::make_pair(None, true);
190
312
    }
191
95
192
95
    // Otherwise, grow from vector to set.
193
285
    
while (95
!Vector.empty()) {
194
190
      Set.insert(Vector.back());
195
190
      Vector.pop_back();
196
190
    }
197
95
    Set.insert(V);
198
95
    return std::make_pair(None, true);
199
95
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::insert(unsigned short const&)
Line
Count
Source
180
34
  std::pair<NoneType, bool> insert(const T &V) {
181
34
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
34
184
34
    VIterator I = vfind(V);
185
34
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
5
      return std::make_pair(None, false);
187
29
    if (Vector.size() < N) {
188
29
      Vector.push_back(V);
189
29
      return std::make_pair(None, true);
190
29
    }
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::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::insert(llvm::DIExpression::FragmentInfo const&)
Line
Count
Source
180
4.85k
  std::pair<NoneType, bool> insert(const T &V) {
181
4.85k
    if (!isSmall())
182
3.99k
      return std::make_pair(None, Set.insert(V).second);
183
860
184
860
    VIterator I = vfind(V);
185
860
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
860
    if (Vector.size() < N) {
188
858
      Vector.push_back(V);
189
858
      return std::make_pair(None, true);
190
858
    }
191
2
192
2
    // Otherwise, grow from vector to set.
193
10
    
while (2
!Vector.empty()) {
194
8
      Set.insert(Vector.back());
195
8
      Vector.pop_back();
196
8
    }
197
2
    Set.insert(V);
198
2
    return std::make_pair(None, true);
199
2
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::insert(int const&)
Line
Count
Source
180
6.21k
  std::pair<NoneType, bool> insert(const T &V) {
181
6.21k
    if (!isSmall())
182
6
      return std::make_pair(None, Set.insert(V).second);
183
6.20k
184
6.20k
    VIterator I = vfind(V);
185
6.20k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
6.20k
    if (Vector.size() < N) {
188
6.20k
      Vector.push_back(V);
189
6.20k
      return std::make_pair(None, true);
190
6.20k
    }
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
19.2k
  std::pair<NoneType, bool> insert(const T &V) {
181
19.2k
    if (!isSmall())
182
517
      return std::make_pair(None, Set.insert(V).second);
183
18.7k
184
18.7k
    VIterator I = vfind(V);
185
18.7k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
18.7k
    if (Vector.size() < N) {
188
18.7k
      Vector.push_back(V);
189
18.7k
      return std::make_pair(None, true);
190
18.7k
    }
191
20
192
20
    // Otherwise, grow from vector to set.
193
660
    
while (20
!Vector.empty()) {
194
640
      Set.insert(Vector.back());
195
640
      Vector.pop_back();
196
640
    }
197
20
    Set.insert(V);
198
20
    return std::make_pair(None, true);
199
20
  }
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
356k
  std::pair<NoneType, bool> insert(const T &V) {
181
356k
    if (!isSmall())
182
72.3k
      return std::make_pair(None, Set.insert(V).second);
183
284k
184
284k
    VIterator I = vfind(V);
185
284k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
91.8k
      return std::make_pair(None, false);
187
192k
    if (Vector.size() < N) {
188
188k
      Vector.push_back(V);
189
188k
      return std::make_pair(None, true);
190
188k
    }
191
3.27k
192
3.27k
    // Otherwise, grow from vector to set.
193
29.5k
    
while (3.27k
!Vector.empty()) {
194
26.2k
      Set.insert(Vector.back());
195
26.2k
      Vector.pop_back();
196
26.2k
    }
197
3.27k
    Set.insert(V);
198
3.27k
    return std::make_pair(None, true);
199
3.27k
  }
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
573k
  std::pair<NoneType, bool> insert(const T &V) {
181
573k
    if (!isSmall())
182
90.5k
      return std::make_pair(None, Set.insert(V).second);
183
482k
184
482k
    VIterator I = vfind(V);
185
482k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
482k
    if (Vector.size() < N) {
188
446k
      Vector.push_back(V);
189
446k
      return std::make_pair(None, true);
190
446k
    }
191
36.3k
192
36.3k
    // Otherwise, grow from vector to set.
193
218k
    
while (36.3k
!Vector.empty()) {
194
181k
      Set.insert(Vector.back());
195
181k
      Vector.pop_back();
196
181k
    }
197
36.3k
    Set.insert(V);
198
36.3k
    return std::make_pair(None, true);
199
36.3k
  }
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
724
  std::pair<NoneType, bool> insert(const T &V) {
181
724
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
724
184
724
    VIterator I = vfind(V);
185
724
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
724
    if (Vector.size() < N) {
188
724
      Vector.push_back(V);
189
724
      return std::make_pair(None, true);
190
724
    }
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
254k
  std::pair<NoneType, bool> insert(const T &V) {
181
254k
    if (!isSmall())
182
701
      return std::make_pair(None, Set.insert(V).second);
183
253k
184
253k
    VIterator I = vfind(V);
185
253k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
35.7k
      return std::make_pair(None, false);
187
217k
    if (Vector.size() < N) {
188
217k
      Vector.push_back(V);
189
217k
      return std::make_pair(None, true);
190
217k
    }
191
79
192
79
    // Otherwise, grow from vector to set.
193
711
    
while (79
!Vector.empty()) {
194
632
      Set.insert(Vector.back());
195
632
      Vector.pop_back();
196
632
    }
197
79
    Set.insert(V);
198
79
    return std::make_pair(None, true);
199
79
  }
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.82M
  std::pair<NoneType, bool> insert(const T &V) {
181
4.82M
    if (!isSmall())
182
3.20M
      return std::make_pair(None, Set.insert(V).second);
183
1.62M
184
1.62M
    VIterator I = vfind(V);
185
1.62M
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
980k
      return std::make_pair(None, false);
187
644k
    if (Vector.size() < N) {
188
640k
      Vector.push_back(V);
189
640k
      return std::make_pair(None, true);
190
640k
    }
191
4.50k
192
4.50k
    // Otherwise, grow from vector to set.
193
148k
    
while (4.50k
!Vector.empty()) {
194
144k
      Set.insert(Vector.back());
195
144k
      Vector.pop_back();
196
144k
    }
197
4.50k
    Set.insert(V);
198
4.50k
    return std::make_pair(None, true);
199
4.50k
  }
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
859k
  std::pair<NoneType, bool> insert(const T &V) {
181
859k
    if (!isSmall())
182
336
      return std::make_pair(None, Set.insert(V).second);
183
859k
184
859k
    VIterator I = vfind(V);
185
859k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
687
      return std::make_pair(None, false);
187
858k
    if (Vector.size() < N) {
188
858k
      Vector.push_back(V);
189
858k
      return std::make_pair(None, true);
190
858k
    }
191
97
192
97
    // Otherwise, grow from vector to set.
193
3.20k
    
while (97
!Vector.empty()) {
194
3.10k
      Set.insert(Vector.back());
195
3.10k
      Vector.pop_back();
196
3.10k
    }
197
97
    Set.insert(V);
198
97
    return std::make_pair(None, true);
199
97
  }
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.3k
  std::pair<NoneType, bool> insert(const T &V) {
181
40.3k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
40.3k
184
40.3k
    VIterator I = vfind(V);
185
40.3k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
40.3k
    if (Vector.size() < N) {
188
40.3k
      Vector.push_back(V);
189
40.3k
      return std::make_pair(None, true);
190
40.3k
    }
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
992
184
992
    VIterator I = vfind(V);
185
992
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
693
      return std::make_pair(None, false);
187
299
    if (Vector.size() < N) {
188
293
      Vector.push_back(V);
189
293
      return std::make_pair(None, true);
190
293
    }
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::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::insert(clang::SourceLocation const&)
Line
Count
Source
180
1.45k
  std::pair<NoneType, bool> insert(const T &V) {
181
1.45k
    if (!isSmall())
182
165
      return std::make_pair(None, Set.insert(V).second);
183
1.29k
184
1.29k
    VIterator I = vfind(V);
185
1.29k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
1.29k
    if (Vector.size() < N) {
188
1.21k
      Vector.push_back(V);
189
1.21k
      return std::make_pair(None, true);
190
1.21k
    }
191
77
192
77
    // Otherwise, grow from vector to set.
193
231
    
while (77
!Vector.empty()) {
194
154
      Set.insert(Vector.back());
195
154
      Vector.pop_back();
196
154
    }
197
77
    Set.insert(V);
198
77
    return std::make_pair(None, true);
199
77
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::insert(clang::DeclarationName const&)
Line
Count
Source
180
3.70k
  std::pair<NoneType, bool> insert(const T &V) {
181
3.70k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
3.70k
184
3.70k
    VIterator I = vfind(V);
185
3.70k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
3.70k
    if (Vector.size() < N) {
188
3.70k
      Vector.push_back(V);
189
3.70k
      return std::make_pair(None, true);
190
3.70k
    }
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<unsigned long, 1u, std::__1::less<unsigned long> >::insert(unsigned long const&)
Line
Count
Source
180
7.33k
  std::pair<NoneType, bool> insert(const T &V) {
181
7.33k
    if (!isSmall())
182
4.29k
      return std::make_pair(None, Set.insert(V).second);
183
3.04k
184
3.04k
    VIterator I = vfind(V);
185
3.04k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1.27k
      return std::make_pair(None, false);
187
1.77k
    if (Vector.size() < N) {
188
1.54k
      Vector.push_back(V);
189
1.54k
      return std::make_pair(None, true);
190
1.54k
    }
191
230
192
230
    // Otherwise, grow from vector to set.
193
460
    
while (230
!Vector.empty()) {
194
230
      Set.insert(Vector.back());
195
230
      Vector.pop_back();
196
230
    }
197
230
    Set.insert(V);
198
230
    return std::make_pair(None, true);
199
230
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::insert(llvm::DWARFDie const&)
Line
Count
Source
180
17.1k
  std::pair<NoneType, bool> insert(const T &V) {
181
17.1k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
17.1k
184
17.1k
    VIterator I = vfind(V);
185
17.1k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
2
      return std::make_pair(None, false);
187
17.1k
    if (Vector.size() < N) {
188
17.1k
      Vector.push_back(V);
189
17.1k
      return std::make_pair(None, true);
190
17.1k
    }
191
2
192
2
    // Otherwise, grow from vector to set.
193
8
    
while (2
!Vector.empty()) {
194
6
      Set.insert(Vector.back());
195
6
      Vector.pop_back();
196
6
    }
197
2
    Set.insert(V);
198
2
    return std::make_pair(None, true);
199
2
  }
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
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::insert(llvm::SDValue const&)
Line
Count
Source
180
15.9k
  std::pair<NoneType, bool> insert(const T &V) {
181
15.9k
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
15.9k
184
15.9k
    VIterator I = vfind(V);
185
15.9k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
7.21k
      return std::make_pair(None, false);
187
8.73k
    if (Vector.size() < N) {
188
8.73k
      Vector.push_back(V);
189
8.73k
      return std::make_pair(None, true);
190
8.73k
    }
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
282
  std::pair<NoneType, bool> insert(const T &V) {
181
282
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
282
184
282
    VIterator I = vfind(V);
185
282
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
66
      return std::make_pair(None, false);
187
216
    if (Vector.size() < N) {
188
216
      Vector.push_back(V);
189
216
      return std::make_pair(None, true);
190
216
    }
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<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
2.04k
  std::pair<NoneType, bool> insert(const T &V) {
181
2.04k
    if (!isSmall())
182
3
      return std::make_pair(None, Set.insert(V).second);
183
2.04k
184
2.04k
    VIterator I = vfind(V);
185
2.04k
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
2.04k
    if (Vector.size() < N) {
188
2.04k
      Vector.push_back(V);
189
2.04k
      return std::make_pair(None, true);
190
2.04k
    }
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<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::insert(llvm::StringRef const&)
Line
Count
Source
180
27
  std::pair<NoneType, bool> insert(const T &V) {
181
27
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
27
184
27
    VIterator I = vfind(V);
185
27
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
27
    if (Vector.size() < N) {
188
27
      Vector.push_back(V);
189
27
      return std::make_pair(None, true);
190
27
    }
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
28
  std::pair<NoneType, bool> insert(const T &V) {
181
28
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
28
184
28
    VIterator I = vfind(V);
185
28
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
1
      return std::make_pair(None, false);
187
27
    if (Vector.size() < N) {
188
27
      Vector.push_back(V);
189
27
      return std::make_pair(None, true);
190
27
    }
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::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 8u, std::__1::less<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >::insert(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
180
272
  std::pair<NoneType, bool> insert(const T &V) {
181
272
    if (!isSmall())
182
0
      return std::make_pair(None, Set.insert(V).second);
183
272
184
272
    VIterator I = vfind(V);
185
272
    if (I != Vector.end())    // Don't reinsert if it already exists.
186
0
      return std::make_pair(None, false);
187
272
    if (Vector.size() < N) {
188
272
      Vector.push_back(V);
189
272
      return std::make_pair(None, true);
190
272
    }
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
86.6k
  void insert(IterT I, IterT E) {
203
786k
    for (; I != E; 
++I700k
)
204
700k
      insert(*I);
205
86.6k
  }
void llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::insert<unsigned short*>(unsigned short*, unsigned short*)
Line
Count
Source
202
28
  void insert(IterT I, IterT E) {
203
42
    for (; I != E; 
++I14
)
204
14
      insert(*I);
205
28
  }
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
86.5k
  void insert(IterT I, IterT E) {
203
786k
    for (; I != E; 
++I699k
)
204
699k
      insert(*I);
205
86.5k
  }
206
207
675k
  bool erase(const T &V) {
208
675k
    if (!isSmall())
209
301k
      return Set.erase(V);
210
634k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 374k
I != E;
++I260k
)
211
374k
      if (*I == V) {
212
114k
        Vector.erase(I);
213
114k
        return true;
214
114k
      }
215
374k
    
return false259k
;
216
374k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::MemoryPhi>, 8u, std::__1::less<llvm::AssertingVH<llvm::MemoryPhi> > >::erase(llvm::AssertingVH<llvm::MemoryPhi> const&)
Line
Count
Source
207
2
  bool erase(const T &V) {
208
2
    if (!isSmall())
209
0
      return Set.erase(V);
210
2
    for (mutable_iterator I = Vector.begin(), E = Vector.end(); I != E; 
++I0
)
211
2
      if (*I == V) {
212
2
        Vector.erase(I);
213
2
        return true;
214
2
      }
215
2
    
return false0
;
216
2
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
635k
  bool erase(const T &V) {
208
635k
    if (!isSmall())
209
301k
      return Set.erase(V);
210
589k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 334k
I != E;
++I255k
)
211
356k
      if (*I == V) {
212
101k
        Vector.erase(I);
213
101k
        return true;
214
101k
      }
215
334k
    
return false233k
;
216
334k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
3.98k
  bool erase(const T &V) {
208
3.98k
    if (!isSmall())
209
0
      return Set.erase(V);
210
4.71k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 3.98k
I != E;
++I729
)
211
823
      if (*I == V) {
212
94
        Vector.erase(I);
213
94
        return true;
214
94
      }
215
3.98k
    
return false3.89k
;
216
3.98k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
12.2k
  bool erase(const T &V) {
208
12.2k
    if (!isSmall())
209
159
      return Set.erase(V);
210
14.7k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 12.1k
I != E;
++I2.62k
)
211
11.2k
      if (*I == V) {
212
8.61k
        Vector.erase(I);
213
8.61k
        return true;
214
8.61k
      }
215
12.1k
    
return false3.50k
;
216
12.1k
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::erase(unsigned int const&)
Line
Count
Source
207
14.7k
  bool erase(const T &V) {
208
14.7k
    if (!isSmall())
209
0
      return Set.erase(V);
210
16.4k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 14.7k
I != E;
++I1.67k
)
211
2.22k
      if (*I == V) {
212
555
        Vector.erase(I);
213
555
        return true;
214
555
      }
215
14.7k
    
return false14.1k
;
216
14.7k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::erase(clang::DeclarationName const&)
Line
Count
Source
207
8.63k
  bool erase(const T &V) {
208
8.63k
    if (!isSmall())
209
0
      return Set.erase(V);
210
8.65k
    
for (mutable_iterator I = Vector.begin(), E = Vector.end(); 8.63k
I != E;
++I24
)
211
3.73k
      if (*I == V) {
212
3.70k
        Vector.erase(I);
213
3.70k
        return true;
214
3.70k
      }
215
8.63k
    
return false4.92k
;
216
8.63k
  }
llvm::SmallSet<unsigned long, 1u, std::__1::less<unsigned long> >::erase(unsigned long const&)
Line
Count
Source
207
645
  bool erase(const T &V) {
208
645
    if (!isSmall())
209
302
      return Set.erase(V);
210
343
    for (mutable_iterator I = Vector.begin(), E = Vector.end(); I != E; 
++I0
)
211
343
      if (*I == V) {
212
343
        Vector.erase(I);
213
343
        return true;
214
343
      }
215
343
    
return false0
;
216
343
  }
217
218
8.79M
  void clear() {
219
8.79M
    Vector.clear();
220
8.79M
    Set.clear();
221
8.79M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
20.9k
  void clear() {
219
20.9k
    Vector.clear();
220
20.9k
    Set.clear();
221
20.9k
  }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
24.0k
  void clear() {
219
24.0k
    Vector.clear();
220
24.0k
    Set.clear();
221
24.0k
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::clear()
Line
Count
Source
218
5.68M
  void clear() {
219
5.68M
    Vector.clear();
220
5.68M
    Set.clear();
221
5.68M
  }
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.15M
  void clear() {
219
1.15M
    Vector.clear();
220
1.15M
    Set.clear();
221
1.15M
  }
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.11M
  void clear() {
219
1.11M
    Vector.clear();
220
1.11M
    Set.clear();
221
1.11M
  }
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
307
  void clear() {
219
307
    Vector.clear();
220
307
    Set.clear();
221
307
  }
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
103k
  void clear() {
219
103k
    Vector.clear();
220
103k
    Set.clear();
221
103k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::clear()
Line
Count
Source
218
103k
  void clear() {
219
103k
    Vector.clear();
220
103k
    Set.clear();
221
103k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::clear()
Line
Count
Source
218
591k
  void clear() {
219
591k
    Vector.clear();
220
591k
    Set.clear();
221
591k
  }
222
223
602k
  const_iterator begin() const {
224
602k
    if (isSmall())
225
594k
      return {Vector.begin()};
226
8.22k
    return {Set.begin()};
227
8.22k
  }
llvm::SmallSet<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::begin() const
Line
Count
Source
223
4.06k
  const_iterator begin() const {
224
4.06k
    if (isSmall())
225
69
      return {Vector.begin()};
226
3.99k
    return {Set.begin()};
227
3.99k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::begin() const
Line
Count
Source
223
591k
  const_iterator begin() const {
224
591k
    if (isSmall())
225
591k
      return {Vector.begin()};
226
18.4E
    return {Set.begin()};
227
18.4E
  }
llvm::SmallSet<unsigned long, 1u, std::__1::less<unsigned long> >::begin() const
Line
Count
Source
223
7.00k
  const_iterator begin() const {
224
7.00k
    if (isSmall())
225
2.77k
      return {Vector.begin()};
226
4.22k
    return {Set.begin()};
227
4.22k
  }
228
229
602k
  const_iterator end() const {
230
602k
    if (isSmall())
231
594k
      return {Vector.end()};
232
8.22k
    return {Set.end()};
233
8.22k
  }
llvm::SmallSet<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::end() const
Line
Count
Source
229
4.06k
  const_iterator end() const {
230
4.06k
    if (isSmall())
231
69
      return {Vector.end()};
232
3.99k
    return {Set.end()};
233
3.99k
  }
llvm::SmallSet<llvm::AssertingVH<llvm::Function>, 20u, std::__1::less<llvm::AssertingVH<llvm::Function> > >::end() const
Line
Count
Source
229
591k
  const_iterator end() const {
230
591k
    if (isSmall())
231
591k
      return {Vector.end()};
232
1
    return {Set.end()};
233
1
  }
llvm::SmallSet<unsigned long, 1u, std::__1::less<unsigned long> >::end() const
Line
Count
Source
229
7.00k
  const_iterator end() const {
230
7.00k
    if (isSmall())
231
2.77k
      return {Vector.end()};
232
4.22k
    return {Set.end()};
233
4.22k
  }
234
235
private:
236
172M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::isSmall() const
Line
Count
Source
236
70
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 4u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
3.03k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 4u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
236
860k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 8u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
47.6M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
16.0M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
30.0M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
6.76M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::FeatureBitset, 4u, std::__1::less<llvm::FeatureBitset> >::isSmall() const
Line
Count
Source
236
6.11k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::isSmall() const
Line
Count
Source
236
56.4M
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
303
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::isSmall() const
Line
Count
Source
236
170
  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
17.6k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
236
403k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> > >::isSmall() const
Line
Count
Source
236
5.34M
  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
1.29k
  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
21.6k
  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.7k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::isSmall() const
Line
Count
Source
236
263
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::isSmall() const
Line
Count
Source
236
12.9k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 16u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
252k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<int, 32u, std::__1::less<int> >::isSmall() const
Line
Count
Source
236
231k
  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
356k
  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
903k
  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.81k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::isSmall() const
Line
Count
Source
236
254k
  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.82M
  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
859k
  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.22M
  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.21k
  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::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::isSmall() const
Line
Count
Source
236
2.29k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::isSmall() const
Line
Count
Source
236
12.3k
  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<unsigned long, 1u, std::__1::less<unsigned long> >::isSmall() const
Line
Count
Source
236
21.9k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::isSmall() const
Line
Count
Source
236
17.1k
  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(); }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::isSmall() const
Line
Count
Source
236
18.8k
  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
282
  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<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.41k
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
27
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::isSmall() const
Line
Count
Source
236
28
  bool isSmall() const { return Set.empty(); }
llvm::SmallSet<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 8u, std::__1::less<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >::isSmall() const
Line
Count
Source
236
713
  bool isSmall() const { return Set.empty(); }
237
238
154M
  VIterator vfind(const T &V) const {
239
373M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I219M
)
240
253M
      if (*I == V)
241
34.2M
        return I;
242
154M
    
return Vector.end()120M
;
243
154M
  }
llvm::SmallSet<llvm::Register, 4u, std::__1::less<llvm::Register> >::vfind(llvm::Register const&) const
Line
Count
Source
238
70
  VIterator vfind(const T &V) const {
239
100
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I30
)
240
52
      if (*I == V)
241
22
        return I;
242
70
    
return Vector.end()48
;
243
70
  }
llvm::SmallSet<int, 4u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
2.67k
  VIterator vfind(const T &V) const {
239
3.78k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.11k
)
240
1.65k
      if (*I == V)
241
540
        return I;
242
2.67k
    
return Vector.end()2.13k
;
243
2.67k
  }
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
787k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I270k
)
240
276k
      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
47.6M
  VIterator vfind(const T &V) const {
239
120M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I72.9M
)
240
89.6M
      if (*I == V)
241
16.7M
        return I;
242
47.6M
    
return Vector.end()30.9M
;
243
47.6M
  }
llvm::SmallSet<unsigned int, 16u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
16.0M
  VIterator vfind(const T &V) const {
239
19.4M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I3.42M
)
240
3.69M
      if (*I == V)
241
269k
        return I;
242
16.0M
    
return Vector.end()15.7M
;
243
16.0M
  }
llvm::SmallSet<unsigned int, 4u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
25.5M
  VIterator vfind(const T &V) const {
239
45.4M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I19.8M
)
240
22.4M
      if (*I == V)
241
2.58M
        return I;
242
25.5M
    
return Vector.end()23.0M
;
243
25.5M
  }
llvm::SmallSet<unsigned int, 2u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
2.71M
  VIterator vfind(const T &V) const {
239
4.43M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.71M
)
240
2.29M
      if (*I == V)
241
578k
        return I;
242
2.71M
    
return Vector.end()2.13M
;
243
2.71M
  }
llvm::SmallSet<llvm::FeatureBitset, 4u, std::__1::less<llvm::FeatureBitset> >::vfind(llvm::FeatureBitset const&) const
Line
Count
Source
238
6.11k
  VIterator vfind(const T &V) const {
239
6.62k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I505
)
240
520
      if (*I == V)
241
15
        return I;
242
6.11k
    
return Vector.end()6.10k
;
243
6.11k
  }
llvm::SmallSet<unsigned int, 32u, std::__1::less<unsigned int> >::vfind(unsigned int const&) const
Line
Count
Source
238
52.3M
  VIterator vfind(const T &V) const {
239
152M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I100M
)
240
112M
      if (*I == V)
241
12.6M
        return I;
242
52.3M
    
return Vector.end()39.6M
;
243
52.3M
  }
llvm::SmallSet<llvm::StringRef, 4u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
303
  VIterator vfind(const T &V) const {
239
794
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I491
)
240
496
      if (*I == V)
241
5
        return I;
242
303
    
return Vector.end()298
;
243
303
  }
llvm::SmallSet<unsigned long long, 8u, std::__1::less<unsigned long long> >::vfind(unsigned long long const&) const
Line
Count
Source
238
170
  VIterator vfind(const T &V) const {
239
172
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2
)
240
2
      if (*I == V)
241
0
        return I;
242
170
    return Vector.end();
243
170
  }
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
14.7k
  VIterator vfind(const T &V) const {
239
51.5k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I36.7k
)
240
42.4k
      if (*I == V)
241
5.63k
        return I;
242
14.7k
    
return Vector.end()9.13k
;
243
14.7k
  }
llvm::SmallSet<llvm::SDValue, 8u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
238
330k
  VIterator vfind(const T &V) const {
239
768k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I438k
)
240
644k
      if (*I == V)
241
206k
        return I;
242
330k
    
return Vector.end()123k
;
243
330k
  }
llvm::SmallSet<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*>, 8u, std::__1::less<std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> > >::vfind(std::__1::pair<llvm::BasicBlock*, llvm::BasicBlock*> const&) const
Line
Count
Source
238
4.92M
  VIterator vfind(const T &V) const {
239
12.4M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I7.48M
)
240
7.49M
      if (*I == V)
241
13.0k
        return I;
242
4.92M
    
return Vector.end()4.90M
;
243
4.92M
  }
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
1.29k
  VIterator vfind(const T &V) const {
239
1.32k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I27
)
240
32
      if (*I == V)
241
5
        return I;
242
1.29k
    
return Vector.end()1.28k
;
243
1.29k
  }
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
6.45k
  VIterator vfind(const T &V) const {
239
9.10k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I2.65k
)
240
2.73k
      if (*I == V)
241
84
        return I;
242
6.45k
    
return Vector.end()6.37k
;
243
6.45k
  }
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.7k
  VIterator vfind(const T &V) const {
239
13.8k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I47
)
240
50
      if (*I == V)
241
3
        return I;
242
13.7k
    
return Vector.end()13.7k
;
243
13.7k
  }
llvm::SmallSet<unsigned short, 4u, std::__1::less<unsigned short> >::vfind(unsigned short const&) const
Line
Count
Source
238
263
  VIterator vfind(const T &V) const {
239
289
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I26
)
240
49
      if (*I == V)
241
23
        return I;
242
263
    
return Vector.end()240
;
243
263
  }
llvm::SmallSet<llvm::DIExpression::FragmentInfo, 4u, std::__1::less<llvm::DIExpression::FragmentInfo> >::vfind(llvm::DIExpression::FragmentInfo const&) const
Line
Count
Source
238
860
  VIterator vfind(const T &V) const {
239
962
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I102
)
240
102
      if (*I == V)
241
0
        return I;
242
860
    return Vector.end();
243
860
  }
llvm::SmallSet<int, 16u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
252k
  VIterator vfind(const T &V) const {
239
289k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I36.9k
)
240
43.1k
      if (*I == V)
241
6.17k
        return I;
242
252k
    
return Vector.end()246k
;
243
252k
  }
llvm::SmallSet<int, 32u, std::__1::less<int> >::vfind(int const&) const
Line
Count
Source
238
225k
  VIterator vfind(const T &V) const {
239
696k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I470k
)
240
510k
      if (*I == V)
241
39.9k
        return I;
242
225k
    
return Vector.end()185k
;
243
225k
  }
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
284k
  VIterator vfind(const T &V) const {
239
598k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I314k
)
240
406k
      if (*I == V)
241
91.8k
        return I;
242
284k
    
return Vector.end()192k
;
243
284k
  }
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
684k
  VIterator vfind(const T &V) const {
239
1.66M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I985k
)
240
1.10M
      if (*I == V)
241
115k
        return I;
242
684k
    
return Vector.end()569k
;
243
684k
  }
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.81k
  VIterator vfind(const T &V) const {
239
27.5k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I21.7k
)
240
25.2k
      if (*I == V)
241
3.48k
        return I;
242
5.81k
    
return Vector.end()2.33k
;
243
5.81k
  }
llvm::SmallSet<long long, 8u, std::__1::less<long long> >::vfind(long long const&) const
Line
Count
Source
238
253k
  VIterator vfind(const T &V) const {
239
604k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I350k
)
240
386k
      if (*I == V)
241
35.7k
        return I;
242
253k
    
return Vector.end()217k
;
243
253k
  }
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.62M
  VIterator vfind(const T &V) const {
239
12.2M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I10.6M
)
240
11.6M
      if (*I == V)
241
980k
        return I;
242
1.62M
    
return Vector.end()644k
;
243
1.62M
  }
llvm::SmallSet<std::__1::pair<llvm::Value*, llvm::Value*>, 32u, std::__1::less<std::__1::pair<llvm::Value*, llvm::Value*> > >::vfind(std::__1::pair<llvm::Value*, llvm::Value*> const&) const
Line
Count
Source
238
859k
  VIterator vfind(const T &V) const {
239
1.21M
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I358k
)
240
359k
      if (*I == V)
241
687
        return I;
242
859k
    
return Vector.end()858k
;
243
859k
  }
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.3k
  VIterator vfind(const T &V) const {
239
54.5k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I14.1k
)
240
14.1k
      if (*I == V)
241
0
        return I;
242
40.3k
    return Vector.end();
243
40.3k
  }
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
992
  VIterator vfind(const T &V) const {
239
1.81k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I820
)
240
1.51k
      if (*I == V)
241
693
        return I;
242
992
    
return Vector.end()299
;
243
992
  }
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
1.00k
  VIterator vfind(const T &V) const {
239
2.47k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I1.46k
)
240
1.47k
      if (*I == V)
241
8
        return I;
242
1.00k
    
return Vector.end()998
;
243
1.00k
  }
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::SourceLocation, 2u, std::__1::less<clang::SourceLocation> >::vfind(clang::SourceLocation const&) const
Line
Count
Source
238
1.89k
  VIterator vfind(const T &V) const {
239
2.68k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I793
)
240
1.07k
      if (*I == V)
241
282
        return I;
242
1.89k
    
return Vector.end()1.61k
;
243
1.89k
  }
llvm::SmallSet<clang::DeclarationName, 8u, std::__1::less<clang::DeclarationName> >::vfind(clang::DeclarationName const&) const
Line
Count
Source
238
3.70k
  VIterator vfind(const T &V) const {
239
3.74k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I33
)
240
33
      if (*I == V)
241
0
        return I;
242
3.70k
    return Vector.end();
243
3.70k
  }
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<unsigned long, 1u, std::__1::less<unsigned long> >::vfind(unsigned long const&) const
Line
Count
Source
238
3.04k
  VIterator vfind(const T &V) const {
239
3.27k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I230
)
240
1.50k
      if (*I == V)
241
1.27k
        return I;
242
3.04k
    
return Vector.end()1.77k
;
243
3.04k
  }
llvm::SmallSet<llvm::DWARFDie, 3u, std::__1::less<llvm::DWARFDie> >::vfind(llvm::DWARFDie const&) const
Line
Count
Source
238
17.1k
  VIterator vfind(const T &V) const {
239
17.7k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I694
)
240
696
      if (*I == V)
241
2
        return I;
242
17.1k
    
return Vector.end()17.1k
;
243
17.1k
  }
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
  }
llvm::SmallSet<llvm::SDValue, 16u, std::__1::less<llvm::SDValue> >::vfind(llvm::SDValue const&) const
Line
Count
Source
238
15.9k
  VIterator vfind(const T &V) const {
239
27.7k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I11.8k
)
240
19.0k
      if (*I == V)
241
7.21k
        return I;
242
15.9k
    
return Vector.end()8.73k
;
243
15.9k
  }
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
282
  VIterator vfind(const T &V) const {
239
299
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I17
)
240
83
      if (*I == V)
241
66
        return I;
242
282
    
return Vector.end()216
;
243
282
  }
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<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.40k
  VIterator vfind(const T &V) const {
239
3.03k
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I634
)
240
634
      if (*I == V)
241
0
        return I;
242
2.40k
    return Vector.end();
243
2.40k
  }
llvm::SmallSet<llvm::StringRef, 3u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
27
  VIterator vfind(const T &V) const {
239
40
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I13
)
240
13
      if (*I == V)
241
0
        return I;
242
27
    return Vector.end();
243
27
  }
llvm::SmallSet<llvm::StringRef, 8u, std::__1::less<llvm::StringRef> >::vfind(llvm::StringRef const&) const
Line
Count
Source
238
28
  VIterator vfind(const T &V) const {
239
28
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I0
)
240
1
      if (*I == V)
241
1
        return I;
242
28
    
return Vector.end()27
;
243
28
  }
llvm::SmallSet<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, 8u, std::__1::less<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >::vfind(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
238
479
  VIterator vfind(const T &V) const {
239
605
    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; 
++I126
)
240
148
      if (*I == V)
241
22
        return I;
242
479
    
return Vector.end()457
;
243
479
  }
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