/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 |