/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/ADT/Hashing.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- llvm/ADT/Hashing.h - Utilities for hashing --------------*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file implements the newly proposed standard C++ interfaces for hashing |
11 | | // arbitrary data and building hash functions for user-defined types. This |
12 | | // interface was originally proposed in N3333[1] and is currently under review |
13 | | // for inclusion in a future TR and/or standard. |
14 | | // |
15 | | // The primary interfaces provide are comprised of one type and three functions: |
16 | | // |
17 | | // -- 'hash_code' class is an opaque type representing the hash code for some |
18 | | // data. It is the intended product of hashing, and can be used to implement |
19 | | // hash tables, checksumming, and other common uses of hashes. It is not an |
20 | | // integer type (although it can be converted to one) because it is risky |
21 | | // to assume much about the internals of a hash_code. In particular, each |
22 | | // execution of the program has a high probability of producing a different |
23 | | // hash_code for a given input. Thus their values are not stable to save or |
24 | | // persist, and should only be used during the execution for the |
25 | | // construction of hashing datastructures. |
26 | | // |
27 | | // -- 'hash_value' is a function designed to be overloaded for each |
28 | | // user-defined type which wishes to be used within a hashing context. It |
29 | | // should be overloaded within the user-defined type's namespace and found |
30 | | // via ADL. Overloads for primitive types are provided by this library. |
31 | | // |
32 | | // -- 'hash_combine' and 'hash_combine_range' are functions designed to aid |
33 | | // programmers in easily and intuitively combining a set of data into |
34 | | // a single hash_code for their object. They should only logically be used |
35 | | // within the implementation of a 'hash_value' routine or similar context. |
36 | | // |
37 | | // Note that 'hash_combine_range' contains very special logic for hashing |
38 | | // a contiguous array of integers or pointers. This logic is *extremely* fast, |
39 | | // on a modern Intel "Gainestown" Xeon (Nehalem uarch) @2.2 GHz, these were |
40 | | // benchmarked at over 6.5 GiB/s for large keys, and <20 cycles/hash for keys |
41 | | // under 32-bytes. |
42 | | // |
43 | | //===----------------------------------------------------------------------===// |
44 | | |
45 | | #ifndef LLVM_ADT_HASHING_H |
46 | | #define LLVM_ADT_HASHING_H |
47 | | |
48 | | #include "llvm/Support/DataTypes.h" |
49 | | #include "llvm/Support/Host.h" |
50 | | #include "llvm/Support/SwapByteOrder.h" |
51 | | #include "llvm/Support/type_traits.h" |
52 | | #include <algorithm> |
53 | | #include <cassert> |
54 | | #include <cstring> |
55 | | #include <string> |
56 | | #include <utility> |
57 | | |
58 | | namespace llvm { |
59 | | |
60 | | /// \brief An opaque object representing a hash code. |
61 | | /// |
62 | | /// This object represents the result of hashing some entity. It is intended to |
63 | | /// be used to implement hashtables or other hashing-based data structures. |
64 | | /// While it wraps and exposes a numeric value, this value should not be |
65 | | /// trusted to be stable or predictable across processes or executions. |
66 | | /// |
67 | | /// In order to obtain the hash_code for an object 'x': |
68 | | /// \code |
69 | | /// using llvm::hash_value; |
70 | | /// llvm::hash_code code = hash_value(x); |
71 | | /// \endcode |
72 | | class hash_code { |
73 | | size_t value; |
74 | | |
75 | | public: |
76 | | /// \brief Default construct a hash_code. |
77 | | /// Note that this leaves the value uninitialized. |
78 | | hash_code() = default; |
79 | | |
80 | | /// \brief Form a hash code directly from a numerical value. |
81 | 1.39G | hash_code(size_t value) : value(value) {} |
82 | | |
83 | | /// \brief Convert the hash code to its numerical value for use. |
84 | 1.24G | /*explicit*/ operator size_t() const { return value; } |
85 | | |
86 | | friend bool operator==(const hash_code &lhs, const hash_code &rhs) { |
87 | | return lhs.value == rhs.value; |
88 | | } |
89 | 1.18k | friend bool operator!=(const hash_code &lhs, const hash_code &rhs) { |
90 | 1.18k | return lhs.value != rhs.value; |
91 | 1.18k | } |
92 | | |
93 | | /// \brief Allow a hash_code to be directly run through hash_value. |
94 | 153M | friend size_t hash_value(const hash_code &code) { return code.value; } |
95 | | }; |
96 | | |
97 | | /// \brief Compute a hash_code for any integer value. |
98 | | /// |
99 | | /// Note that this function is intended to compute the same hash_code for |
100 | | /// a particular value without regard to the pre-promotion type. This is in |
101 | | /// contrast to hash_combine which may produce different hash_codes for |
102 | | /// differing argument types even if they would implicit promote to a common |
103 | | /// type without changing the value. |
104 | | template <typename T> |
105 | | typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type |
106 | | hash_value(T value); |
107 | | |
108 | | /// \brief Compute a hash_code for a pointer's address. |
109 | | /// |
110 | | /// N.B.: This hashes the *address*. Not the value and not the type. |
111 | | template <typename T> hash_code hash_value(const T *ptr); |
112 | | |
113 | | /// \brief Compute a hash_code for a pair of objects. |
114 | | template <typename T, typename U> |
115 | | hash_code hash_value(const std::pair<T, U> &arg); |
116 | | |
117 | | /// \brief Compute a hash_code for a standard string. |
118 | | template <typename T> |
119 | | hash_code hash_value(const std::basic_string<T> &arg); |
120 | | |
121 | | |
122 | | /// \brief Override the execution seed with a fixed value. |
123 | | /// |
124 | | /// This hashing library uses a per-execution seed designed to change on each |
125 | | /// run with high probability in order to ensure that the hash codes are not |
126 | | /// attackable and to ensure that output which is intended to be stable does |
127 | | /// not rely on the particulars of the hash codes produced. |
128 | | /// |
129 | | /// That said, there are use cases where it is important to be able to |
130 | | /// reproduce *exactly* a specific behavior. To that end, we provide a function |
131 | | /// which will forcibly set the seed to a fixed value. This must be done at the |
132 | | /// start of the program, before any hashes are computed. Also, it cannot be |
133 | | /// undone. This makes it thread-hostile and very hard to use outside of |
134 | | /// immediately on start of a simple program designed for reproducible |
135 | | /// behavior. |
136 | | void set_fixed_execution_hash_seed(size_t fixed_value); |
137 | | |
138 | | |
139 | | // All of the implementation details of actually computing the various hash |
140 | | // code values are held within this namespace. These routines are included in |
141 | | // the header file mainly to allow inlining and constant propagation. |
142 | | namespace hashing { |
143 | | namespace detail { |
144 | | |
145 | 4.49G | inline uint64_t fetch64(const char *p) { |
146 | 4.49G | uint64_t result; |
147 | 4.49G | memcpy(&result, p, sizeof(result)); |
148 | 4.49G | if (sys::IsBigEndianHost) |
149 | 0 | sys::swapByteOrder(result); |
150 | 4.49G | return result; |
151 | 4.49G | } |
152 | | |
153 | 808M | inline uint32_t fetch32(const char *p) { |
154 | 808M | uint32_t result; |
155 | 808M | memcpy(&result, p, sizeof(result)); |
156 | 808M | if (sys::IsBigEndianHost) |
157 | 0 | sys::swapByteOrder(result); |
158 | 808M | return result; |
159 | 808M | } |
160 | | |
161 | | /// Some primes between 2^63 and 2^64 for various uses. |
162 | | static const uint64_t k0 = 0xc3a5c85c97cb3127ULL; |
163 | | static const uint64_t k1 = 0xb492b66fbe98f273ULL; |
164 | | static const uint64_t k2 = 0x9ae16a3b2f90404fULL; |
165 | | static const uint64_t k3 = 0xc949d7c7509e6557ULL; |
166 | | |
167 | | /// \brief Bitwise right rotate. |
168 | | /// Normally this will compile to a single instruction, especially if the |
169 | | /// shift is a manifest constant. |
170 | 3.10G | inline uint64_t rotate(uint64_t val, size_t shift) { |
171 | 3.10G | // Avoid shifting by 64: doing so yields an undefined result. |
172 | 3.10G | return shift == 0 ? val0 : ((val >> shift) | (val << (64 - shift)))3.10G ; |
173 | 3.10G | } |
174 | | |
175 | 298M | inline uint64_t shift_mix(uint64_t val) { |
176 | 298M | return val ^ (val >> 47); |
177 | 298M | } |
178 | | |
179 | 1.34G | inline uint64_t hash_16_bytes(uint64_t low, uint64_t high) { |
180 | 1.34G | // Murmur-inspired hashing. |
181 | 1.34G | const uint64_t kMul = 0x9ddfea08eb382d69ULL; |
182 | 1.34G | uint64_t a = (low ^ high) * kMul; |
183 | 1.34G | a ^= (a >> 47); |
184 | 1.34G | uint64_t b = (high ^ a) * kMul; |
185 | 1.34G | b ^= (b >> 47); |
186 | 1.34G | b *= kMul; |
187 | 1.34G | return b; |
188 | 1.34G | } |
189 | | |
190 | 136k | inline uint64_t hash_1to3_bytes(const char *s, size_t len, uint64_t seed) { |
191 | 136k | uint8_t a = s[0]; |
192 | 136k | uint8_t b = s[len >> 1]; |
193 | 136k | uint8_t c = s[len - 1]; |
194 | 136k | uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8); |
195 | 136k | uint32_t z = len + (static_cast<uint32_t>(c) << 2); |
196 | 136k | return shift_mix(y * k2 ^ z * k3 ^ seed) * k2; |
197 | 136k | } |
198 | | |
199 | 404M | inline uint64_t hash_4to8_bytes(const char *s, size_t len, uint64_t seed) { |
200 | 404M | uint64_t a = fetch32(s); |
201 | 404M | return hash_16_bytes(len + (a << 3), seed ^ fetch32(s + len - 4)); |
202 | 404M | } |
203 | | |
204 | 403M | inline uint64_t hash_9to16_bytes(const char *s, size_t len, uint64_t seed) { |
205 | 403M | uint64_t a = fetch64(s); |
206 | 403M | uint64_t b = fetch64(s + len - 8); |
207 | 403M | return hash_16_bytes(seed ^ a, rotate(b + len, len)) ^ b; |
208 | 403M | } |
209 | | |
210 | 420M | inline uint64_t hash_17to32_bytes(const char *s, size_t len, uint64_t seed) { |
211 | 420M | uint64_t a = fetch64(s) * k1; |
212 | 420M | uint64_t b = fetch64(s + 8); |
213 | 420M | uint64_t c = fetch64(s + len - 8) * k2; |
214 | 420M | uint64_t d = fetch64(s + len - 16) * k0; |
215 | 420M | return hash_16_bytes(rotate(a - b, 43) + rotate(c ^ seed, 30) + d, |
216 | 420M | a + rotate(b ^ k3, 20) - c + len + seed); |
217 | 420M | } |
218 | | |
219 | 114M | inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) { |
220 | 114M | uint64_t z = fetch64(s + 24); |
221 | 114M | uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0; |
222 | 114M | uint64_t b = rotate(a + z, 52); |
223 | 114M | uint64_t c = rotate(a, 37); |
224 | 114M | a += fetch64(s + 8); |
225 | 114M | c += rotate(a, 7); |
226 | 114M | a += fetch64(s + 16); |
227 | 114M | uint64_t vf = a + z; |
228 | 114M | uint64_t vs = b + rotate(a, 31) + c; |
229 | 114M | a = fetch64(s + 16) + fetch64(s + len - 32); |
230 | 114M | z = fetch64(s + len - 8); |
231 | 114M | b = rotate(a + z, 52); |
232 | 114M | c = rotate(a, 37); |
233 | 114M | a += fetch64(s + len - 24); |
234 | 114M | c += rotate(a, 7); |
235 | 114M | a += fetch64(s + len - 16); |
236 | 114M | uint64_t wf = a + z; |
237 | 114M | uint64_t ws = b + rotate(a, 31) + c; |
238 | 114M | uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0); |
239 | 114M | return shift_mix((seed ^ (r * k0)) + vs) * k2; |
240 | 114M | } |
241 | | |
242 | 1.37G | inline uint64_t hash_short(const char *s, size_t length, uint64_t seed) { |
243 | 1.37G | if (length >= 4 && 1.37G length <= 81.34G ) |
244 | 404M | return hash_4to8_bytes(s, length, seed); |
245 | 968M | if (968M length > 8 && 968M length <= 16938M ) |
246 | 403M | return hash_9to16_bytes(s, length, seed); |
247 | 564M | if (564M length > 16 && 564M length <= 32534M ) |
248 | 420M | return hash_17to32_bytes(s, length, seed); |
249 | 144M | if (144M length > 32144M ) |
250 | 114M | return hash_33to64_bytes(s, length, seed); |
251 | 29.9M | if (29.9M length != 029.9M ) |
252 | 136k | return hash_1to3_bytes(s, length, seed); |
253 | 29.9M | |
254 | 29.8M | return k2 ^ seed; |
255 | 1.37G | } |
256 | | |
257 | | /// \brief The intermediate state used during hashing. |
258 | | /// Currently, the algorithm for computing hash codes is based on CityHash and |
259 | | /// keeps 56 bytes of arbitrary state. |
260 | | struct hash_state { |
261 | | uint64_t h0, h1, h2, h3, h4, h5, h6; |
262 | | |
263 | | /// \brief Create a new hash_state structure and initialize it based on the |
264 | | /// seed and the first 64-byte chunk. |
265 | | /// This effectively performs the initial mix. |
266 | 23.2M | static hash_state create(const char *s, uint64_t seed) { |
267 | 23.2M | hash_state state = { |
268 | 23.2M | 0, seed, hash_16_bytes(seed, k1), rotate(seed ^ k1, 49), |
269 | 23.2M | seed * k1, shift_mix(seed), 0 }; |
270 | 23.2M | state.h6 = hash_16_bytes(state.h4, state.h5); |
271 | 23.2M | state.mix(s); |
272 | 23.2M | return state; |
273 | 23.2M | } |
274 | | |
275 | | /// \brief Mix 32-bytes from the input sequence into the 16-bytes of 'a' |
276 | | /// and 'b', including whatever is already in 'a' and 'b'. |
277 | 144M | static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) { |
278 | 144M | a += fetch64(s); |
279 | 144M | uint64_t c = fetch64(s + 24); |
280 | 144M | b = rotate(b + a + c, 21); |
281 | 144M | uint64_t d = a; |
282 | 144M | a += fetch64(s + 8) + fetch64(s + 16); |
283 | 144M | b += rotate(a, 44) + d; |
284 | 144M | a += c; |
285 | 144M | } |
286 | | |
287 | | /// \brief Mix in a 64-byte buffer of data. |
288 | | /// We mix all 64 bytes even when the chunk length is smaller, but we |
289 | | /// record the actual length. |
290 | 72.2M | void mix(const char *s) { |
291 | 72.2M | h0 = rotate(h0 + h1 + h3 + fetch64(s + 8), 37) * k1; |
292 | 72.2M | h1 = rotate(h1 + h4 + fetch64(s + 48), 42) * k1; |
293 | 72.2M | h0 ^= h6; |
294 | 72.2M | h1 += h3 + fetch64(s + 40); |
295 | 72.2M | h2 = rotate(h2 + h5, 33) * k1; |
296 | 72.2M | h3 = h4 * k1; |
297 | 72.2M | h4 = h0 + h5; |
298 | 72.2M | mix_32_bytes(s, h3, h4); |
299 | 72.2M | h5 = h2 + h6; |
300 | 72.2M | h6 = h1 + fetch64(s + 16); |
301 | 72.2M | mix_32_bytes(s + 32, h5, h6); |
302 | 72.2M | std::swap(h2, h0); |
303 | 72.2M | } |
304 | | |
305 | | /// \brief Compute the final 64-bit hash code value based on the current |
306 | | /// state and the length of bytes hashed. |
307 | 23.2M | uint64_t finalize(size_t length) { |
308 | 23.2M | return hash_16_bytes(hash_16_bytes(h3, h5) + shift_mix(h1) * k1 + h2, |
309 | 23.2M | hash_16_bytes(h4, h6) + shift_mix(length) * k1 + h0); |
310 | 23.2M | } |
311 | | }; |
312 | | |
313 | | |
314 | | /// \brief A global, fixed seed-override variable. |
315 | | /// |
316 | | /// This variable can be set using the \see llvm::set_fixed_execution_seed |
317 | | /// function. See that function for details. Do not, under any circumstances, |
318 | | /// set or read this variable. |
319 | | extern size_t fixed_seed_override; |
320 | | |
321 | 1.39G | inline size_t get_execution_seed() { |
322 | 1.39G | // FIXME: This needs to be a per-execution seed. This is just a placeholder |
323 | 1.39G | // implementation. Switching to a per-execution seed is likely to flush out |
324 | 1.39G | // instability bugs and so will happen as its own commit. |
325 | 1.39G | // |
326 | 1.39G | // However, if there is a fixed seed override set the first time this is |
327 | 1.39G | // called, return that instead of the per-execution seed. |
328 | 1.39G | const uint64_t seed_prime = 0xff51afd7ed558ccdULL; |
329 | 0 | static size_t seed = fixed_seed_override ? fixed_seed_override |
330 | 1.39G | : (size_t)seed_prime; |
331 | 1.39G | return seed; |
332 | 1.39G | } |
333 | | |
334 | | |
335 | | /// \brief Trait to indicate whether a type's bits can be hashed directly. |
336 | | /// |
337 | | /// A type trait which is true if we want to combine values for hashing by |
338 | | /// reading the underlying data. It is false if values of this type must |
339 | | /// first be passed to hash_value, and the resulting hash_codes combined. |
340 | | // |
341 | | // FIXME: We want to replace is_integral_or_enum and is_pointer here with |
342 | | // a predicate which asserts that comparing the underlying storage of two |
343 | | // values of the type for equality is equivalent to comparing the two values |
344 | | // for equality. For all the platforms we care about, this holds for integers |
345 | | // and pointers, but there are platforms where it doesn't and we would like to |
346 | | // support user-defined types which happen to satisfy this property. |
347 | | template <typename T> struct is_hashable_data |
348 | | : std::integral_constant<bool, ((is_integral_or_enum<T>::value || |
349 | | std::is_pointer<T>::value) && |
350 | | 64 % sizeof(T) == 0)> {}; |
351 | | |
352 | | // Special case std::pair to detect when both types are viable and when there |
353 | | // is no alignment-derived padding in the pair. This is a bit of a lie because |
354 | | // std::pair isn't truly POD, but it's close enough in all reasonable |
355 | | // implementations for our use case of hashing the underlying data. |
356 | | template <typename T, typename U> struct is_hashable_data<std::pair<T, U> > |
357 | | : std::integral_constant<bool, (is_hashable_data<T>::value && |
358 | | is_hashable_data<U>::value && |
359 | | (sizeof(T) + sizeof(U)) == |
360 | | sizeof(std::pair<T, U>))> {}; |
361 | | |
362 | | /// \brief Helper to get the hashable data representation for a type. |
363 | | /// This variant is enabled when the type itself can be used. |
364 | | template <typename T> |
365 | | typename std::enable_if<is_hashable_data<T>::value, T>::type |
366 | 1.19G | get_hashable_data(const T &value) { |
367 | 1.19G | return value; |
368 | 1.19G | } std::__1::enable_if<is_hashable_data<llvm::Value const*>::value, llvm::Value const*>::type llvm::hashing::detail::get_hashable_data<llvm::Value const*>(llvm::Value const* const&) Line | Count | Source | 366 | 820k | get_hashable_data(const T &value) { | 367 | 820k | return value; | 368 | 820k | } |
std::__1::enable_if<is_hashable_data<bool>::value, bool>::type llvm::hashing::detail::get_hashable_data<bool>(bool const&) Line | Count | Source | 366 | 54.6M | get_hashable_data(const T &value) { | 367 | 54.6M | return value; | 368 | 54.6M | } |
std::__1::enable_if<is_hashable_data<llvm::BasicBlock*>::value, llvm::BasicBlock*>::type llvm::hashing::detail::get_hashable_data<llvm::BasicBlock*>(llvm::BasicBlock* const&) Line | Count | Source | 366 | 2.94M | get_hashable_data(const T &value) { | 367 | 2.94M | return value; | 368 | 2.94M | } |
std::__1::enable_if<is_hashable_data<llvm::Loop const*>::value, llvm::Loop const*>::type llvm::hashing::detail::get_hashable_data<llvm::Loop const*>(llvm::Loop const* const&) Line | Count | Source | 366 | 2.94M | get_hashable_data(const T &value) { | 367 | 2.94M | return value; | 368 | 2.94M | } |
std::__1::enable_if<is_hashable_data<int>::value, int>::type llvm::hashing::detail::get_hashable_data<int>(int const&) Line | Count | Source | 366 | 1.07M | get_hashable_data(const T &value) { | 367 | 1.07M | return value; | 368 | 1.07M | } |
std::__1::enable_if<is_hashable_data<char const*>::value, char const*>::type llvm::hashing::detail::get_hashable_data<char const*>(char const* const&) Line | Count | Source | 366 | 5.40k | get_hashable_data(const T &value) { | 367 | 5.40k | return value; | 368 | 5.40k | } |
std::__1::enable_if<is_hashable_data<llvm::GlobalValue const*>::value, llvm::GlobalValue const*>::type llvm::hashing::detail::get_hashable_data<llvm::GlobalValue const*>(llvm::GlobalValue const* const&) Line | Count | Source | 366 | 6.77M | get_hashable_data(const T &value) { | 367 | 6.77M | return value; | 368 | 6.77M | } |
std::__1::enable_if<is_hashable_data<llvm::BlockAddress const*>::value, llvm::BlockAddress const*>::type llvm::hashing::detail::get_hashable_data<llvm::BlockAddress const*>(llvm::BlockAddress const* const&) Line | Count | Source | 366 | 353 | get_hashable_data(const T &value) { | 367 | 353 | return value; | 368 | 353 | } |
std::__1::enable_if<is_hashable_data<llvm::MCSymbol*>::value, llvm::MCSymbol*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol*>(llvm::MCSymbol* const&) Line | Count | Source | 366 | 153 | get_hashable_data(const T &value) { | 367 | 153 | return value; | 368 | 153 | } |
std::__1::enable_if<is_hashable_data<llvm::MachineBasicBlock*>::value, llvm::MachineBasicBlock*>::type llvm::hashing::detail::get_hashable_data<llvm::MachineBasicBlock*>(llvm::MachineBasicBlock* const&) Line | Count | Source | 366 | 2.66M | get_hashable_data(const T &value) { | 367 | 2.66M | return value; | 368 | 2.66M | } |
std::__1::enable_if<is_hashable_data<llvm::MachineOperand::MachineOperandType>::value, llvm::MachineOperand::MachineOperandType>::type llvm::hashing::detail::get_hashable_data<llvm::MachineOperand::MachineOperandType>(llvm::MachineOperand::MachineOperandType const&) Line | Count | Source | 366 | 75.5M | get_hashable_data(const T &value) { | 367 | 75.5M | return value; | 368 | 75.5M | } |
std::__1::enable_if<is_hashable_data<long long>::value, long long>::type llvm::hashing::detail::get_hashable_data<long long>(long long const&) Line | Count | Source | 366 | 31.8M | get_hashable_data(const T &value) { | 367 | 31.8M | return value; | 368 | 31.8M | } |
std::__1::enable_if<is_hashable_data<llvm::ConstantInt const*>::value, llvm::ConstantInt const*>::type llvm::hashing::detail::get_hashable_data<llvm::ConstantInt const*>(llvm::ConstantInt const* const&) Line | Count | Source | 366 | 1 | get_hashable_data(const T &value) { | 367 | 1 | return value; | 368 | 1 | } |
std::__1::enable_if<is_hashable_data<llvm::ConstantFP const*>::value, llvm::ConstantFP const*>::type llvm::hashing::detail::get_hashable_data<llvm::ConstantFP const*>(llvm::ConstantFP const* const&) Line | Count | Source | 366 | 225 | get_hashable_data(const T &value) { | 367 | 225 | return value; | 368 | 225 | } |
std::__1::enable_if<is_hashable_data<unsigned int const*>::value, unsigned int const*>::type llvm::hashing::detail::get_hashable_data<unsigned int const*>(unsigned int const* const&) Line | Count | Source | 366 | 2 | get_hashable_data(const T &value) { | 367 | 2 | return value; | 368 | 2 | } |
Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::MDNode const*>::value, llvm::MDNode const*>::type llvm::hashing::detail::get_hashable_data<llvm::MDNode const*>(llvm::MDNode const* const&) Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::Intrinsic::ID>::value, llvm::Intrinsic::ID>::type llvm::hashing::detail::get_hashable_data<llvm::Intrinsic::ID>(llvm::Intrinsic::ID const&) std::__1::enable_if<is_hashable_data<unsigned long long>::value, unsigned long long>::type llvm::hashing::detail::get_hashable_data<unsigned long long>(unsigned long long const&) Line | Count | Source | 366 | 326M | get_hashable_data(const T &value) { | 367 | 326M | return value; | 368 | 326M | } |
std::__1::enable_if<is_hashable_data<unsigned char>::value, unsigned char>::type llvm::hashing::detail::get_hashable_data<unsigned char>(unsigned char const&) Line | Count | Source | 366 | 57.9M | get_hashable_data(const T &value) { | 367 | 57.9M | return value; | 368 | 57.9M | } |
std::__1::enable_if<is_hashable_data<llvm::MDString*>::value, llvm::MDString*>::type llvm::hashing::detail::get_hashable_data<llvm::MDString*>(llvm::MDString* const&) Line | Count | Source | 366 | 105k | get_hashable_data(const T &value) { | 367 | 105k | return value; | 368 | 105k | } |
std::__1::enable_if<is_hashable_data<unsigned short>::value, unsigned short>::type llvm::hashing::detail::get_hashable_data<unsigned short>(unsigned short const&) Line | Count | Source | 366 | 28.0M | get_hashable_data(const T &value) { | 367 | 28.0M | return value; | 368 | 28.0M | } |
std::__1::enable_if<is_hashable_data<llvm::DIFile::ChecksumKind>::value, llvm::DIFile::ChecksumKind>::type llvm::hashing::detail::get_hashable_data<llvm::DIFile::ChecksumKind>(llvm::DIFile::ChecksumKind const&) Line | Count | Source | 366 | 10.5k | get_hashable_data(const T &value) { | 367 | 10.5k | return value; | 368 | 10.5k | } |
std::__1::enable_if<is_hashable_data<llvm::Type const*>::value, llvm::Type const*>::type llvm::hashing::detail::get_hashable_data<llvm::Type const*>(llvm::Type const* const&) Line | Count | Source | 366 | 8.37M | get_hashable_data(const T &value) { | 367 | 8.37M | return value; | 368 | 8.37M | } |
std::__1::enable_if<is_hashable_data<llvm::Metadata*>::value, llvm::Metadata*>::type llvm::hashing::detail::get_hashable_data<llvm::Metadata*>(llvm::Metadata* const&) Line | Count | Source | 366 | 5.79M | get_hashable_data(const T &value) { | 367 | 5.79M | return value; | 368 | 5.79M | } |
std::__1::enable_if<is_hashable_data<llvm::InlineAsm::AsmDialect>::value, llvm::InlineAsm::AsmDialect>::type llvm::hashing::detail::get_hashable_data<llvm::InlineAsm::AsmDialect>(llvm::InlineAsm::AsmDialect const&) Line | Count | Source | 366 | 13.3k | get_hashable_data(const T &value) { | 367 | 13.3k | return value; | 368 | 13.3k | } |
std::__1::enable_if<is_hashable_data<llvm::FunctionType*>::value, llvm::FunctionType*>::type llvm::hashing::detail::get_hashable_data<llvm::FunctionType*>(llvm::FunctionType* const&) Line | Count | Source | 366 | 13.3k | get_hashable_data(const T &value) { | 367 | 13.3k | return value; | 368 | 13.3k | } |
std::__1::enable_if<is_hashable_data<llvm::ArrayType*>::value, llvm::ArrayType*>::type llvm::hashing::detail::get_hashable_data<llvm::ArrayType*>(llvm::ArrayType* const&) Line | Count | Source | 366 | 45.2k | get_hashable_data(const T &value) { | 367 | 45.2k | return value; | 368 | 45.2k | } |
std::__1::enable_if<is_hashable_data<llvm::StructType*>::value, llvm::StructType*>::type llvm::hashing::detail::get_hashable_data<llvm::StructType*>(llvm::StructType* const&) Line | Count | Source | 366 | 231k | get_hashable_data(const T &value) { | 367 | 231k | return value; | 368 | 231k | } |
std::__1::enable_if<is_hashable_data<llvm::VectorType*>::value, llvm::VectorType*>::type llvm::hashing::detail::get_hashable_data<llvm::VectorType*>(llvm::VectorType* const&) Line | Count | Source | 366 | 233k | get_hashable_data(const T &value) { | 367 | 233k | return value; | 368 | 233k | } |
std::__1::enable_if<is_hashable_data<llvm::Type*>::value, llvm::Type*>::type llvm::hashing::detail::get_hashable_data<llvm::Type*>(llvm::Type* const&) Line | Count | Source | 366 | 70.6M | get_hashable_data(const T &value) { | 367 | 70.6M | return value; | 368 | 70.6M | } |
std::__1::enable_if<is_hashable_data<llvm::PointerType*>::value, llvm::PointerType*>::type llvm::hashing::detail::get_hashable_data<llvm::PointerType*>(llvm::PointerType* const&) Line | Count | Source | 366 | 13.3k | get_hashable_data(const T &value) { | 367 | 13.3k | return value; | 368 | 13.3k | } |
std::__1::enable_if<is_hashable_data<char>::value, char>::type llvm::hashing::detail::get_hashable_data<char>(char const&) Line | Count | Source | 366 | 453k | get_hashable_data(const T &value) { | 367 | 453k | return value; | 368 | 453k | } |
std::__1::enable_if<is_hashable_data<llvm::MCSymbol const*>::value, llvm::MCSymbol const*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol const*>(llvm::MCSymbol const* const&) Line | Count | Source | 366 | 11.2k | get_hashable_data(const T &value) { | 367 | 11.2k | return value; | 368 | 11.2k | } |
std::__1::enable_if<is_hashable_data<llvm::Instruction::BinaryOps>::value, llvm::Instruction::BinaryOps>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction::BinaryOps>(llvm::Instruction::BinaryOps const&) Line | Count | Source | 366 | 10.5M | get_hashable_data(const T &value) { | 367 | 10.5M | return value; | 368 | 10.5M | } |
std::__1::enable_if<is_hashable_data<llvm::Value*>::value, llvm::Value*>::type llvm::hashing::detail::get_hashable_data<llvm::Value*>(llvm::Value* const&) Line | Count | Source | 366 | 193M | get_hashable_data(const T &value) { | 367 | 193M | return value; | 368 | 193M | } |
std::__1::enable_if<is_hashable_data<llvm::CmpInst::Predicate>::value, llvm::CmpInst::Predicate>::type llvm::hashing::detail::get_hashable_data<llvm::CmpInst::Predicate>(llvm::CmpInst::Predicate const&) Line | Count | Source | 366 | 19.4M | get_hashable_data(const T &value) { | 367 | 19.4M | return value; | 368 | 19.4M | } |
std::__1::enable_if<is_hashable_data<llvm::Instruction::CastOps>::value, llvm::Instruction::CastOps>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction::CastOps>(llvm::Instruction::CastOps const&) Line | Count | Source | 366 | 10.8M | get_hashable_data(const T &value) { | 367 | 10.8M | return value; | 368 | 10.8M | } |
std::__1::enable_if<is_hashable_data<llvm::Instruction*>::value, llvm::Instruction*>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction*>(llvm::Instruction* const&) Line | Count | Source | 366 | 324 | get_hashable_data(const T &value) { | 367 | 324 | return value; | 368 | 324 | } |
std::__1::enable_if<is_hashable_data<llvm::Constant*>::value, llvm::Constant*>::type llvm::hashing::detail::get_hashable_data<llvm::Constant*>(llvm::Constant* const&) Line | Count | Source | 366 | 437 | get_hashable_data(const T &value) { | 367 | 437 | return value; | 368 | 437 | } |
std::__1::enable_if<is_hashable_data<llvm::MemoryAccess const*>::value, llvm::MemoryAccess const*>::type llvm::hashing::detail::get_hashable_data<llvm::MemoryAccess const*>(llvm::MemoryAccess const* const&) Line | Count | Source | 366 | 1.12k | get_hashable_data(const T &value) { | 367 | 1.12k | return value; | 368 | 1.12k | } |
std::__1::enable_if<is_hashable_data<short>::value, short>::type llvm::hashing::detail::get_hashable_data<short>(short const&) Line | Count | Source | 366 | 766k | get_hashable_data(const T &value) { | 367 | 766k | return value; | 368 | 766k | } |
Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::fltSemantics const*>::value, llvm::fltSemantics const*>::type llvm::hashing::detail::get_hashable_data<llvm::fltSemantics const*>(llvm::fltSemantics const* const&) std::__1::enable_if<is_hashable_data<clang::NestedNameSpecifier*>::value, clang::NestedNameSpecifier*>::type llvm::hashing::detail::get_hashable_data<clang::NestedNameSpecifier*>(clang::NestedNameSpecifier* const&) Line | Count | Source | 366 | 270 | get_hashable_data(const T &value) { | 367 | 270 | return value; | 368 | 270 | } |
std::__1::enable_if<is_hashable_data<void*>::value, void*>::type llvm::hashing::detail::get_hashable_data<void*>(void* const&) Line | Count | Source | 366 | 9.42k | get_hashable_data(const T &value) { | 367 | 9.42k | return value; | 368 | 9.42k | } |
std::__1::enable_if<is_hashable_data<llvm::coverage::Counter::CounterKind>::value, llvm::coverage::Counter::CounterKind>::type llvm::hashing::detail::get_hashable_data<llvm::coverage::Counter::CounterKind>(llvm::coverage::Counter::CounterKind const&) Line | Count | Source | 366 | 3.17k | get_hashable_data(const T &value) { | 367 | 3.17k | return value; | 368 | 3.17k | } |
std::__1::enable_if<is_hashable_data<llvm::coverage::CounterExpression::ExprKind>::value, llvm::coverage::CounterExpression::ExprKind>::type llvm::hashing::detail::get_hashable_data<llvm::coverage::CounterExpression::ExprKind>(llvm::coverage::CounterExpression::ExprKind const&) Line | Count | Source | 366 | 1.58k | get_hashable_data(const T &value) { | 367 | 1.58k | return value; | 368 | 1.58k | } |
std::__1::enable_if<is_hashable_data<llvm::RegisterBankInfo::ValueMapping const*>::value, llvm::RegisterBankInfo::ValueMapping const*>::type llvm::hashing::detail::get_hashable_data<llvm::RegisterBankInfo::ValueMapping const*>(llvm::RegisterBankInfo::ValueMapping const* const&) Line | Count | Source | 366 | 7.22M | get_hashable_data(const T &value) { | 367 | 7.22M | return value; | 368 | 7.22M | } |
std::__1::enable_if<is_hashable_data<long>::value, long>::type llvm::hashing::detail::get_hashable_data<long>(long const&) Line | Count | Source | 366 | 59.0k | get_hashable_data(const T &value) { | 367 | 59.0k | return value; | 368 | 59.0k | } |
std::__1::enable_if<is_hashable_data<unsigned int>::value, unsigned int>::type llvm::hashing::detail::get_hashable_data<unsigned int>(unsigned int const&) Line | Count | Source | 366 | 272M | get_hashable_data(const T &value) { | 367 | 272M | return value; | 368 | 272M | } |
|
369 | | /// \brief Helper to get the hashable data representation for a type. |
370 | | /// This variant is enabled when we must first call hash_value and use the |
371 | | /// result as our data. |
372 | | template <typename T> |
373 | | typename std::enable_if<!is_hashable_data<T>::value, size_t>::type |
374 | 154M | get_hashable_data(const T &value) { |
375 | 154M | using ::llvm::hash_value; |
376 | 154M | return hash_value(value); |
377 | 154M | } std::__1::enable_if<!(is_hashable_data<llvm::hash_code>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::hash_code>(llvm::hash_code const&) Line | Count | Source | 374 | 153M | get_hashable_data(const T &value) { | 375 | 153M | using ::llvm::hash_value; | 376 | 153M | return hash_value(value); | 377 | 153M | } |
std::__1::enable_if<!(is_hashable_data<llvm::MachineOperand>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::MachineOperand>(llvm::MachineOperand const&) Line | Count | Source | 374 | 91.4k | get_hashable_data(const T &value) { | 375 | 91.4k | using ::llvm::hash_value; | 376 | 91.4k | return hash_value(value); | 377 | 91.4k | } |
std::__1::enable_if<!(is_hashable_data<llvm::StringRef>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::StringRef>(llvm::StringRef const&) Line | Count | Source | 374 | 553k | get_hashable_data(const T &value) { | 375 | 553k | using ::llvm::hash_value; | 376 | 553k | return hash_value(value); | 377 | 553k | } |
std::__1::enable_if<!(is_hashable_data<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 374 | 17.0k | get_hashable_data(const T &value) { | 375 | 17.0k | using ::llvm::hash_value; | 376 | 17.0k | return hash_value(value); | 377 | 17.0k | } |
|
378 | | |
379 | | /// \brief Helper to store data from a value into a buffer and advance the |
380 | | /// pointer into that buffer. |
381 | | /// |
382 | | /// This routine first checks whether there is enough space in the provided |
383 | | /// buffer, and if not immediately returns false. If there is space, it |
384 | | /// copies the underlying bytes of value into the buffer, advances the |
385 | | /// buffer_ptr past the copied bytes, and returns true. |
386 | | template <typename T> |
387 | | bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value, |
388 | 1.38G | size_t offset = 0) { |
389 | 1.38G | size_t store_size = sizeof(value) - offset; |
390 | 1.38G | if (buffer_ptr + store_size > buffer_end) |
391 | 4.67M | return false; |
392 | 1.38G | const char *value_data = reinterpret_cast<const char *>(&value); |
393 | 1.38G | memcpy(buffer_ptr, value_data + offset, store_size); |
394 | 1.38G | buffer_ptr += store_size; |
395 | 1.38G | return true; |
396 | 1.38G | } bool llvm::hashing::detail::store_and_advance<bool>(char*&, char*, bool const&, unsigned long) Line | Count | Source | 388 | 54.6M | size_t offset = 0) { | 389 | 54.6M | size_t store_size = sizeof(value) - offset; | 390 | 54.6M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 54.6M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 54.6M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 54.6M | buffer_ptr += store_size; | 395 | 54.6M | return true; | 396 | 54.6M | } |
bool llvm::hashing::detail::store_and_advance<unsigned int>(char*&, char*, unsigned int const&, unsigned long) Line | Count | Source | 388 | 272M | size_t offset = 0) { | 389 | 272M | size_t store_size = sizeof(value) - offset; | 390 | 272M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 272M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 272M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 272M | buffer_ptr += store_size; | 395 | 272M | return true; | 396 | 272M | } |
bool llvm::hashing::detail::store_and_advance<llvm::GlobalValue const*>(char*&, char*, llvm::GlobalValue const* const&, unsigned long) Line | Count | Source | 388 | 6.77M | size_t offset = 0) { | 389 | 6.77M | size_t store_size = sizeof(value) - offset; | 390 | 6.77M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 6.77M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 6.77M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 6.77M | buffer_ptr += store_size; | 395 | 6.77M | return true; | 396 | 6.77M | } |
bool llvm::hashing::detail::store_and_advance<llvm::BlockAddress const*>(char*&, char*, llvm::BlockAddress const* const&, unsigned long) Line | Count | Source | 388 | 353 | size_t offset = 0) { | 389 | 353 | size_t store_size = sizeof(value) - offset; | 390 | 353 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 353 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 353 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 353 | buffer_ptr += store_size; | 395 | 353 | return true; | 396 | 353 | } |
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol*>(char*&, char*, llvm::MCSymbol* const&, unsigned long) Line | Count | Source | 388 | 153 | size_t offset = 0) { | 389 | 153 | size_t store_size = sizeof(value) - offset; | 390 | 153 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 153 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 153 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 153 | buffer_ptr += store_size; | 395 | 153 | return true; | 396 | 153 | } |
bool llvm::hashing::detail::store_and_advance<llvm::MachineBasicBlock*>(char*&, char*, llvm::MachineBasicBlock* const&, unsigned long) Line | Count | Source | 388 | 2.66M | size_t offset = 0) { | 389 | 2.66M | size_t store_size = sizeof(value) - offset; | 390 | 2.66M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 2.66M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 2.66M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 2.66M | buffer_ptr += store_size; | 395 | 2.66M | return true; | 396 | 2.66M | } |
bool llvm::hashing::detail::store_and_advance<llvm::MachineOperand::MachineOperandType>(char*&, char*, llvm::MachineOperand::MachineOperandType const&, unsigned long) Line | Count | Source | 388 | 75.5M | size_t offset = 0) { | 389 | 75.5M | size_t store_size = sizeof(value) - offset; | 390 | 75.5M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 75.5M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 75.5M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 75.5M | buffer_ptr += store_size; | 395 | 75.5M | return true; | 396 | 75.5M | } |
bool llvm::hashing::detail::store_and_advance<long long>(char*&, char*, long long const&, unsigned long) Line | Count | Source | 388 | 31.8M | size_t offset = 0) { | 389 | 31.8M | size_t store_size = sizeof(value) - offset; | 390 | 31.8M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 31.8M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 31.8M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 31.8M | buffer_ptr += store_size; | 395 | 31.8M | return true; | 396 | 31.8M | } |
bool llvm::hashing::detail::store_and_advance<char const*>(char*&, char*, char const* const&, unsigned long) Line | Count | Source | 388 | 5.40k | size_t offset = 0) { | 389 | 5.40k | size_t store_size = sizeof(value) - offset; | 390 | 5.40k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 5.40k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 5.40k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 5.40k | buffer_ptr += store_size; | 395 | 5.40k | return true; | 396 | 5.40k | } |
bool llvm::hashing::detail::store_and_advance<llvm::ConstantInt const*>(char*&, char*, llvm::ConstantInt const* const&, unsigned long) Line | Count | Source | 388 | 1 | size_t offset = 0) { | 389 | 1 | size_t store_size = sizeof(value) - offset; | 390 | 1 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 1 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 1 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 1 | buffer_ptr += store_size; | 395 | 1 | return true; | 396 | 1 | } |
bool llvm::hashing::detail::store_and_advance<llvm::ConstantFP const*>(char*&, char*, llvm::ConstantFP const* const&, unsigned long) Line | Count | Source | 388 | 225 | size_t offset = 0) { | 389 | 225 | size_t store_size = sizeof(value) - offset; | 390 | 225 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 225 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 225 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 225 | buffer_ptr += store_size; | 395 | 225 | return true; | 396 | 225 | } |
bool llvm::hashing::detail::store_and_advance<unsigned int const*>(char*&, char*, unsigned int const* const&, unsigned long) Line | Count | Source | 388 | 2 | size_t offset = 0) { | 389 | 2 | size_t store_size = sizeof(value) - offset; | 390 | 2 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 2 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 2 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 2 | buffer_ptr += store_size; | 395 | 2 | return true; | 396 | 2 | } |
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::MDNode const*>(char*&, char*, llvm::MDNode const* const&, unsigned long) Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::Intrinsic::ID>(char*&, char*, llvm::Intrinsic::ID const&, unsigned long) bool llvm::hashing::detail::store_and_advance<unsigned long long>(char*&, char*, unsigned long long const&, unsigned long) Line | Count | Source | 388 | 326M | size_t offset = 0) { | 389 | 326M | size_t store_size = sizeof(value) - offset; | 390 | 326M | if (buffer_ptr + store_size > buffer_end) | 391 | 2 | return false; | 392 | 326M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 326M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 326M | buffer_ptr += store_size; | 395 | 326M | return true; | 396 | 326M | } |
bool llvm::hashing::detail::store_and_advance<unsigned char>(char*&, char*, unsigned char const&, unsigned long) Line | Count | Source | 388 | 57.9M | size_t offset = 0) { | 389 | 57.9M | size_t store_size = sizeof(value) - offset; | 390 | 57.9M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 57.9M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 57.9M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 57.9M | buffer_ptr += store_size; | 395 | 57.9M | return true; | 396 | 57.9M | } |
bool llvm::hashing::detail::store_and_advance<llvm::MDString*>(char*&, char*, llvm::MDString* const&, unsigned long) Line | Count | Source | 388 | 105k | size_t offset = 0) { | 389 | 105k | size_t store_size = sizeof(value) - offset; | 390 | 105k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 105k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 105k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 105k | buffer_ptr += store_size; | 395 | 105k | return true; | 396 | 105k | } |
bool llvm::hashing::detail::store_and_advance<unsigned short>(char*&, char*, unsigned short const&, unsigned long) Line | Count | Source | 388 | 28.0M | size_t offset = 0) { | 389 | 28.0M | size_t store_size = sizeof(value) - offset; | 390 | 28.0M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 28.0M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 28.0M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 28.0M | buffer_ptr += store_size; | 395 | 28.0M | return true; | 396 | 28.0M | } |
bool llvm::hashing::detail::store_and_advance<llvm::DIFile::ChecksumKind>(char*&, char*, llvm::DIFile::ChecksumKind const&, unsigned long) Line | Count | Source | 388 | 10.5k | size_t offset = 0) { | 389 | 10.5k | size_t store_size = sizeof(value) - offset; | 390 | 10.5k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 10.5k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 10.5k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 10.5k | buffer_ptr += store_size; | 395 | 10.5k | return true; | 396 | 10.5k | } |
bool llvm::hashing::detail::store_and_advance<llvm::Type const*>(char*&, char*, llvm::Type const* const&, unsigned long) Line | Count | Source | 388 | 8.37M | size_t offset = 0) { | 389 | 8.37M | size_t store_size = sizeof(value) - offset; | 390 | 8.37M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 8.37M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 8.37M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 8.37M | buffer_ptr += store_size; | 395 | 8.37M | return true; | 396 | 8.37M | } |
bool llvm::hashing::detail::store_and_advance<llvm::Metadata*>(char*&, char*, llvm::Metadata* const&, unsigned long) Line | Count | Source | 388 | 5.79M | size_t offset = 0) { | 389 | 5.79M | size_t store_size = sizeof(value) - offset; | 390 | 5.79M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 5.79M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 5.79M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 5.79M | buffer_ptr += store_size; | 395 | 5.79M | return true; | 396 | 5.79M | } |
bool llvm::hashing::detail::store_and_advance<llvm::InlineAsm::AsmDialect>(char*&, char*, llvm::InlineAsm::AsmDialect const&, unsigned long) Line | Count | Source | 388 | 13.3k | size_t offset = 0) { | 389 | 13.3k | size_t store_size = sizeof(value) - offset; | 390 | 13.3k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 13.3k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 13.3k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 13.3k | buffer_ptr += store_size; | 395 | 13.3k | return true; | 396 | 13.3k | } |
bool llvm::hashing::detail::store_and_advance<llvm::FunctionType*>(char*&, char*, llvm::FunctionType* const&, unsigned long) Line | Count | Source | 388 | 13.3k | size_t offset = 0) { | 389 | 13.3k | size_t store_size = sizeof(value) - offset; | 390 | 13.3k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 13.3k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 13.3k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 13.3k | buffer_ptr += store_size; | 395 | 13.3k | return true; | 396 | 13.3k | } |
bool llvm::hashing::detail::store_and_advance<llvm::ArrayType*>(char*&, char*, llvm::ArrayType* const&, unsigned long) Line | Count | Source | 388 | 45.2k | size_t offset = 0) { | 389 | 45.2k | size_t store_size = sizeof(value) - offset; | 390 | 45.2k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 45.2k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 45.2k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 45.2k | buffer_ptr += store_size; | 395 | 45.2k | return true; | 396 | 45.2k | } |
bool llvm::hashing::detail::store_and_advance<llvm::StructType*>(char*&, char*, llvm::StructType* const&, unsigned long) Line | Count | Source | 388 | 231k | size_t offset = 0) { | 389 | 231k | size_t store_size = sizeof(value) - offset; | 390 | 231k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 231k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 231k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 231k | buffer_ptr += store_size; | 395 | 231k | return true; | 396 | 231k | } |
bool llvm::hashing::detail::store_and_advance<llvm::VectorType*>(char*&, char*, llvm::VectorType* const&, unsigned long) Line | Count | Source | 388 | 233k | size_t offset = 0) { | 389 | 233k | size_t store_size = sizeof(value) - offset; | 390 | 233k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 233k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 233k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 233k | buffer_ptr += store_size; | 395 | 233k | return true; | 396 | 233k | } |
bool llvm::hashing::detail::store_and_advance<llvm::Type*>(char*&, char*, llvm::Type* const&, unsigned long) Line | Count | Source | 388 | 70.6M | size_t offset = 0) { | 389 | 70.6M | size_t store_size = sizeof(value) - offset; | 390 | 70.6M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 70.6M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 70.6M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 70.6M | buffer_ptr += store_size; | 395 | 70.6M | return true; | 396 | 70.6M | } |
bool llvm::hashing::detail::store_and_advance<llvm::PointerType*>(char*&, char*, llvm::PointerType* const&, unsigned long) Line | Count | Source | 388 | 13.3k | size_t offset = 0) { | 389 | 13.3k | size_t store_size = sizeof(value) - offset; | 390 | 13.3k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 13.3k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 13.3k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 13.3k | buffer_ptr += store_size; | 395 | 13.3k | return true; | 396 | 13.3k | } |
bool llvm::hashing::detail::store_and_advance<llvm::Metadata const*>(char*&, char*, llvm::Metadata const* const&, unsigned long) Line | Count | Source | 388 | 36.7M | size_t offset = 0) { | 389 | 36.7M | size_t store_size = sizeof(value) - offset; | 390 | 36.7M | if (buffer_ptr + store_size > buffer_end) | 391 | 4.07M | return false; | 392 | 32.6M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 32.6M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 32.6M | buffer_ptr += store_size; | 395 | 32.6M | return true; | 396 | 36.7M | } |
bool llvm::hashing::detail::store_and_advance<char>(char*&, char*, char const&, unsigned long) Line | Count | Source | 388 | 453k | size_t offset = 0) { | 389 | 453k | size_t store_size = sizeof(value) - offset; | 390 | 453k | if (buffer_ptr + store_size > buffer_end) | 391 | 3.58k | return false; | 392 | 449k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 449k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 449k | buffer_ptr += store_size; | 395 | 449k | return true; | 396 | 453k | } |
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol const*>(char*&, char*, llvm::MCSymbol const* const&, unsigned long) Line | Count | Source | 388 | 11.2k | size_t offset = 0) { | 389 | 11.2k | size_t store_size = sizeof(value) - offset; | 390 | 11.2k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 11.2k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 11.2k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 11.2k | buffer_ptr += store_size; | 395 | 11.2k | return true; | 396 | 11.2k | } |
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::BinaryOps>(char*&, char*, llvm::Instruction::BinaryOps const&, unsigned long) Line | Count | Source | 388 | 10.5M | size_t offset = 0) { | 389 | 10.5M | size_t store_size = sizeof(value) - offset; | 390 | 10.5M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 10.5M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 10.5M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 10.5M | buffer_ptr += store_size; | 395 | 10.5M | return true; | 396 | 10.5M | } |
bool llvm::hashing::detail::store_and_advance<llvm::Value*>(char*&, char*, llvm::Value* const&, unsigned long) Line | Count | Source | 388 | 193M | size_t offset = 0) { | 389 | 193M | size_t store_size = sizeof(value) - offset; | 390 | 193M | if (buffer_ptr + store_size > buffer_end) | 391 | 595k | return false; | 392 | 193M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 193M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 193M | buffer_ptr += store_size; | 395 | 193M | return true; | 396 | 193M | } |
bool llvm::hashing::detail::store_and_advance<llvm::CmpInst::Predicate>(char*&, char*, llvm::CmpInst::Predicate const&, unsigned long) Line | Count | Source | 388 | 19.4M | size_t offset = 0) { | 389 | 19.4M | size_t store_size = sizeof(value) - offset; | 390 | 19.4M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 19.4M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 19.4M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 19.4M | buffer_ptr += store_size; | 395 | 19.4M | return true; | 396 | 19.4M | } |
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::CastOps>(char*&, char*, llvm::Instruction::CastOps const&, unsigned long) Line | Count | Source | 388 | 10.8M | size_t offset = 0) { | 389 | 10.8M | size_t store_size = sizeof(value) - offset; | 390 | 10.8M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 10.8M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 10.8M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 10.8M | buffer_ptr += store_size; | 395 | 10.8M | return true; | 396 | 10.8M | } |
bool llvm::hashing::detail::store_and_advance<llvm::Instruction*>(char*&, char*, llvm::Instruction* const&, unsigned long) Line | Count | Source | 388 | 324 | size_t offset = 0) { | 389 | 324 | size_t store_size = sizeof(value) - offset; | 390 | 324 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 324 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 324 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 324 | buffer_ptr += store_size; | 395 | 324 | return true; | 396 | 324 | } |
bool llvm::hashing::detail::store_and_advance<llvm::Constant*>(char*&, char*, llvm::Constant* const&, unsigned long) Line | Count | Source | 388 | 437 | size_t offset = 0) { | 389 | 437 | size_t store_size = sizeof(value) - offset; | 390 | 437 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 437 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 437 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 437 | buffer_ptr += store_size; | 395 | 437 | return true; | 396 | 437 | } |
bool llvm::hashing::detail::store_and_advance<llvm::MemoryAccess const*>(char*&, char*, llvm::MemoryAccess const* const&, unsigned long) Line | Count | Source | 388 | 1.12k | size_t offset = 0) { | 389 | 1.12k | size_t store_size = sizeof(value) - offset; | 390 | 1.12k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 1.12k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 1.12k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 1.12k | buffer_ptr += store_size; | 395 | 1.12k | return true; | 396 | 1.12k | } |
bool llvm::hashing::detail::store_and_advance<short>(char*&, char*, short const&, unsigned long) Line | Count | Source | 388 | 766k | size_t offset = 0) { | 389 | 766k | size_t store_size = sizeof(value) - offset; | 390 | 766k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 766k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 766k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 766k | buffer_ptr += store_size; | 395 | 766k | return true; | 396 | 766k | } |
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::fltSemantics const*>(char*&, char*, llvm::fltSemantics const* const&, unsigned long) bool llvm::hashing::detail::store_and_advance<llvm::Value const*>(char*&, char*, llvm::Value const* const&, unsigned long) Line | Count | Source | 388 | 820k | size_t offset = 0) { | 389 | 820k | size_t store_size = sizeof(value) - offset; | 390 | 820k | if (buffer_ptr + store_size > buffer_end) | 391 | 48 | return false; | 392 | 820k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 820k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 820k | buffer_ptr += store_size; | 395 | 820k | return true; | 396 | 820k | } |
bool llvm::hashing::detail::store_and_advance<clang::NestedNameSpecifier*>(char*&, char*, clang::NestedNameSpecifier* const&, unsigned long) Line | Count | Source | 388 | 270 | size_t offset = 0) { | 389 | 270 | size_t store_size = sizeof(value) - offset; | 390 | 270 | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 270 | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 270 | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 270 | buffer_ptr += store_size; | 395 | 270 | return true; | 396 | 270 | } |
bool llvm::hashing::detail::store_and_advance<void*>(char*&, char*, void* const&, unsigned long) Line | Count | Source | 388 | 9.42k | size_t offset = 0) { | 389 | 9.42k | size_t store_size = sizeof(value) - offset; | 390 | 9.42k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 9.42k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 9.42k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 9.42k | buffer_ptr += store_size; | 395 | 9.42k | return true; | 396 | 9.42k | } |
bool llvm::hashing::detail::store_and_advance<llvm::coverage::Counter::CounterKind>(char*&, char*, llvm::coverage::Counter::CounterKind const&, unsigned long) Line | Count | Source | 388 | 3.17k | size_t offset = 0) { | 389 | 3.17k | size_t store_size = sizeof(value) - offset; | 390 | 3.17k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 3.17k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 3.17k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 3.17k | buffer_ptr += store_size; | 395 | 3.17k | return true; | 396 | 3.17k | } |
bool llvm::hashing::detail::store_and_advance<llvm::coverage::CounterExpression::ExprKind>(char*&, char*, llvm::coverage::CounterExpression::ExprKind const&, unsigned long) Line | Count | Source | 388 | 1.58k | size_t offset = 0) { | 389 | 1.58k | size_t store_size = sizeof(value) - offset; | 390 | 1.58k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 1.58k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 1.58k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 1.58k | buffer_ptr += store_size; | 395 | 1.58k | return true; | 396 | 1.58k | } |
bool llvm::hashing::detail::store_and_advance<llvm::RegisterBankInfo::ValueMapping const*>(char*&, char*, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned long) Line | Count | Source | 388 | 7.22M | size_t offset = 0) { | 389 | 7.22M | size_t store_size = sizeof(value) - offset; | 390 | 7.22M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 7.22M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 7.22M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 7.22M | buffer_ptr += store_size; | 395 | 7.22M | return true; | 396 | 7.22M | } |
bool llvm::hashing::detail::store_and_advance<long>(char*&, char*, long const&, unsigned long) Line | Count | Source | 388 | 59.0k | size_t offset = 0) { | 389 | 59.0k | size_t store_size = sizeof(value) - offset; | 390 | 59.0k | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 59.0k | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 59.0k | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 59.0k | buffer_ptr += store_size; | 395 | 59.0k | return true; | 396 | 59.0k | } |
bool llvm::hashing::detail::store_and_advance<llvm::BasicBlock*>(char*&, char*, llvm::BasicBlock* const&, unsigned long) Line | Count | Source | 388 | 2.94M | size_t offset = 0) { | 389 | 2.94M | size_t store_size = sizeof(value) - offset; | 390 | 2.94M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 2.94M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 2.94M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 2.94M | buffer_ptr += store_size; | 395 | 2.94M | return true; | 396 | 2.94M | } |
bool llvm::hashing::detail::store_and_advance<llvm::Loop const*>(char*&, char*, llvm::Loop const* const&, unsigned long) Line | Count | Source | 388 | 2.94M | size_t offset = 0) { | 389 | 2.94M | size_t store_size = sizeof(value) - offset; | 390 | 2.94M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 2.94M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 2.94M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 2.94M | buffer_ptr += store_size; | 395 | 2.94M | return true; | 396 | 2.94M | } |
bool llvm::hashing::detail::store_and_advance<int>(char*&, char*, int const&, unsigned long) Line | Count | Source | 388 | 1.07M | size_t offset = 0) { | 389 | 1.07M | size_t store_size = sizeof(value) - offset; | 390 | 1.07M | if (buffer_ptr + store_size > buffer_end) | 391 | 4 | return false; | 392 | 1.07M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 1.07M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 1.07M | buffer_ptr += store_size; | 395 | 1.07M | return true; | 396 | 1.07M | } |
bool llvm::hashing::detail::store_and_advance<unsigned long>(char*&, char*, unsigned long const&, unsigned long) Line | Count | Source | 388 | 154M | size_t offset = 0) { | 389 | 154M | size_t store_size = sizeof(value) - offset; | 390 | 154M | if (buffer_ptr + store_size > buffer_end) | 391 | 0 | return false; | 392 | 154M | const char *value_data = reinterpret_cast<const char *>(&value); | 393 | 154M | memcpy(buffer_ptr, value_data + offset, store_size); | 394 | 154M | buffer_ptr += store_size; | 395 | 154M | return true; | 396 | 154M | } |
|
397 | | |
398 | | /// \brief Implement the combining of integral values into a hash_code. |
399 | | /// |
400 | | /// This overload is selected when the value type of the iterator is |
401 | | /// integral. Rather than computing a hash_code for each object and then |
402 | | /// combining them, this (as an optimization) directly combines the integers. |
403 | | template <typename InputIteratorT> |
404 | 40.3M | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) { |
405 | 40.3M | const size_t seed = get_execution_seed(); |
406 | 40.3M | char buffer[64], *buffer_ptr = buffer; |
407 | 40.3M | char *const buffer_end = std::end(buffer); |
408 | 160M | while (first != last && 160M store_and_advance(buffer_ptr, buffer_end, |
409 | 120M | get_hashable_data(*first))) |
410 | 119M | ++first; |
411 | 40.3M | if (first == last) |
412 | 39.9M | return hash_short(buffer, buffer_ptr - buffer, seed); |
413 | 323k | assert(buffer_ptr == buffer_end); |
414 | 323k | |
415 | 323k | hash_state state = state.create(buffer, seed); |
416 | 323k | size_t length = 64; |
417 | 4.99M | while (first != last4.99M ) { |
418 | 4.67M | // Fill up the buffer. We don't clear it, which re-mixes the last round |
419 | 4.67M | // when only a partial 64-byte chunk is left. |
420 | 4.67M | buffer_ptr = buffer; |
421 | 40.7M | while (first != last && 40.7M store_and_advance(buffer_ptr, buffer_end, |
422 | 40.3M | get_hashable_data(*first))) |
423 | 36.0M | ++first; |
424 | 4.67M | |
425 | 4.67M | // Rotate the buffer if we did a partial fill in order to simulate doing |
426 | 4.67M | // a mix of the last 64-bytes. That is how the algorithm works when we |
427 | 4.67M | // have a contiguous byte sequence, and we want to emulate that here. |
428 | 4.67M | std::rotate(buffer, buffer_ptr, buffer_end); |
429 | 4.67M | |
430 | 4.67M | // Mix this chunk into the current state. |
431 | 4.67M | state.mix(buffer); |
432 | 4.67M | length += buffer_ptr - buffer; |
433 | 4.67M | }; |
434 | 323k | |
435 | 323k | return state.finalize(length); |
436 | 40.3M | } llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*) Line | Count | Source | 404 | 13.9k | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) { | 405 | 13.9k | const size_t seed = get_execution_seed(); | 406 | 13.9k | char buffer[64], *buffer_ptr = buffer; | 407 | 13.9k | char *const buffer_end = std::end(buffer); | 408 | 96.0k | while (first != last && 96.0k store_and_advance(buffer_ptr, buffer_end, | 409 | 89.6k | get_hashable_data(*first))) | 410 | 82.0k | ++first; | 411 | 13.9k | if (first == last) | 412 | 6.33k | return hash_short(buffer, buffer_ptr - buffer, seed); | 413 | 7.60k | assert(buffer_ptr == buffer_end); | 414 | 7.60k | | 415 | 7.60k | hash_state state = state.create(buffer, seed); | 416 | 7.60k | size_t length = 64; | 417 | 4.08M | while (first != last4.08M ) { | 418 | 4.07M | // Fill up the buffer. We don't clear it, which re-mixes the last round | 419 | 4.07M | // when only a partial 64-byte chunk is left. | 420 | 4.07M | buffer_ptr = buffer; | 421 | 36.6M | while (first != last && 36.6M store_and_advance(buffer_ptr, buffer_end, | 422 | 36.6M | get_hashable_data(*first))) | 423 | 32.5M | ++first; | 424 | 4.07M | | 425 | 4.07M | // Rotate the buffer if we did a partial fill in order to simulate doing | 426 | 4.07M | // a mix of the last 64-bytes. That is how the algorithm works when we | 427 | 4.07M | // have a contiguous byte sequence, and we want to emulate that here. | 428 | 4.07M | std::rotate(buffer, buffer_ptr, buffer_end); | 429 | 4.07M | | 430 | 4.07M | // Mix this chunk into the current state. | 431 | 4.07M | state.mix(buffer); | 432 | 4.07M | length += buffer_ptr - buffer; | 433 | 4.07M | }; | 434 | 7.60k | | 435 | 7.60k | return state.finalize(length); | 436 | 13.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::User::const_value_op_iterator>(llvm::User::const_value_op_iterator, llvm::User::const_value_op_iterator) Line | Count | Source | 404 | 304k | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) { | 405 | 304k | const size_t seed = get_execution_seed(); | 406 | 304k | char buffer[64], *buffer_ptr = buffer; | 407 | 304k | char *const buffer_end = std::end(buffer); | 408 | 1.12M | while (first != last && 1.12M store_and_advance(buffer_ptr, buffer_end, | 409 | 820k | get_hashable_data(*first))) | 410 | 820k | ++first; | 411 | 304k | if (first == last) | 412 | 304k | return hash_short(buffer, buffer_ptr - buffer, seed); | 413 | 48 | assert(buffer_ptr == buffer_end); | 414 | 48 | | 415 | 48 | hash_state state = state.create(buffer, seed); | 416 | 48 | size_t length = 64; | 417 | 96 | while (first != last96 ) { | 418 | 48 | // Fill up the buffer. We don't clear it, which re-mixes the last round | 419 | 48 | // when only a partial 64-byte chunk is left. | 420 | 48 | buffer_ptr = buffer; | 421 | 96 | while (first != last && 96 store_and_advance(buffer_ptr, buffer_end, | 422 | 48 | get_hashable_data(*first))) | 423 | 48 | ++first; | 424 | 48 | | 425 | 48 | // Rotate the buffer if we did a partial fill in order to simulate doing | 426 | 48 | // a mix of the last 64-bytes. That is how the algorithm works when we | 427 | 48 | // have a contiguous byte sequence, and we want to emulate that here. | 428 | 48 | std::rotate(buffer, buffer_ptr, buffer_end); | 429 | 48 | | 430 | 48 | // Mix this chunk into the current state. | 431 | 48 | state.mix(buffer); | 432 | 48 | length += buffer_ptr - buffer; | 433 | 48 | }; | 434 | 48 | | 435 | 48 | return state.finalize(length); | 436 | 304k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::User::value_op_iterator>(llvm::User::value_op_iterator, llvm::User::value_op_iterator) Line | Count | Source | 404 | 39.9M | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) { | 405 | 39.9M | const size_t seed = get_execution_seed(); | 406 | 39.9M | char buffer[64], *buffer_ptr = buffer; | 407 | 39.9M | char *const buffer_end = std::end(buffer); | 408 | 158M | while (first != last && 158M store_and_advance(buffer_ptr, buffer_end, | 409 | 119M | get_hashable_data(*first))) | 410 | 118M | ++first; | 411 | 39.9M | if (first == last) | 412 | 39.6M | return hash_short(buffer, buffer_ptr - buffer, seed); | 413 | 312k | assert(buffer_ptr == buffer_end); | 414 | 312k | | 415 | 312k | hash_state state = state.create(buffer, seed); | 416 | 312k | size_t length = 64; | 417 | 907k | while (first != last907k ) { | 418 | 595k | // Fill up the buffer. We don't clear it, which re-mixes the last round | 419 | 595k | // when only a partial 64-byte chunk is left. | 420 | 595k | buffer_ptr = buffer; | 421 | 3.90M | while (first != last && 3.90M store_and_advance(buffer_ptr, buffer_end, | 422 | 3.58M | get_hashable_data(*first))) | 423 | 3.30M | ++first; | 424 | 595k | | 425 | 595k | // Rotate the buffer if we did a partial fill in order to simulate doing | 426 | 595k | // a mix of the last 64-bytes. That is how the algorithm works when we | 427 | 595k | // have a contiguous byte sequence, and we want to emulate that here. | 428 | 595k | std::rotate(buffer, buffer_ptr, buffer_end); | 429 | 595k | | 430 | 595k | // Mix this chunk into the current state. | 431 | 595k | state.mix(buffer); | 432 | 595k | length += buffer_ptr - buffer; | 433 | 595k | }; | 434 | 312k | | 435 | 312k | return state.finalize(length); | 436 | 39.9M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>) Line | Count | Source | 404 | 18.9k | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) { | 405 | 18.9k | const size_t seed = get_execution_seed(); | 406 | 18.9k | char buffer[64], *buffer_ptr = buffer; | 407 | 18.9k | char *const buffer_end = std::end(buffer); | 408 | 331k | while (first != last && 331k store_and_advance(buffer_ptr, buffer_end, | 409 | 315k | get_hashable_data(*first))) | 410 | 312k | ++first; | 411 | 18.9k | if (first == last) | 412 | 15.4k | return hash_short(buffer, buffer_ptr - buffer, seed); | 413 | 3.44k | assert(buffer_ptr == buffer_end); | 414 | 3.44k | | 415 | 3.44k | hash_state state = state.create(buffer, seed); | 416 | 3.44k | size_t length = 64; | 417 | 7.03k | while (first != last7.03k ) { | 418 | 3.58k | // Fill up the buffer. We don't clear it, which re-mixes the last round | 419 | 3.58k | // when only a partial 64-byte chunk is left. | 420 | 3.58k | buffer_ptr = buffer; | 421 | 140k | while (first != last && 140k store_and_advance(buffer_ptr, buffer_end, | 422 | 137k | get_hashable_data(*first))) | 423 | 137k | ++first; | 424 | 3.58k | | 425 | 3.58k | // Rotate the buffer if we did a partial fill in order to simulate doing | 426 | 3.58k | // a mix of the last 64-bytes. That is how the algorithm works when we | 427 | 3.58k | // have a contiguous byte sequence, and we want to emulate that here. | 428 | 3.58k | std::rotate(buffer, buffer_ptr, buffer_end); | 429 | 3.58k | | 430 | 3.58k | // Mix this chunk into the current state. | 431 | 3.58k | state.mix(buffer); | 432 | 3.58k | length += buffer_ptr - buffer; | 433 | 3.58k | }; | 434 | 3.44k | | 435 | 3.44k | return state.finalize(length); | 436 | 18.9k | } |
|
437 | | |
438 | | /// \brief Implement the combining of integral values into a hash_code. |
439 | | /// |
440 | | /// This overload is selected when the value type of the iterator is integral |
441 | | /// and when the input iterator is actually a pointer. Rather than computing |
442 | | /// a hash_code for each object and then combining them, this (as an |
443 | | /// optimization) directly combines the integers. Also, because the integers |
444 | | /// are stored in contiguous memory, this routine avoids copying each value |
445 | | /// and directly reads from the underlying memory. |
446 | | template <typename ValueT> |
447 | | typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type |
448 | 748M | hash_combine_range_impl(ValueT *first, ValueT *last) { |
449 | 748M | const size_t seed = get_execution_seed(); |
450 | 748M | const char *s_begin = reinterpret_cast<const char *>(first); |
451 | 748M | const char *s_end = reinterpret_cast<const char *>(last); |
452 | 748M | const size_t length = std::distance(s_begin, s_end); |
453 | 748M | if (length <= 64) |
454 | 726M | return hash_short(s_begin, length, seed); |
455 | 748M | |
456 | 22.9M | const char *s_aligned_end = s_begin + (length & ~63); |
457 | 22.9M | hash_state state = state.create(s_begin, seed); |
458 | 22.9M | s_begin += 64; |
459 | 44.5M | while (s_begin != s_aligned_end44.5M ) { |
460 | 21.5M | state.mix(s_begin); |
461 | 21.5M | s_begin += 64; |
462 | 21.5M | } |
463 | 22.9M | if (length & 63) |
464 | 22.7M | state.mix(s_end - 64); |
465 | 22.9M | |
466 | 22.9M | return state.finalize(length); |
467 | 748M | } std::__1::enable_if<is_hashable_data<unsigned char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned char const>(unsigned char const*, unsigned char const*) Line | Count | Source | 448 | 2.66k | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 2.66k | const size_t seed = get_execution_seed(); | 450 | 2.66k | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 2.66k | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 2.66k | const size_t length = std::distance(s_begin, s_end); | 453 | 2.66k | if (length <= 64) | 454 | 2.33k | return hash_short(s_begin, length, seed); | 455 | 2.66k | | 456 | 329 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 329 | hash_state state = state.create(s_begin, seed); | 458 | 329 | s_begin += 64; | 459 | 9.95k | while (s_begin != s_aligned_end9.95k ) { | 460 | 9.62k | state.mix(s_begin); | 461 | 9.62k | s_begin += 64; | 462 | 9.62k | } | 463 | 329 | if (length & 63) | 464 | 290 | state.mix(s_end - 64); | 465 | 329 | | 466 | 329 | return state.finalize(length); | 467 | 2.66k | } |
std::__1::enable_if<is_hashable_data<llvm::RegisterBankInfo::ValueMapping const* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::RegisterBankInfo::ValueMapping const* const>(llvm::RegisterBankInfo::ValueMapping const* const*, llvm::RegisterBankInfo::ValueMapping const* const*) Line | Count | Source | 448 | 6.39M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 6.39M | const size_t seed = get_execution_seed(); | 450 | 6.39M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 6.39M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 6.39M | const size_t length = std::distance(s_begin, s_end); | 453 | 6.39M | if (length <= 64) | 454 | 6.39M | return hash_short(s_begin, length, seed); | 455 | 6.39M | | 456 | 467 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 467 | hash_state state = state.create(s_begin, seed); | 458 | 467 | s_begin += 64; | 459 | 616 | while (s_begin != s_aligned_end616 ) { | 460 | 149 | state.mix(s_begin); | 461 | 149 | s_begin += 64; | 462 | 149 | } | 463 | 467 | if (length & 63) | 464 | 467 | state.mix(s_end - 64); | 465 | 467 | | 466 | 467 | return state.finalize(length); | 467 | 6.39M | } |
std::__1::enable_if<is_hashable_data<llvm::BasicBlock*>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::BasicBlock*>(llvm::BasicBlock**, llvm::BasicBlock**) Line | Count | Source | 448 | 12.8M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 12.8M | const size_t seed = get_execution_seed(); | 450 | 12.8M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 12.8M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 12.8M | const size_t length = std::distance(s_begin, s_end); | 453 | 12.8M | if (length <= 64) | 454 | 12.5M | return hash_short(s_begin, length, seed); | 455 | 12.8M | | 456 | 306k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 306k | hash_state state = state.create(s_begin, seed); | 458 | 306k | s_begin += 64; | 459 | 595k | while (s_begin != s_aligned_end595k ) { | 460 | 289k | state.mix(s_begin); | 461 | 289k | s_begin += 64; | 462 | 289k | } | 463 | 306k | if (length & 63) | 464 | 299k | state.mix(s_end - 64); | 465 | 306k | | 466 | 306k | return state.finalize(length); | 467 | 12.8M | } |
std::__1::enable_if<is_hashable_data<char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<char const>(char const*, char const*) Line | Count | Source | 448 | 6.13M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 6.13M | const size_t seed = get_execution_seed(); | 450 | 6.13M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 6.13M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 6.13M | const size_t length = std::distance(s_begin, s_end); | 453 | 6.13M | if (length <= 64) | 454 | 6.04M | return hash_short(s_begin, length, seed); | 455 | 6.13M | | 456 | 91.0k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 91.0k | hash_state state = state.create(s_begin, seed); | 458 | 91.0k | s_begin += 64; | 459 | 836k | while (s_begin != s_aligned_end836k ) { | 460 | 745k | state.mix(s_begin); | 461 | 745k | s_begin += 64; | 462 | 745k | } | 463 | 91.0k | if (length & 63) | 464 | 90.3k | state.mix(s_end - 64); | 465 | 91.0k | | 466 | 91.0k | return state.finalize(length); | 467 | 6.13M | } |
std::__1::enable_if<is_hashable_data<unsigned long long>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned long long>(unsigned long long*, unsigned long long*) Line | Count | Source | 448 | 5.78M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 5.78M | const size_t seed = get_execution_seed(); | 450 | 5.78M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 5.78M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 5.78M | const size_t length = std::distance(s_begin, s_end); | 453 | 5.78M | if (length <= 64) | 454 | 5.78M | return hash_short(s_begin, length, seed); | 455 | 5.78M | | 456 | 640 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 640 | hash_state state = state.create(s_begin, seed); | 458 | 640 | s_begin += 64; | 459 | 73.6k | while (s_begin != s_aligned_end73.6k ) { | 460 | 72.9k | state.mix(s_begin); | 461 | 72.9k | s_begin += 64; | 462 | 72.9k | } | 463 | 640 | if (length & 63) | 464 | 106 | state.mix(s_end - 64); | 465 | 640 | | 466 | 640 | return state.finalize(length); | 467 | 5.78M | } |
std::__1::enable_if<is_hashable_data<llvm::SCEV const* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::SCEV const* const>(llvm::SCEV const* const*, llvm::SCEV const* const*) Line | Count | Source | 448 | 25.8M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 25.8M | const size_t seed = get_execution_seed(); | 450 | 25.8M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 25.8M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 25.8M | const size_t length = std::distance(s_begin, s_end); | 453 | 25.8M | if (length <= 64) | 454 | 25.8M | return hash_short(s_begin, length, seed); | 455 | 25.8M | | 456 | 0 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 0 | hash_state state = state.create(s_begin, seed); | 458 | 0 | s_begin += 64; | 459 | 0 | while (s_begin != s_aligned_end0 ) { | 460 | 0 | state.mix(s_begin); | 461 | 0 | s_begin += 64; | 462 | 0 | } | 463 | 0 | if (length & 63) | 464 | 0 | state.mix(s_end - 64); | 465 | 0 |
| 466 | 0 | return state.finalize(length); | 467 | 25.8M | } |
std::__1::enable_if<is_hashable_data<llvm::Value* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Value* const>(llvm::Value* const*, llvm::Value* const*) Line | Count | Source | 448 | 2.43k | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 2.43k | const size_t seed = get_execution_seed(); | 450 | 2.43k | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 2.43k | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 2.43k | const size_t length = std::distance(s_begin, s_end); | 453 | 2.43k | if (length <= 64) | 454 | 2.43k | return hash_short(s_begin, length, seed); | 455 | 2.43k | | 456 | 0 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 0 | hash_state state = state.create(s_begin, seed); | 458 | 0 | s_begin += 64; | 459 | 0 | while (s_begin != s_aligned_end0 ) { | 460 | 0 | state.mix(s_begin); | 461 | 0 | s_begin += 64; | 462 | 0 | } | 463 | 0 | if (length & 63) | 464 | 0 | state.mix(s_end - 64); | 465 | 0 |
| 466 | 0 | return state.finalize(length); | 467 | 2.43k | } |
std::__1::enable_if<is_hashable_data<llvm::Metadata* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Metadata* const>(llvm::Metadata* const*, llvm::Metadata* const*) Line | Count | Source | 448 | 1.26M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 1.26M | const size_t seed = get_execution_seed(); | 450 | 1.26M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 1.26M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 1.26M | const size_t length = std::distance(s_begin, s_end); | 453 | 1.26M | if (length <= 64) | 454 | 1.21M | return hash_short(s_begin, length, seed); | 455 | 1.26M | | 456 | 50.7k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 50.7k | hash_state state = state.create(s_begin, seed); | 458 | 50.7k | s_begin += 64; | 459 | 123k | while (s_begin != s_aligned_end123k ) { | 460 | 72.9k | state.mix(s_begin); | 461 | 72.9k | s_begin += 64; | 462 | 72.9k | } | 463 | 50.7k | if (length & 63) | 464 | 50.5k | state.mix(s_end - 64); | 465 | 50.7k | | 466 | 50.7k | return state.finalize(length); | 467 | 1.26M | } |
std::__1::enable_if<is_hashable_data<llvm::Type* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Type* const>(llvm::Type* const*, llvm::Type* const*) Line | Count | Source | 448 | 8.51M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 8.51M | const size_t seed = get_execution_seed(); | 450 | 8.51M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 8.51M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 8.51M | const size_t length = std::distance(s_begin, s_end); | 453 | 8.51M | if (length <= 64) | 454 | 8.46M | return hash_short(s_begin, length, seed); | 455 | 8.51M | | 456 | 52.1k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 52.1k | hash_state state = state.create(s_begin, seed); | 458 | 52.1k | s_begin += 64; | 459 | 77.0k | while (s_begin != s_aligned_end77.0k ) { | 460 | 24.8k | state.mix(s_begin); | 461 | 24.8k | s_begin += 64; | 462 | 24.8k | } | 463 | 52.1k | if (length & 63) | 464 | 51.7k | state.mix(s_end - 64); | 465 | 52.1k | | 466 | 52.1k | return state.finalize(length); | 467 | 8.51M | } |
std::__1::enable_if<is_hashable_data<unsigned int const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned int const>(unsigned int const*, unsigned int const*) Line | Count | Source | 448 | 624M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 624M | const size_t seed = get_execution_seed(); | 450 | 624M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 624M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 624M | const size_t length = std::distance(s_begin, s_end); | 453 | 624M | if (length <= 64) | 454 | 602M | return hash_short(s_begin, length, seed); | 455 | 624M | | 456 | 22.0M | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 22.0M | hash_state state = state.create(s_begin, seed); | 458 | 22.0M | s_begin += 64; | 459 | 42.1M | while (s_begin != s_aligned_end42.1M ) { | 460 | 20.1M | state.mix(s_begin); | 461 | 20.1M | s_begin += 64; | 462 | 20.1M | } | 463 | 22.0M | if (length & 63) | 464 | 21.8M | state.mix(s_end - 64); | 465 | 22.0M | | 466 | 22.0M | return state.finalize(length); | 467 | 624M | } |
std::__1::enable_if<is_hashable_data<llvm::Constant* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Constant* const>(llvm::Constant* const*, llvm::Constant* const*) Line | Count | Source | 448 | 28.6M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 28.6M | const size_t seed = get_execution_seed(); | 450 | 28.6M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 28.6M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 28.6M | const size_t length = std::distance(s_begin, s_end); | 453 | 28.6M | if (length <= 64) | 454 | 28.5M | return hash_short(s_begin, length, seed); | 455 | 28.6M | | 456 | 43.1k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 43.1k | hash_state state = state.create(s_begin, seed); | 458 | 43.1k | s_begin += 64; | 459 | 80.0k | while (s_begin != s_aligned_end80.0k ) { | 460 | 36.8k | state.mix(s_begin); | 461 | 36.8k | s_begin += 64; | 462 | 36.8k | } | 463 | 43.1k | if (length & 63) | 464 | 19.5k | state.mix(s_end - 64); | 465 | 43.1k | | 466 | 43.1k | return state.finalize(length); | 467 | 28.6M | } |
std::__1::enable_if<is_hashable_data<unsigned long long const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned long long const>(unsigned long long const*, unsigned long long const*) Line | Count | Source | 448 | 773k | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 773k | const size_t seed = get_execution_seed(); | 450 | 773k | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 773k | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 773k | const size_t length = std::distance(s_begin, s_end); | 453 | 773k | if (length <= 64) | 454 | 773k | return hash_short(s_begin, length, seed); | 455 | 773k | | 456 | 29 | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 29 | hash_state state = state.create(s_begin, seed); | 458 | 29 | s_begin += 64; | 459 | 35 | while (s_begin != s_aligned_end35 ) { | 460 | 6 | state.mix(s_begin); | 461 | 6 | s_begin += 64; | 462 | 6 | } | 463 | 29 | if (length & 63) | 464 | 28 | state.mix(s_end - 64); | 465 | 29 | | 466 | 29 | return state.finalize(length); | 467 | 773k | } |
std::__1::enable_if<is_hashable_data<unsigned long>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned long>(unsigned long*, unsigned long*) Line | Count | Source | 448 | 27.9M | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 27.9M | const size_t seed = get_execution_seed(); | 450 | 27.9M | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 27.9M | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 27.9M | const size_t length = std::distance(s_begin, s_end); | 453 | 27.9M | if (length <= 64) | 454 | 27.5M | return hash_short(s_begin, length, seed); | 455 | 27.9M | | 456 | 359k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 359k | hash_state state = state.create(s_begin, seed); | 458 | 359k | s_begin += 64; | 459 | 540k | while (s_begin != s_aligned_end540k ) { | 460 | 181k | state.mix(s_begin); | 461 | 181k | s_begin += 64; | 462 | 181k | } | 463 | 359k | if (length & 63) | 464 | 359k | state.mix(s_end - 64); | 465 | 359k | | 466 | 359k | return state.finalize(length); | 467 | 27.9M | } |
std::__1::enable_if<is_hashable_data<unsigned int>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned int>(unsigned int*, unsigned int*) Line | Count | Source | 448 | 2.05k | hash_combine_range_impl(ValueT *first, ValueT *last) { | 449 | 2.05k | const size_t seed = get_execution_seed(); | 450 | 2.05k | const char *s_begin = reinterpret_cast<const char *>(first); | 451 | 2.05k | const char *s_end = reinterpret_cast<const char *>(last); | 452 | 2.05k | const size_t length = std::distance(s_begin, s_end); | 453 | 2.05k | if (length <= 64) | 454 | 205 | return hash_short(s_begin, length, seed); | 455 | 2.05k | | 456 | 1.85k | const char *s_aligned_end = s_begin + (length & ~63); | 457 | 1.85k | hash_state state = state.create(s_begin, seed); | 458 | 1.85k | s_begin += 64; | 459 | 29.4k | while (s_begin != s_aligned_end29.4k ) { | 460 | 27.5k | state.mix(s_begin); | 461 | 27.5k | s_begin += 64; | 462 | 27.5k | } | 463 | 1.85k | if (length & 63) | 464 | 1.51k | state.mix(s_end - 64); | 465 | 1.85k | | 466 | 1.85k | return state.finalize(length); | 467 | 2.05k | } |
|
468 | | |
469 | | } // namespace detail |
470 | | } // namespace hashing |
471 | | |
472 | | |
473 | | /// \brief Compute a hash_code for a sequence of values. |
474 | | /// |
475 | | /// This hashes a sequence of values. It produces the same hash_code as |
476 | | /// 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences |
477 | | /// and is significantly faster given pointers and types which can be hashed as |
478 | | /// a sequence of bytes. |
479 | | template <typename InputIteratorT> |
480 | 789M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { |
481 | 789M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); |
482 | 789M | } llvm::hash_code llvm::hash_combine_range<llvm::User::const_value_op_iterator>(llvm::User::const_value_op_iterator, llvm::User::const_value_op_iterator) Line | Count | Source | 480 | 304k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 304k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 304k | } |
llvm::hash_code llvm::hash_combine_range<unsigned int*>(unsigned int*, unsigned int*) Line | Count | Source | 480 | 2.05k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 2.05k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 2.05k | } |
llvm::hash_code llvm::hash_combine_range<unsigned long*>(unsigned long*, unsigned long*) Line | Count | Source | 480 | 27.9M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 27.9M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 27.9M | } |
llvm::hash_code llvm::hash_combine_range<llvm::Constant* const*>(llvm::Constant* const*, llvm::Constant* const*) Line | Count | Source | 480 | 28.6M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 28.6M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 28.6M | } |
llvm::hash_code llvm::hash_combine_range<unsigned int const*>(unsigned int const*, unsigned int const*) Line | Count | Source | 480 | 624M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 624M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 624M | } |
llvm::hash_code llvm::hash_combine_range<unsigned long long const*>(unsigned long long const*, unsigned long long const*) Line | Count | Source | 480 | 773k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 773k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 773k | } |
llvm::hash_code llvm::hash_combine_range<llvm::Type* const*>(llvm::Type* const*, llvm::Type* const*) Line | Count | Source | 480 | 8.51M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 8.51M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 8.51M | } |
llvm::hash_code llvm::hash_combine_range<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*) Line | Count | Source | 480 | 13.9k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 13.9k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 13.9k | } |
llvm::hash_code llvm::hash_combine_range<llvm::Metadata* const*>(llvm::Metadata* const*, llvm::Metadata* const*) Line | Count | Source | 480 | 1.26M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 1.26M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 1.26M | } |
llvm::hash_code llvm::hash_combine_range<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>) Line | Count | Source | 480 | 18.9k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 18.9k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 18.9k | } |
llvm::hash_code llvm::hash_combine_range<llvm::User::value_op_iterator>(llvm::User::value_op_iterator, llvm::User::value_op_iterator) Line | Count | Source | 480 | 39.9M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 39.9M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 39.9M | } |
llvm::hash_code llvm::hash_combine_range<llvm::Value* const*>(llvm::Value* const*, llvm::Value* const*) Line | Count | Source | 480 | 2.43k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 2.43k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 2.43k | } |
llvm::hash_code llvm::hash_combine_range<llvm::SCEV const* const*>(llvm::SCEV const* const*, llvm::SCEV const* const*) Line | Count | Source | 480 | 25.8M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 25.8M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 25.8M | } |
llvm::hash_code llvm::hash_combine_range<unsigned long long*>(unsigned long long*, unsigned long long*) Line | Count | Source | 480 | 5.78M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 5.78M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 5.78M | } |
llvm::hash_code llvm::hash_combine_range<char const*>(char const*, char const*) Line | Count | Source | 480 | 6.13M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 6.13M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 6.13M | } |
llvm::hash_code llvm::hash_combine_range<llvm::BasicBlock**>(llvm::BasicBlock**, llvm::BasicBlock**) Line | Count | Source | 480 | 12.8M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 12.8M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 12.8M | } |
llvm::hash_code llvm::hash_combine_range<llvm::RegisterBankInfo::ValueMapping const* const*>(llvm::RegisterBankInfo::ValueMapping const* const*, llvm::RegisterBankInfo::ValueMapping const* const*) Line | Count | Source | 480 | 6.39M | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 6.39M | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 6.39M | } |
llvm::hash_code llvm::hash_combine_range<unsigned char const*>(unsigned char const*, unsigned char const*) Line | Count | Source | 480 | 2.66k | hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) { | 481 | 2.66k | return ::llvm::hashing::detail::hash_combine_range_impl(first, last); | 482 | 2.66k | } |
|
483 | | |
484 | | |
485 | | // Implementation details for hash_combine. |
486 | | namespace hashing { |
487 | | namespace detail { |
488 | | |
489 | | /// \brief Helper class to manage the recursive combining of hash_combine |
490 | | /// arguments. |
491 | | /// |
492 | | /// This class exists to manage the state and various calls involved in the |
493 | | /// recursive combining of arguments used in hash_combine. It is particularly |
494 | | /// useful at minimizing the code in the recursive calls to ease the pain |
495 | | /// caused by a lack of variadic functions. |
496 | | struct hash_combine_recursive_helper { |
497 | | char buffer[64]; |
498 | | hash_state state; |
499 | | const size_t seed; |
500 | | |
501 | | public: |
502 | | /// \brief Construct a recursive hash combining helper. |
503 | | /// |
504 | | /// This sets up the state for a recursive hash combine, including getting |
505 | | /// the seed and buffer setup. |
506 | | hash_combine_recursive_helper() |
507 | 606M | : seed(get_execution_seed()) {} |
508 | | |
509 | | /// \brief Combine one chunk of data into the current in-flight hash. |
510 | | /// |
511 | | /// This merges one chunk of data into the hash. First it tries to buffer |
512 | | /// the data. If the buffer is full, it hashes the buffer into its |
513 | | /// hash_state, empties it, and then merges the new chunk in. This also |
514 | | /// handles cases where the data straddles the end of the buffer. |
515 | | template <typename T> |
516 | 1.22G | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { |
517 | 1.22G | if (!store_and_advance(buffer_ptr, buffer_end, data)1.22G ) { |
518 | 6 | // Check for skew which prevents the buffer from being packed, and do |
519 | 6 | // a partial store into the buffer to fill it. This is only a concern |
520 | 6 | // with the variadic combine because that formation can have varying |
521 | 6 | // argument types. |
522 | 6 | size_t partial_store_size = buffer_end - buffer_ptr; |
523 | 6 | memcpy(buffer_ptr, &data, partial_store_size); |
524 | 6 | |
525 | 6 | // If the store fails, our buffer is full and ready to hash. We have to |
526 | 6 | // either initialize the hash state (on the first full buffer) or mix |
527 | 6 | // this buffer into the existing hash state. Length tracks the *hashed* |
528 | 6 | // length, not the buffered length. |
529 | 6 | if (length == 06 ) { |
530 | 6 | state = state.create(buffer, seed); |
531 | 6 | length = 64; |
532 | 6 | } else { |
533 | 0 | // Mix this chunk into the current state and bump length up by 64. |
534 | 0 | state.mix(buffer); |
535 | 0 | length += 64; |
536 | 0 | } |
537 | 6 | // Reset the buffer_ptr to the head of the buffer for the next chunk of |
538 | 6 | // data. |
539 | 6 | buffer_ptr = buffer; |
540 | 6 | |
541 | 6 | // Try again to store into the buffer -- this cannot fail as we only |
542 | 6 | // store types smaller than the buffer. |
543 | 6 | if (!store_and_advance(buffer_ptr, buffer_end, data, |
544 | 6 | partial_store_size)) |
545 | 0 | abort(); |
546 | 6 | } |
547 | 1.22G | return buffer_ptr; |
548 | 1.22G | } char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::PointerType*>(unsigned long&, char*, char*, llvm::PointerType*) Line | Count | Source | 516 | 13.3k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 13.3k | if (!store_and_advance(buffer_ptr, buffer_end, data)13.3k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 13.3k | return buffer_ptr; | 548 | 13.3k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type*>(unsigned long&, char*, char*, llvm::Type*) Line | Count | Source | 516 | 70.6M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 70.6M | if (!store_and_advance(buffer_ptr, buffer_end, data)70.6M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 70.6M | return buffer_ptr; | 548 | 70.6M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::VectorType*>(unsigned long&, char*, char*, llvm::VectorType*) Line | Count | Source | 516 | 233k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 233k | if (!store_and_advance(buffer_ptr, buffer_end, data)233k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 233k | return buffer_ptr; | 548 | 233k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::StructType*>(unsigned long&, char*, char*, llvm::StructType*) Line | Count | Source | 516 | 231k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 231k | if (!store_and_advance(buffer_ptr, buffer_end, data)231k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 231k | return buffer_ptr; | 548 | 231k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ArrayType*>(unsigned long&, char*, char*, llvm::ArrayType*) Line | Count | Source | 516 | 45.2k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 45.2k | if (!store_and_advance(buffer_ptr, buffer_end, data)45.2k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 45.2k | return buffer_ptr; | 548 | 45.2k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::FunctionType*>(unsigned long&, char*, char*, llvm::FunctionType*) Line | Count | Source | 516 | 13.3k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 13.3k | if (!store_and_advance(buffer_ptr, buffer_end, data)13.3k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 13.3k | return buffer_ptr; | 548 | 13.3k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::InlineAsm::AsmDialect>(unsigned long&, char*, char*, llvm::InlineAsm::AsmDialect) Line | Count | Source | 516 | 13.3k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 13.3k | if (!store_and_advance(buffer_ptr, buffer_end, data)13.3k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 13.3k | return buffer_ptr; | 548 | 13.3k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Metadata*>(unsigned long&, char*, char*, llvm::Metadata*) Line | Count | Source | 516 | 5.79M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 5.79M | if (!store_and_advance(buffer_ptr, buffer_end, data)5.79M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 5.79M | return buffer_ptr; | 548 | 5.79M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type const*>(unsigned long&, char*, char*, llvm::Type const*) Line | Count | Source | 516 | 8.37M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 8.37M | if (!store_and_advance(buffer_ptr, buffer_end, data)8.37M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 8.37M | return buffer_ptr; | 548 | 8.37M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::DIFile::ChecksumKind>(unsigned long&, char*, char*, llvm::DIFile::ChecksumKind) Line | Count | Source | 516 | 10.5k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 10.5k | if (!store_and_advance(buffer_ptr, buffer_end, data)10.5k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 10.5k | return buffer_ptr; | 548 | 10.5k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned short>(unsigned long&, char*, char*, unsigned short) Line | Count | Source | 516 | 28.0M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 28.0M | if (!store_and_advance(buffer_ptr, buffer_end, data)28.0M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 28.0M | return buffer_ptr; | 548 | 28.0M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDString*>(unsigned long&, char*, char*, llvm::MDString*) Line | Count | Source | 516 | 105k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 105k | if (!store_and_advance(buffer_ptr, buffer_end, data)105k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 105k | return buffer_ptr; | 548 | 105k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned char>(unsigned long&, char*, char*, unsigned char) Line | Count | Source | 516 | 57.9M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 57.9M | if (!store_and_advance(buffer_ptr, buffer_end, data)57.9M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 57.9M | return buffer_ptr; | 548 | 57.9M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long long>(unsigned long&, char*, char*, unsigned long long) Line | Count | Source | 516 | 326M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 326M | if (!store_and_advance(buffer_ptr, buffer_end, data)326M ) { | 518 | 2 | // Check for skew which prevents the buffer from being packed, and do | 519 | 2 | // a partial store into the buffer to fill it. This is only a concern | 520 | 2 | // with the variadic combine because that formation can have varying | 521 | 2 | // argument types. | 522 | 2 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 2 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 2 | | 525 | 2 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 2 | // either initialize the hash state (on the first full buffer) or mix | 527 | 2 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 2 | // length, not the buffered length. | 529 | 2 | if (length == 02 ) { | 530 | 2 | state = state.create(buffer, seed); | 531 | 2 | length = 64; | 532 | 2 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 2 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 2 | // data. | 539 | 2 | buffer_ptr = buffer; | 540 | 2 | | 541 | 2 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 2 | // store types smaller than the buffer. | 543 | 2 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 2 | partial_store_size)) | 545 | 0 | abort(); | 546 | 2 | } | 547 | 326M | return buffer_ptr; | 548 | 326M | } |
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Intrinsic::ID>(unsigned long&, char*, char*, llvm::Intrinsic::ID) char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<int>(unsigned long&, char*, char*, int) Line | Count | Source | 516 | 1.07M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 1.07M | if (!store_and_advance(buffer_ptr, buffer_end, data)1.07M ) { | 518 | 4 | // Check for skew which prevents the buffer from being packed, and do | 519 | 4 | // a partial store into the buffer to fill it. This is only a concern | 520 | 4 | // with the variadic combine because that formation can have varying | 521 | 4 | // argument types. | 522 | 4 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 4 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 4 | | 525 | 4 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 4 | // either initialize the hash state (on the first full buffer) or mix | 527 | 4 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 4 | // length, not the buffered length. | 529 | 4 | if (length == 04 ) { | 530 | 4 | state = state.create(buffer, seed); | 531 | 4 | length = 64; | 532 | 4 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 4 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 4 | // data. | 539 | 4 | buffer_ptr = buffer; | 540 | 4 | | 541 | 4 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 4 | // store types smaller than the buffer. | 543 | 4 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 4 | partial_store_size)) | 545 | 0 | abort(); | 546 | 4 | } | 547 | 1.07M | return buffer_ptr; | 548 | 1.07M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int const*>(unsigned long&, char*, char*, unsigned int const*) Line | Count | Source | 516 | 2 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 2 | if (!store_and_advance(buffer_ptr, buffer_end, data)2 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 2 | return buffer_ptr; | 548 | 2 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantFP const*>(unsigned long&, char*, char*, llvm::ConstantFP const*) Line | Count | Source | 516 | 225 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 225 | if (!store_and_advance(buffer_ptr, buffer_end, data)225 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 225 | return buffer_ptr; | 548 | 225 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantInt const*>(unsigned long&, char*, char*, llvm::ConstantInt const*) Line | Count | Source | 516 | 1 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 1 | if (!store_and_advance(buffer_ptr, buffer_end, data)1 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 1 | return buffer_ptr; | 548 | 1 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long long>(unsigned long&, char*, char*, long long) Line | Count | Source | 516 | 31.8M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 31.8M | if (!store_and_advance(buffer_ptr, buffer_end, data)31.8M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 31.8M | return buffer_ptr; | 548 | 31.8M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineOperand::MachineOperandType>(unsigned long&, char*, char*, llvm::MachineOperand::MachineOperandType) Line | Count | Source | 516 | 75.5M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 75.5M | if (!store_and_advance(buffer_ptr, buffer_end, data)75.5M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 75.5M | return buffer_ptr; | 548 | 75.5M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineBasicBlock*>(unsigned long&, char*, char*, llvm::MachineBasicBlock*) Line | Count | Source | 516 | 2.66M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 2.66M | if (!store_and_advance(buffer_ptr, buffer_end, data)2.66M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 2.66M | return buffer_ptr; | 548 | 2.66M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol*>(unsigned long&, char*, char*, llvm::MCSymbol*) Line | Count | Source | 516 | 153 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 153 | if (!store_and_advance(buffer_ptr, buffer_end, data)153 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 153 | return buffer_ptr; | 548 | 153 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BlockAddress const*>(unsigned long&, char*, char*, llvm::BlockAddress const*) Line | Count | Source | 516 | 353 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 353 | if (!store_and_advance(buffer_ptr, buffer_end, data)353 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 353 | return buffer_ptr; | 548 | 353 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::GlobalValue const*>(unsigned long&, char*, char*, llvm::GlobalValue const*) Line | Count | Source | 516 | 6.77M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 6.77M | if (!store_and_advance(buffer_ptr, buffer_end, data)6.77M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 6.77M | return buffer_ptr; | 548 | 6.77M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<char const*>(unsigned long&, char*, char*, char const*) Line | Count | Source | 516 | 5.40k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 5.40k | if (!store_and_advance(buffer_ptr, buffer_end, data)5.40k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 5.40k | return buffer_ptr; | 548 | 5.40k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Loop const*>(unsigned long&, char*, char*, llvm::Loop const*) Line | Count | Source | 516 | 2.94M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 2.94M | if (!store_and_advance(buffer_ptr, buffer_end, data)2.94M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 2.94M | return buffer_ptr; | 548 | 2.94M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BasicBlock*>(unsigned long&, char*, char*, llvm::BasicBlock*) Line | Count | Source | 516 | 2.94M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 2.94M | if (!store_and_advance(buffer_ptr, buffer_end, data)2.94M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 2.94M | return buffer_ptr; | 548 | 2.94M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long>(unsigned long&, char*, char*, unsigned long) Line | Count | Source | 516 | 154M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 154M | if (!store_and_advance(buffer_ptr, buffer_end, data)154M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 154M | return buffer_ptr; | 548 | 154M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<bool>(unsigned long&, char*, char*, bool) Line | Count | Source | 516 | 54.6M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 54.6M | if (!store_and_advance(buffer_ptr, buffer_end, data)54.6M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 54.6M | return buffer_ptr; | 548 | 54.6M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int>(unsigned long&, char*, char*, unsigned int) Line | Count | Source | 516 | 272M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 272M | if (!store_and_advance(buffer_ptr, buffer_end, data)272M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 272M | return buffer_ptr; | 548 | 272M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol const*>(unsigned long&, char*, char*, llvm::MCSymbol const*) Line | Count | Source | 516 | 11.2k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 11.2k | if (!store_and_advance(buffer_ptr, buffer_end, data)11.2k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 11.2k | return buffer_ptr; | 548 | 11.2k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::BinaryOps>(unsigned long&, char*, char*, llvm::Instruction::BinaryOps) Line | Count | Source | 516 | 10.5M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 10.5M | if (!store_and_advance(buffer_ptr, buffer_end, data)10.5M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 10.5M | return buffer_ptr; | 548 | 10.5M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Value*>(unsigned long&, char*, char*, llvm::Value*) Line | Count | Source | 516 | 71.0M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 71.0M | if (!store_and_advance(buffer_ptr, buffer_end, data)71.0M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 71.0M | return buffer_ptr; | 548 | 71.0M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::CmpInst::Predicate>(unsigned long&, char*, char*, llvm::CmpInst::Predicate) Line | Count | Source | 516 | 19.4M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 19.4M | if (!store_and_advance(buffer_ptr, buffer_end, data)19.4M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 19.4M | return buffer_ptr; | 548 | 19.4M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::CastOps>(unsigned long&, char*, char*, llvm::Instruction::CastOps) Line | Count | Source | 516 | 10.8M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 10.8M | if (!store_and_advance(buffer_ptr, buffer_end, data)10.8M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 10.8M | return buffer_ptr; | 548 | 10.8M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction*>(unsigned long&, char*, char*, llvm::Instruction*) Line | Count | Source | 516 | 324 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 324 | if (!store_and_advance(buffer_ptr, buffer_end, data)324 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 324 | return buffer_ptr; | 548 | 324 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Constant*>(unsigned long&, char*, char*, llvm::Constant*) Line | Count | Source | 516 | 437 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 437 | if (!store_and_advance(buffer_ptr, buffer_end, data)437 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 437 | return buffer_ptr; | 548 | 437 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MemoryAccess const*>(unsigned long&, char*, char*, llvm::MemoryAccess const*) Line | Count | Source | 516 | 1.12k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 1.12k | if (!store_and_advance(buffer_ptr, buffer_end, data)1.12k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 1.12k | return buffer_ptr; | 548 | 1.12k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<short>(unsigned long&, char*, char*, short) Line | Count | Source | 516 | 766k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 766k | if (!store_and_advance(buffer_ptr, buffer_end, data)766k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 766k | return buffer_ptr; | 548 | 766k | } |
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::fltSemantics const*>(unsigned long&, char*, char*, llvm::fltSemantics const*) char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<clang::NestedNameSpecifier*>(unsigned long&, char*, char*, clang::NestedNameSpecifier*) Line | Count | Source | 516 | 270 | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 270 | if (!store_and_advance(buffer_ptr, buffer_end, data)270 ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 270 | return buffer_ptr; | 548 | 270 | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<void*>(unsigned long&, char*, char*, void*) Line | Count | Source | 516 | 9.42k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 9.42k | if (!store_and_advance(buffer_ptr, buffer_end, data)9.42k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 9.42k | return buffer_ptr; | 548 | 9.42k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::coverage::Counter::CounterKind>(unsigned long&, char*, char*, llvm::coverage::Counter::CounterKind) Line | Count | Source | 516 | 3.17k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 3.17k | if (!store_and_advance(buffer_ptr, buffer_end, data)3.17k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 3.17k | return buffer_ptr; | 548 | 3.17k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::coverage::CounterExpression::ExprKind>(unsigned long&, char*, char*, llvm::coverage::CounterExpression::ExprKind) Line | Count | Source | 516 | 1.58k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 1.58k | if (!store_and_advance(buffer_ptr, buffer_end, data)1.58k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 1.58k | return buffer_ptr; | 548 | 1.58k | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::RegisterBankInfo::ValueMapping const*>(unsigned long&, char*, char*, llvm::RegisterBankInfo::ValueMapping const*) Line | Count | Source | 516 | 7.22M | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 7.22M | if (!store_and_advance(buffer_ptr, buffer_end, data)7.22M ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 7.22M | return buffer_ptr; | 548 | 7.22M | } |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long>(unsigned long&, char*, char*, long) Line | Count | Source | 516 | 59.0k | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) { | 517 | 59.0k | if (!store_and_advance(buffer_ptr, buffer_end, data)59.0k ) { | 518 | 0 | // Check for skew which prevents the buffer from being packed, and do | 519 | 0 | // a partial store into the buffer to fill it. This is only a concern | 520 | 0 | // with the variadic combine because that formation can have varying | 521 | 0 | // argument types. | 522 | 0 | size_t partial_store_size = buffer_end - buffer_ptr; | 523 | 0 | memcpy(buffer_ptr, &data, partial_store_size); | 524 | 0 |
| 525 | 0 | // If the store fails, our buffer is full and ready to hash. We have to | 526 | 0 | // either initialize the hash state (on the first full buffer) or mix | 527 | 0 | // this buffer into the existing hash state. Length tracks the *hashed* | 528 | 0 | // length, not the buffered length. | 529 | 0 | if (length == 00 ) { | 530 | 0 | state = state.create(buffer, seed); | 531 | 0 | length = 64; | 532 | 0 | } else { | 533 | 0 | // Mix this chunk into the current state and bump length up by 64. | 534 | 0 | state.mix(buffer); | 535 | 0 | length += 64; | 536 | 0 | } | 537 | 0 | // Reset the buffer_ptr to the head of the buffer for the next chunk of | 538 | 0 | // data. | 539 | 0 | buffer_ptr = buffer; | 540 | 0 |
| 541 | 0 | // Try again to store into the buffer -- this cannot fail as we only | 542 | 0 | // store types smaller than the buffer. | 543 | 0 | if (!store_and_advance(buffer_ptr, buffer_end, data, | 544 | 0 | partial_store_size)) | 545 | 0 | abort(); | 546 | 0 | } | 547 | 59.0k | return buffer_ptr; | 548 | 59.0k | } |
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDNode const*>(unsigned long&, char*, char*, llvm::MDNode const*) |
549 | | |
550 | | /// \brief Recursive, variadic combining method. |
551 | | /// |
552 | | /// This function recurses through each argument, combining that argument |
553 | | /// into a single hash. |
554 | | template <typename T, typename ...Ts> |
555 | | hash_code combine(size_t length, char *buffer_ptr, char *buffer_end, |
556 | 1.22G | const T &arg, const Ts &...args) { |
557 | 1.22G | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); |
558 | 1.22G | |
559 | 1.22G | // Recurse to the next argument. |
560 | 1.22G | return combine(length, buffer_ptr, buffer_end, args...); |
561 | 1.22G | } llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned long long>(unsigned long, char*, char*, unsigned long long const&) Line | Count | Source | 556 | 326M | const T &arg, const Ts &...args) { | 557 | 326M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 326M | | 559 | 326M | // Recurse to the next argument. | 560 | 326M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 326M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<void*>(unsigned long, char*, char*, void* const&) Line | Count | Source | 556 | 4.84k | const T &arg, const Ts &...args) { | 557 | 4.84k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.84k | | 559 | 4.84k | // Recurse to the next argument. | 560 | 4.84k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.84k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<clang::NestedNameSpecifier*, void*>(unsigned long, char*, char*, clang::NestedNameSpecifier* const&, void* const&) Line | Count | Source | 556 | 270 | const T &arg, const Ts &...args) { | 557 | 270 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 270 | | 559 | 270 | // Recurse to the next argument. | 560 | 270 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 270 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<void*, void*>(unsigned long, char*, char*, void* const&, void* const&) Line | Count | Source | 556 | 4.57k | const T &arg, const Ts &...args) { | 557 | 4.57k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.57k | | 559 | 4.57k | // Recurse to the next argument. | 560 | 4.57k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.57k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&) Line | Count | Source | 556 | 1.58k | const T &arg, const Ts &...args) { | 557 | 1.58k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.58k | | 559 | 1.58k | // Recurse to the next argument. | 560 | 1.58k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.58k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::Counter::CounterKind const&, unsigned int const&) Line | Count | Source | 556 | 1.58k | const T &arg, const Ts &...args) { | 557 | 1.58k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.58k | | 559 | 1.58k | // Recurse to the next argument. | 560 | 1.58k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.58k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::Counter::CounterKind, unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::Counter::CounterKind const&, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&) Line | Count | Source | 556 | 1.58k | const T &arg, const Ts &...args) { | 557 | 1.58k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.58k | | 559 | 1.58k | // Recurse to the next argument. | 560 | 1.58k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.58k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::CounterExpression::ExprKind, llvm::coverage::Counter::CounterKind, unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::CounterExpression::ExprKind const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&) Line | Count | Source | 556 | 1.58k | const T &arg, const Ts &...args) { | 557 | 1.58k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.58k | | 559 | 1.58k | // Recurse to the next argument. | 560 | 1.58k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.58k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::StringRef>(unsigned long, char*, char*, llvm::hash_code const&, llvm::StringRef const&) Line | Count | Source | 556 | 14 | const T &arg, const Ts &...args) { | 557 | 14 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 14 | | 559 | 14 | // Recurse to the next argument. | 560 | 14 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 14 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StringRef>(unsigned long, char*, char*, llvm::StringRef const&) Line | Count | Source | 556 | 170 | const T &arg, const Ts &...args) { | 557 | 170 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 170 | | 559 | 170 | // Recurse to the next argument. | 560 | 170 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 170 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(unsigned long, char*, char*, llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 556 | 3.26k | const T &arg, const Ts &...args) { | 557 | 3.26k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.26k | | 559 | 3.26k | // Recurse to the next argument. | 560 | 3.26k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.26k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 556 | 6.99k | const T &arg, const Ts &...args) { | 557 | 6.99k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 6.99k | | 559 | 6.99k | // Recurse to the next argument. | 560 | 6.99k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 6.99k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(unsigned long, char*, char*, llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 556 | 3.73k | const T &arg, const Ts &...args) { | 557 | 3.73k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.73k | | 559 | 3.73k | // Recurse to the next argument. | 560 | 3.73k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.73k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::hash_code const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool>(unsigned long, char*, char*, llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, bool const&) Line | Count | Source | 556 | 1.18k | const T &arg, const Ts &...args) { | 557 | 1.18k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.18k | | 559 | 1.18k | // Recurse to the next argument. | 560 | 1.18k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.18k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool>(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, bool const&) Line | Count | Source | 556 | 1.18k | const T &arg, const Ts &...args) { | 557 | 1.18k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.18k | | 559 | 1.18k | // Recurse to the next argument. | 560 | 1.18k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.18k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 1.85k | const T &arg, const Ts &...args) { | 557 | 1.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.85k | | 559 | 1.85k | // Recurse to the next argument. | 560 | 1.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 5.82M | const T &arg, const Ts &...args) { | 557 | 5.82M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.82M | | 559 | 5.82M | // Recurse to the next argument. | 560 | 5.82M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.82M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, unsigned long long>(unsigned long, char*, char*, llvm::hash_code const&, unsigned long long const&) Line | Count | Source | 556 | 3 | const T &arg, const Ts &...args) { | 557 | 3 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3 | | 559 | 3 | // Recurse to the next argument. | 560 | 3 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::RegisterBankInfo::ValueMapping const*, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned int const&) Line | Count | Source | 556 | 7.22M | const T &arg, const Ts &...args) { | 557 | 7.22M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 7.22M | | 559 | 7.22M | // Recurse to the next argument. | 560 | 7.22M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 7.22M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::RegisterBankInfo::ValueMapping const*, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned int const&) Line | Count | Source | 556 | 7.22M | const T &arg, const Ts &...args) { | 557 | 7.22M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 7.22M | | 559 | 7.22M | // Recurse to the next argument. | 560 | 7.22M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 7.22M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::RegisterBankInfo::ValueMapping const*, unsigned int>(unsigned long, char*, char*, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned int const&) Line | Count | Source | 556 | 7.22M | const T &arg, const Ts &...args) { | 557 | 7.22M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 7.22M | | 559 | 7.22M | // Recurse to the next argument. | 560 | 7.22M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 7.22M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, long>(unsigned long, char*, char*, long long const&, long const&) Line | Count | Source | 556 | 59.0k | const T &arg, const Ts &...args) { | 557 | 59.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 59.0k | | 559 | 59.0k | // Recurse to the next argument. | 560 | 59.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 59.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long>(unsigned long, char*, char*, long const&) Line | Count | Source | 556 | 59.0k | const T &arg, const Ts &...args) { | 557 | 59.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 59.0k | | 559 | 59.0k | // Recurse to the next argument. | 560 | 59.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 59.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 1.89k | const T &arg, const Ts &...args) { | 557 | 1.89k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.89k | | 559 | 1.89k | // Recurse to the next argument. | 560 | 1.89k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.89k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&) Line | Count | Source | 556 | 400 | const T &arg, const Ts &...args) { | 557 | 400 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 400 | | 559 | 400 | // Recurse to the next argument. | 560 | 400 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 400 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 12.9k | const T &arg, const Ts &...args) { | 557 | 12.9k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 12.9k | | 559 | 12.9k | // Recurse to the next argument. | 560 | 12.9k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 12.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&) Line | Count | Source | 556 | 32.4k | const T &arg, const Ts &...args) { | 557 | 32.4k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 32.4k | | 559 | 32.4k | // Recurse to the next argument. | 560 | 32.4k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 32.4k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::MDString*, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 127 | const T &arg, const Ts &...args) { | 557 | 127 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 127 | | 559 | 127 | // Recurse to the next argument. | 560 | 127 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 127 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 114 | const T &arg, const Ts &...args) { | 557 | 114 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 114 | | 559 | 114 | // Recurse to the next argument. | 560 | 114 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 114 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 471 | const T &arg, const Ts &...args) { | 557 | 471 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 471 | | 559 | 471 | // Recurse to the next argument. | 560 | 471 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 471 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.81M | const T &arg, const Ts &...args) { | 557 | 2.81M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.81M | | 559 | 2.81M | // Recurse to the next argument. | 560 | 2.81M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.81M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::DIFile::ChecksumKind, llvm::MDString*>(unsigned long, char*, char*, llvm::DIFile::ChecksumKind const&, llvm::MDString* const&) Line | Count | Source | 556 | 10.5k | const T &arg, const Ts &...args) { | 557 | 10.5k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.5k | | 559 | 10.5k | // Recurse to the next argument. | 560 | 10.5k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.5k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::DIFile::ChecksumKind, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::DIFile::ChecksumKind const&, llvm::MDString* const&) Line | Count | Source | 556 | 10.5k | const T &arg, const Ts &...args) { | 557 | 10.5k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.5k | | 559 | 10.5k | // Recurse to the next argument. | 560 | 10.5k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.5k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::DIFile::ChecksumKind, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::DIFile::ChecksumKind const&, llvm::MDString* const&) Line | Count | Source | 556 | 10.5k | const T &arg, const Ts &...args) { | 557 | 10.5k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.5k | | 559 | 10.5k | // Recurse to the next argument. | 560 | 10.5k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.5k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type const*, llvm::hash_code, bool>(unsigned long, char*, char*, llvm::Type const* const&, llvm::hash_code const&, bool const&) Line | Count | Source | 556 | 8.37M | const T &arg, const Ts &...args) { | 557 | 8.37M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 8.37M | | 559 | 8.37M | // Recurse to the next argument. | 560 | 8.37M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 8.37M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.82M | const T &arg, const Ts &...args) { | 557 | 2.82M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.82M | | 559 | 2.82M | // Recurse to the next argument. | 560 | 2.82M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.82M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::fltSemantics const*>(unsigned long, char*, char*, llvm::fltSemantics const* const&) llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<short, llvm::hash_code>(unsigned long, char*, char*, short const&, llvm::hash_code const&) Line | Count | Source | 556 | 766k | const T &arg, const Ts &...args) { | 557 | 766k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 766k | | 559 | 766k | // Recurse to the next argument. | 560 | 766k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 766k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, short, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, short const&, llvm::hash_code const&) Line | Count | Source | 556 | 766k | const T &arg, const Ts &...args) { | 557 | 766k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 766k | | 559 | 766k | // Recurse to the next argument. | 560 | 766k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 766k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned int, short, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned int const&, short const&, llvm::hash_code const&) Line | Count | Source | 556 | 766k | const T &arg, const Ts &...args) { | 557 | 766k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 766k | | 559 | 766k | // Recurse to the next argument. | 560 | 766k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 766k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned char, unsigned int, short, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned char const&, unsigned int const&, short const&, llvm::hash_code const&) Line | Count | Source | 556 | 766k | const T &arg, const Ts &...args) { | 557 | 766k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 766k | | 559 | 766k | // Recurse to the next argument. | 560 | 766k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 766k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned int>(unsigned long, char*, char*, unsigned char const&, unsigned int const&) Line | Count | Source | 556 | 118k | const T &arg, const Ts &...args) { | 557 | 118k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 118k | | 559 | 118k | // Recurse to the next argument. | 560 | 118k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 118k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned char, unsigned int>(unsigned long, char*, char*, unsigned char const&, unsigned char const&, unsigned int const&) Line | Count | Source | 556 | 118k | const T &arg, const Ts &...args) { | 557 | 118k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 118k | | 559 | 118k | // Recurse to the next argument. | 560 | 118k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 118k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::MemoryAccess const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::MemoryAccess const* const&) Line | Count | Source | 556 | 1.12k | const T &arg, const Ts &...args) { | 557 | 1.12k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.12k | | 559 | 1.12k | // Recurse to the next argument. | 560 | 1.12k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.12k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MemoryAccess const*>(unsigned long, char*, char*, llvm::MemoryAccess const* const&) Line | Count | Source | 556 | 1.12k | const T &arg, const Ts &...args) { | 557 | 1.12k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.12k | | 559 | 1.12k | // Recurse to the next argument. | 560 | 1.12k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.12k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::BasicBlock*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::BasicBlock* const&) Line | Count | Source | 556 | 236 | const T &arg, const Ts &...args) { | 557 | 236 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 236 | | 559 | 236 | // Recurse to the next argument. | 560 | 236 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 236 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Constant*>(unsigned long, char*, char*, llvm::Constant* const&) Line | Count | Source | 556 | 437 | const T &arg, const Ts &...args) { | 557 | 437 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 437 | | 559 | 437 | // Recurse to the next argument. | 560 | 437 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 437 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::Constant*>(unsigned long, char*, char*, llvm::Type* const&, llvm::Constant* const&) Line | Count | Source | 556 | 437 | const T &arg, const Ts &...args) { | 557 | 437 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 437 | | 559 | 437 | // Recurse to the next argument. | 560 | 437 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 437 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::Constant*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::Constant* const&) Line | Count | Source | 556 | 437 | const T &arg, const Ts &...args) { | 557 | 437 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 437 | | 559 | 437 | // Recurse to the next argument. | 560 | 437 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 437 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::Value* const&) Line | Count | Source | 556 | 50 | const T &arg, const Ts &...args) { | 557 | 50 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 50 | | 559 | 50 | // Recurse to the next argument. | 560 | 50 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 50 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction*>(unsigned long, char*, char*, llvm::Instruction* const&) Line | Count | Source | 556 | 324 | const T &arg, const Ts &...args) { | 557 | 324 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 324 | | 559 | 324 | // Recurse to the next argument. | 560 | 324 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 324 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85M | const T &arg, const Ts &...args) { | 557 | 2.85M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85M | | 559 | 2.85M | // Recurse to the next argument. | 560 | 2.85M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Instruction*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Instruction* const&) Line | Count | Source | 556 | 324 | const T &arg, const Ts &...args) { | 557 | 324 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 324 | | 559 | 324 | // Recurse to the next argument. | 560 | 324 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 324 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, unsigned int>(unsigned long, char*, char*, llvm::hash_code const&, unsigned int const&) Line | Count | Source | 556 | 217k | const T &arg, const Ts &...args) { | 557 | 217k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 217k | | 559 | 217k | // Recurse to the next argument. | 560 | 217k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 217k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, unsigned long long, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, unsigned long long const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 2.44k | const T &arg, const Ts &...args) { | 557 | 2.44k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.44k | | 559 | 2.44k | // Recurse to the next argument. | 560 | 2.44k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.44k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, unsigned long long, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, unsigned long long const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 2.44k | const T &arg, const Ts &...args) { | 557 | 2.44k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.44k | | 559 | 2.44k | // Recurse to the next argument. | 560 | 2.44k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.44k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 12.9k | const T &arg, const Ts &...args) { | 557 | 12.9k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 12.9k | | 559 | 12.9k | // Recurse to the next argument. | 560 | 12.9k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 12.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 556 | 40.9M | const T &arg, const Ts &...args) { | 557 | 40.9M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 40.9M | | 559 | 40.9M | // Recurse to the next argument. | 560 | 40.9M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 40.9M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 12.9k | const T &arg, const Ts &...args) { | 557 | 12.9k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 12.9k | | 559 | 12.9k | // Recurse to the next argument. | 560 | 12.9k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 12.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, llvm::MDString*>(unsigned long, char*, char*, long long const&, llvm::MDString* const&) Line | Count | Source | 556 | 17.7k | const T &arg, const Ts &...args) { | 557 | 17.7k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 17.7k | | 559 | 17.7k | // Recurse to the next argument. | 560 | 17.7k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 17.7k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 127 | const T &arg, const Ts &...args) { | 557 | 127 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 127 | | 559 | 127 | // Recurse to the next argument. | 560 | 127 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 127 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 3.30k | const T &arg, const Ts &...args) { | 557 | 3.30k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.30k | | 559 | 3.30k | // Recurse to the next argument. | 560 | 3.30k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.30k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 127 | const T &arg, const Ts &...args) { | 557 | 127 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 127 | | 559 | 127 | // Recurse to the next argument. | 560 | 127 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 127 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 556 | 28.0M | const T &arg, const Ts &...args) { | 557 | 28.0M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 28.0M | | 559 | 28.0M | // Recurse to the next argument. | 560 | 28.0M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 28.0M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 1.16k | const T &arg, const Ts &...args) { | 557 | 1.16k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.16k | | 559 | 1.16k | // Recurse to the next argument. | 560 | 1.16k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.16k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 1.16k | const T &arg, const Ts &...args) { | 557 | 1.16k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.16k | | 559 | 1.16k | // Recurse to the next argument. | 560 | 1.16k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.16k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.85k | const T &arg, const Ts &...args) { | 557 | 2.85k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.85k | | 559 | 2.85k | // Recurse to the next argument. | 560 | 2.85k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.85k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 556 | 28.0M | const T &arg, const Ts &...args) { | 557 | 28.0M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 28.0M | | 559 | 28.0M | // Recurse to the next argument. | 560 | 28.0M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 28.0M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, long long>(unsigned long, char*, char*, long long const&, long long const&) Line | Count | Source | 556 | 718 | const T &arg, const Ts &...args) { | 557 | 718 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 718 | | 559 | 718 | // Recurse to the next argument. | 560 | 718 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 718 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 14.6k | const T &arg, const Ts &...args) { | 557 | 14.6k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 14.6k | | 559 | 14.6k | // Recurse to the next argument. | 560 | 14.6k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 14.6k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 14.6k | const T &arg, const Ts &...args) { | 557 | 14.6k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 14.6k | | 559 | 14.6k | // Recurse to the next argument. | 560 | 14.6k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 14.6k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 3.91k | const T &arg, const Ts &...args) { | 557 | 3.91k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.91k | | 559 | 3.91k | // Recurse to the next argument. | 560 | 3.91k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.91k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 556 | 173 | const T &arg, const Ts &...args) { | 557 | 173 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 173 | | 559 | 173 | // Recurse to the next argument. | 560 | 173 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 173 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 12.9k | const T &arg, const Ts &...args) { | 557 | 12.9k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 12.9k | | 559 | 12.9k | // Recurse to the next argument. | 560 | 12.9k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 12.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 12.9k | const T &arg, const Ts &...args) { | 557 | 12.9k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 12.9k | | 559 | 12.9k | // Recurse to the next argument. | 560 | 12.9k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 12.9k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StringRef, bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, llvm::StringRef const&, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned long long, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned long long const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 2.44k | const T &arg, const Ts &...args) { | 557 | 2.44k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.44k | | 559 | 2.44k | // Recurse to the next argument. | 560 | 2.44k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.44k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StringRef, llvm::StringRef, bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, llvm::StringRef const&, llvm::StringRef const&, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Intrinsic::ID>(unsigned long, char*, char*, llvm::Intrinsic::ID const&) Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Intrinsic::ID>(unsigned long, char*, char*, unsigned int const&, llvm::Intrinsic::ID const&) Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::Intrinsic::ID>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::Intrinsic::ID const&) Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const&) llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MCSymbol*>(unsigned long, char*, char*, unsigned int const&, llvm::MCSymbol* const&) Line | Count | Source | 556 | 151 | const T &arg, const Ts &...args) { | 557 | 151 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 151 | | 559 | 151 | // Recurse to the next argument. | 560 | 151 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 151 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MCSymbol* const&) Line | Count | Source | 556 | 151 | const T &arg, const Ts &...args) { | 557 | 151 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 151 | | 559 | 151 | // Recurse to the next argument. | 560 | 151 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 151 | } |
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDNode const*>(unsigned long, char*, char*, llvm::MDNode const* const&) Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDNode const*>(unsigned long, char*, char*, unsigned int const&, llvm::MDNode const* const&) Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MDNode const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MDNode const* const&) llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int const*>(unsigned long, char*, char*, unsigned int const* const&) Line | Count | Source | 556 | 2 | const T &arg, const Ts &...args) { | 557 | 2 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2 | | 559 | 2 | // Recurse to the next argument. | 560 | 2 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int const*>(unsigned long, char*, char*, unsigned int const&, unsigned int const* const&) Line | Count | Source | 556 | 2 | const T &arg, const Ts &...args) { | 557 | 2 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2 | | 559 | 2 | // Recurse to the next argument. | 560 | 2 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const* const&) Line | Count | Source | 556 | 2 | const T &arg, const Ts &...args) { | 557 | 2 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2 | | 559 | 2 | // Recurse to the next argument. | 560 | 2 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BlockAddress const*, long long>(unsigned long, char*, char*, llvm::BlockAddress const* const&, long long const&) Line | Count | Source | 556 | 343 | const T &arg, const Ts &...args) { | 557 | 343 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 343 | | 559 | 343 | // Recurse to the next argument. | 560 | 343 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 343 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::BlockAddress const*, long long>(unsigned long, char*, char*, unsigned int const&, llvm::BlockAddress const* const&, long long const&) Line | Count | Source | 556 | 343 | const T &arg, const Ts &...args) { | 557 | 343 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 343 | | 559 | 343 | // Recurse to the next argument. | 560 | 343 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 343 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::BlockAddress const*, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::BlockAddress const* const&, long long const&) Line | Count | Source | 556 | 343 | const T &arg, const Ts &...args) { | 557 | 343 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 343 | | 559 | 343 | // Recurse to the next argument. | 560 | 343 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 343 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, unsigned int, bool>(unsigned long, char*, char*, llvm::Type* const&, unsigned int const&, bool const&) Line | Count | Source | 556 | 130 | const T &arg, const Ts &...args) { | 557 | 130 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 130 | | 559 | 130 | // Recurse to the next argument. | 560 | 130 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 130 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Type*, unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, llvm::Type* const&, unsigned int const&, bool const&) Line | Count | Source | 556 | 130 | const T &arg, const Ts &...args) { | 557 | 130 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 130 | | 559 | 130 | // Recurse to the next argument. | 560 | 130 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 130 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::hash_code const&) Line | Count | Source | 556 | 2.24k | const T &arg, const Ts &...args) { | 557 | 2.24k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.24k | | 559 | 2.24k | // Recurse to the next argument. | 560 | 2.24k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.24k | } |
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, unsigned int, bool>(unsigned long, char*, char*, llvm::hash_code const&, unsigned int const&, bool const&) llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, llvm::Type* const&, llvm::hash_code const&) Line | Count | Source | 556 | 31.7M | const T &arg, const Ts &...args) { | 557 | 31.7M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 31.7M | | 559 | 31.7M | // Recurse to the next argument. | 560 | 31.7M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 31.7M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 61 | const T &arg, const Ts &...args) { | 557 | 61 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 61 | | 559 | 61 | // Recurse to the next argument. | 560 | 61 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 61 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Type* const&, llvm::hash_code const&) Line | Count | Source | 556 | 31.7M | const T &arg, const Ts &...args) { | 557 | 31.7M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 31.7M | | 559 | 31.7M | // Recurse to the next argument. | 560 | 31.7M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 31.7M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, llvm::Value* const&, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 556 | 29.0k | const T &arg, const Ts &...args) { | 557 | 29.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 29.0k | | 559 | 29.0k | // Recurse to the next argument. | 560 | 29.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 29.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Value*, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Value* const&, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 556 | 29.0k | const T &arg, const Ts &...args) { | 557 | 29.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 29.0k | | 559 | 29.0k | // Recurse to the next argument. | 560 | 29.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 29.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 556 | 277k | const T &arg, const Ts &...args) { | 557 | 277k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 277k | | 559 | 277k | // Recurse to the next argument. | 560 | 277k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 277k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 556 | 248k | const T &arg, const Ts &...args) { | 557 | 248k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 248k | | 559 | 248k | // Recurse to the next argument. | 560 | 248k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 248k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::Type* const&, llvm::Value* const&) Line | Count | Source | 556 | 10.8M | const T &arg, const Ts &...args) { | 557 | 10.8M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.8M | | 559 | 10.8M | // Recurse to the next argument. | 560 | 10.8M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.8M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction::CastOps, llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::Instruction::CastOps const&, llvm::Type* const&, llvm::Value* const&) Line | Count | Source | 556 | 10.8M | const T &arg, const Ts &...args) { | 557 | 10.8M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.8M | | 559 | 10.8M | // Recurse to the next argument. | 560 | 10.8M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.8M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::CmpInst::Predicate const&, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 556 | 19.4M | const T &arg, const Ts &...args) { | 557 | 19.4M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 19.4M | | 559 | 19.4M | // Recurse to the next argument. | 560 | 19.4M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 19.4M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, unsigned int const&, llvm::CmpInst::Predicate const&, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 556 | 19.4M | const T &arg, const Ts &...args) { | 557 | 19.4M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 19.4M | | 559 | 19.4M | // Recurse to the next argument. | 560 | 19.4M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 19.4M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&) Line | Count | Source | 556 | 40.8M | const T &arg, const Ts &...args) { | 557 | 40.8M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 40.8M | | 559 | 40.8M | // Recurse to the next argument. | 560 | 40.8M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 40.8M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 556 | 29.9M | const T &arg, const Ts &...args) { | 557 | 29.9M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 29.9M | | 559 | 29.9M | // Recurse to the next argument. | 560 | 29.9M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 29.9M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::Instruction::BinaryOps const&, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 556 | 10.5M | const T &arg, const Ts &...args) { | 557 | 10.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10.5M | | 559 | 10.5M | // Recurse to the next argument. | 560 | 10.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, unsigned int>(unsigned long, char*, char*, bool const&, bool const&, unsigned int const&) Line | Count | Source | 556 | 11.2k | const T &arg, const Ts &...args) { | 557 | 11.2k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 11.2k | | 559 | 11.2k | // Recurse to the next argument. | 560 | 11.2k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 11.2k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, unsigned int const&, bool const&, bool const&, unsigned int const&) Line | Count | Source | 556 | 11.2k | const T &arg, const Ts &...args) { | 557 | 11.2k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 11.2k | | 559 | 11.2k | // Recurse to the next argument. | 560 | 11.2k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 11.2k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&) Line | Count | Source | 556 | 11.2k | const T &arg, const Ts &...args) { | 557 | 11.2k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 11.2k | | 559 | 11.2k | // Recurse to the next argument. | 560 | 11.2k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 11.2k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol const*, unsigned int, unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, llvm::MCSymbol const* const&, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&) Line | Count | Source | 556 | 11.2k | const T &arg, const Ts &...args) { | 557 | 11.2k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 11.2k | | 559 | 11.2k | // Recurse to the next argument. | 560 | 11.2k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 11.2k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::PointerType*, unsigned int>(unsigned long, char*, char*, llvm::PointerType* const&, unsigned int const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, unsigned int>(unsigned long, char*, char*, llvm::Type* const&, unsigned int const&) Line | Count | Source | 556 | 28.0M | const T &arg, const Ts &...args) { | 557 | 28.0M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 28.0M | | 559 | 28.0M | // Recurse to the next argument. | 560 | 28.0M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 28.0M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::VectorType*, unsigned int>(unsigned long, char*, char*, llvm::VectorType* const&, unsigned int const&) Line | Count | Source | 556 | 233k | const T &arg, const Ts &...args) { | 557 | 233k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 233k | | 559 | 233k | // Recurse to the next argument. | 560 | 233k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 233k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StructType*, unsigned int>(unsigned long, char*, char*, llvm::StructType* const&, unsigned int const&) Line | Count | Source | 556 | 231k | const T &arg, const Ts &...args) { | 557 | 231k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 231k | | 559 | 231k | // Recurse to the next argument. | 560 | 231k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 231k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ArrayType*, unsigned int>(unsigned long, char*, char*, llvm::ArrayType* const&, unsigned int const&) Line | Count | Source | 556 | 45.2k | const T &arg, const Ts &...args) { | 557 | 45.2k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 45.2k | | 559 | 45.2k | // Recurse to the next argument. | 560 | 45.2k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 45.2k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 4.64k | const T &arg, const Ts &...args) { | 557 | 4.64k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.64k | | 559 | 4.64k | // Recurse to the next argument. | 560 | 4.64k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.64k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 4.64k | const T &arg, const Ts &...args) { | 557 | 4.64k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.64k | | 559 | 4.64k | // Recurse to the next argument. | 560 | 4.64k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.64k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 3.18k | const T &arg, const Ts &...args) { | 557 | 3.18k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.18k | | 559 | 3.18k | // Recurse to the next argument. | 560 | 3.18k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.18k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 556 | 3.18k | const T &arg, const Ts &...args) { | 557 | 3.18k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 3.18k | | 559 | 3.18k | // Recurse to the next argument. | 560 | 3.18k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 3.18k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 4.64k | const T &arg, const Ts &...args) { | 557 | 4.64k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.64k | | 559 | 4.64k | // Recurse to the next argument. | 560 | 4.64k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.64k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 4.64k | const T &arg, const Ts &...args) { | 557 | 4.64k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.64k | | 559 | 4.64k | // Recurse to the next argument. | 560 | 4.64k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.64k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 357 | const T &arg, const Ts &...args) { | 557 | 357 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 357 | | 559 | 357 | // Recurse to the next argument. | 560 | 357 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 357 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned char, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, unsigned char const&, llvm::Metadata* const&) Line | Count | Source | 556 | 30.5k | const T &arg, const Ts &...args) { | 557 | 30.5k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 30.5k | | 559 | 30.5k | // Recurse to the next argument. | 560 | 30.5k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 30.5k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 2.81M | const T &arg, const Ts &...args) { | 557 | 2.81M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.81M | | 559 | 2.81M | // Recurse to the next argument. | 560 | 2.81M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.81M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 357 | const T &arg, const Ts &...args) { | 557 | 357 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 357 | | 559 | 357 | // Recurse to the next argument. | 560 | 357 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 357 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 556 | 4.64k | const T &arg, const Ts &...args) { | 557 | 4.64k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 4.64k | | 559 | 4.64k | // Recurse to the next argument. | 560 | 4.64k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 4.64k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 357 | const T &arg, const Ts &...args) { | 557 | 357 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 357 | | 559 | 357 | // Recurse to the next argument. | 560 | 357 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 357 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 556 | 357 | const T &arg, const Ts &...args) { | 557 | 357 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 357 | | 559 | 357 | // Recurse to the next argument. | 560 | 357 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 357 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, llvm::Metadata*>(unsigned long, char*, char*, unsigned char const&, llvm::Metadata* const&) Line | Count | Source | 556 | 30.5k | const T &arg, const Ts &...args) { | 557 | 30.5k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 30.5k | | 559 | 30.5k | // Recurse to the next argument. | 560 | 30.5k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 30.5k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 14.6k | const T &arg, const Ts &...args) { | 557 | 14.6k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 14.6k | | 559 | 14.6k | // Recurse to the next argument. | 560 | 14.6k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 14.6k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 14.6k | const T &arg, const Ts &...args) { | 557 | 14.6k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 14.6k | | 559 | 14.6k | // Recurse to the next argument. | 560 | 14.6k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 14.6k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::FunctionType*>(unsigned long, char*, char*, llvm::FunctionType* const&) Line | Count | Source | 556 | 13.3k | const T &arg, const Ts &...args) { | 557 | 13.3k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 13.3k | | 559 | 13.3k | // Recurse to the next argument. | 560 | 13.3k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 13.3k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 18.0k | const T &arg, const Ts &...args) { | 557 | 18.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 18.0k | | 559 | 18.0k | // Recurse to the next argument. | 560 | 18.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 18.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 18.0k | const T &arg, const Ts &...args) { | 557 | 18.0k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 18.0k | | 559 | 18.0k | // Recurse to the next argument. | 560 | 18.0k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 18.0k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 556 | 1.89k | const T &arg, const Ts &...args) { | 557 | 1.89k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1.89k | | 559 | 1.89k | // Recurse to the next argument. | 560 | 1.89k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1.89k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned char, unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned char const&, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 556 | 28.0M | const T &arg, const Ts &...args) { | 557 | 28.0M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 28.0M | | 559 | 28.0M | // Recurse to the next argument. | 560 | 28.0M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 28.0M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::GlobalValue const*, long long>(unsigned long, char*, char*, llvm::GlobalValue const* const&, long long const&) Line | Count | Source | 556 | 6.75M | const T &arg, const Ts &...args) { | 557 | 6.75M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 6.75M | | 559 | 6.75M | // Recurse to the next argument. | 560 | 6.75M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 6.75M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::GlobalValue const*, long long>(unsigned long, char*, char*, unsigned int const&, llvm::GlobalValue const* const&, long long const&) Line | Count | Source | 556 | 6.75M | const T &arg, const Ts &...args) { | 557 | 6.75M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 6.75M | | 559 | 6.75M | // Recurse to the next argument. | 560 | 6.75M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 6.75M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::GlobalValue const*, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::GlobalValue const* const&, long long const&) Line | Count | Source | 556 | 6.75M | const T &arg, const Ts &...args) { | 557 | 6.75M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 6.75M | | 559 | 6.75M | // Recurse to the next argument. | 560 | 6.75M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 6.75M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, char const*>(unsigned long, char*, char*, long long const&, char const* const&) Line | Count | Source | 556 | 5.40k | const T &arg, const Ts &...args) { | 557 | 5.40k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.40k | | 559 | 5.40k | // Recurse to the next argument. | 560 | 5.40k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.40k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, long long, char const*>(unsigned long, char*, char*, unsigned int const&, long long const&, char const* const&) Line | Count | Source | 556 | 5.40k | const T &arg, const Ts &...args) { | 557 | 5.40k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.40k | | 559 | 5.40k | // Recurse to the next argument. | 560 | 5.40k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.40k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long, char const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&, char const* const&) Line | Count | Source | 556 | 5.40k | const T &arg, const Ts &...args) { | 557 | 5.40k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.40k | | 559 | 5.40k | // Recurse to the next argument. | 560 | 5.40k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.40k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int, long long>(unsigned long, char*, char*, int const&, long long const&) Line | Count | Source | 556 | 525k | const T &arg, const Ts &...args) { | 557 | 525k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 525k | | 559 | 525k | // Recurse to the next argument. | 560 | 525k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 525k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, int, long long>(unsigned long, char*, char*, unsigned int const&, int const&, long long const&) Line | Count | Source | 556 | 525k | const T &arg, const Ts &...args) { | 557 | 525k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 525k | | 559 | 525k | // Recurse to the next argument. | 560 | 525k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 525k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, int, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&, long long const&) Line | Count | Source | 556 | 525k | const T &arg, const Ts &...args) { | 557 | 525k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 525k | | 559 | 525k | // Recurse to the next argument. | 560 | 525k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 525k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, int>(unsigned long, char*, char*, unsigned int const&, int const&) Line | Count | Source | 556 | 544k | const T &arg, const Ts &...args) { | 557 | 544k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 544k | | 559 | 544k | // Recurse to the next argument. | 560 | 544k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 544k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, int>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&) Line | Count | Source | 556 | 544k | const T &arg, const Ts &...args) { | 557 | 544k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 544k | | 559 | 544k | // Recurse to the next argument. | 560 | 544k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 544k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MachineBasicBlock*>(unsigned long, char*, char*, unsigned int const&, llvm::MachineBasicBlock* const&) Line | Count | Source | 556 | 2.66M | const T &arg, const Ts &...args) { | 557 | 2.66M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.66M | | 559 | 2.66M | // Recurse to the next argument. | 560 | 2.66M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.66M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MachineBasicBlock* const&) Line | Count | Source | 556 | 2.66M | const T &arg, const Ts &...args) { | 557 | 2.66M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.66M | | 559 | 2.66M | // Recurse to the next argument. | 560 | 2.66M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.66M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ConstantFP const*>(unsigned long, char*, char*, llvm::ConstantFP const* const&) Line | Count | Source | 556 | 225 | const T &arg, const Ts &...args) { | 557 | 225 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 225 | | 559 | 225 | // Recurse to the next argument. | 560 | 225 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 225 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::ConstantFP const*>(unsigned long, char*, char*, unsigned int const&, llvm::ConstantFP const* const&) Line | Count | Source | 556 | 225 | const T &arg, const Ts &...args) { | 557 | 225 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 225 | | 559 | 225 | // Recurse to the next argument. | 560 | 225 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 225 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::ConstantFP const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::ConstantFP const* const&) Line | Count | Source | 556 | 225 | const T &arg, const Ts &...args) { | 557 | 225 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 225 | | 559 | 225 | // Recurse to the next argument. | 560 | 225 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 225 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ConstantInt const*>(unsigned long, char*, char*, llvm::ConstantInt const* const&) Line | Count | Source | 556 | 1 | const T &arg, const Ts &...args) { | 557 | 1 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1 | | 559 | 1 | // Recurse to the next argument. | 560 | 1 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::ConstantInt const*>(unsigned long, char*, char*, unsigned int const&, llvm::ConstantInt const* const&) Line | Count | Source | 556 | 1 | const T &arg, const Ts &...args) { | 557 | 1 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1 | | 559 | 1 | // Recurse to the next argument. | 560 | 1 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::ConstantInt const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::ConstantInt const* const&) Line | Count | Source | 556 | 1 | const T &arg, const Ts &...args) { | 557 | 1 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 1 | | 559 | 1 | // Recurse to the next argument. | 560 | 1 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 1 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long>(unsigned long, char*, char*, long long const&) Line | Count | Source | 556 | 31.7M | const T &arg, const Ts &...args) { | 557 | 31.7M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 31.7M | | 559 | 31.7M | // Recurse to the next argument. | 560 | 31.7M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 31.7M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, long long>(unsigned long, char*, char*, unsigned int const&, long long const&) Line | Count | Source | 556 | 24.5M | const T &arg, const Ts &...args) { | 557 | 24.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 24.5M | | 559 | 24.5M | // Recurse to the next argument. | 560 | 24.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 24.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&) Line | Count | Source | 556 | 24.5M | const T &arg, const Ts &...args) { | 557 | 24.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 24.5M | | 559 | 24.5M | // Recurse to the next argument. | 560 | 24.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 24.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, bool const&) Line | Count | Source | 556 | 40.5M | const T &arg, const Ts &...args) { | 557 | 40.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 40.5M | | 559 | 40.5M | // Recurse to the next argument. | 560 | 40.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 40.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, bool const&) Line | Count | Source | 556 | 40.5M | const T &arg, const Ts &...args) { | 557 | 40.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 40.5M | | 559 | 40.5M | // Recurse to the next argument. | 560 | 40.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 40.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int, bool>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const&, bool const&) Line | Count | Source | 556 | 40.5M | const T &arg, const Ts &...args) { | 557 | 40.5M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 40.5M | | 559 | 40.5M | // Recurse to the next argument. | 560 | 40.5M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 40.5M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, unsigned int>(unsigned long, char*, char*, bool const&, unsigned int const&) Line | Count | Source | 556 | 2.57M | const T &arg, const Ts &...args) { | 557 | 2.57M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.57M | | 559 | 2.57M | // Recurse to the next argument. | 560 | 2.57M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.57M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineBasicBlock* const&) Line | Count | Source | 556 | 2.66M | const T &arg, const Ts &...args) { | 557 | 2.66M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.66M | | 559 | 2.66M | // Recurse to the next argument. | 560 | 2.66M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.66M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::MachineBasicBlock* const&) Line | Count | Source | 556 | 7 | const T &arg, const Ts &...args) { | 557 | 7 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 7 | | 559 | 7 | // Recurse to the next argument. | 560 | 7 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 7 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MCSymbol* const&) Line | Count | Source | 556 | 153 | const T &arg, const Ts &...args) { | 557 | 153 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 153 | | 559 | 153 | // Recurse to the next argument. | 560 | 153 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 153 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::MCSymbol*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::MCSymbol* const&) Line | Count | Source | 556 | 2 | const T &arg, const Ts &...args) { | 557 | 2 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2 | | 559 | 2 | // Recurse to the next argument. | 560 | 2 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BlockAddress const*>(unsigned long, char*, char*, llvm::BlockAddress const* const&) Line | Count | Source | 556 | 10 | const T &arg, const Ts &...args) { | 557 | 10 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10 | | 559 | 10 | // Recurse to the next argument. | 560 | 10 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::BlockAddress const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::BlockAddress const* const&) Line | Count | Source | 556 | 10 | const T &arg, const Ts &...args) { | 557 | 10 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 10 | | 559 | 10 | // Recurse to the next argument. | 560 | 10 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 10 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::GlobalValue const*>(unsigned long, char*, char*, llvm::GlobalValue const* const&) Line | Count | Source | 556 | 15.1k | const T &arg, const Ts &...args) { | 557 | 15.1k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 15.1k | | 559 | 15.1k | // Recurse to the next argument. | 560 | 15.1k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 15.1k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::GlobalValue const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::GlobalValue const* const&) Line | Count | Source | 556 | 15.1k | const T &arg, const Ts &...args) { | 557 | 15.1k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 15.1k | | 559 | 15.1k | // Recurse to the next argument. | 560 | 15.1k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 15.1k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<char const*>(unsigned long, char*, char*, char const* const&) Line | Count | Source | 556 | 5.40k | const T &arg, const Ts &...args) { | 557 | 5.40k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.40k | | 559 | 5.40k | // Recurse to the next argument. | 560 | 5.40k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.40k | } |
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, char const*>(unsigned long, char*, char*, llvm::hash_code const&, char const* const&) llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int>(unsigned long, char*, char*, int const&) Line | Count | Source | 556 | 544k | const T &arg, const Ts &...args) { | 557 | 544k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 544k | | 559 | 544k | // Recurse to the next argument. | 560 | 544k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 544k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, int>(unsigned long, char*, char*, llvm::hash_code const&, int const&) Line | Count | Source | 556 | 303 | const T &arg, const Ts &...args) { | 557 | 303 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 303 | | 559 | 303 | // Recurse to the next argument. | 560 | 303 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 303 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&) Line | Count | Source | 556 | 22.8k | const T &arg, const Ts &...args) { | 557 | 22.8k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 22.8k | | 559 | 22.8k | // Recurse to the next argument. | 560 | 22.8k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 22.8k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&) Line | Count | Source | 556 | 22.8k | const T &arg, const Ts &...args) { | 557 | 22.8k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 22.8k | | 559 | 22.8k | // Recurse to the next argument. | 560 | 22.8k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 22.8k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&) Line | Count | Source | 556 | 22.8k | const T &arg, const Ts &...args) { | 557 | 22.8k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 22.8k | | 559 | 22.8k | // Recurse to the next argument. | 560 | 22.8k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 22.8k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&) Line | Count | Source | 556 | 22.8k | const T &arg, const Ts &...args) { | 557 | 22.8k | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 22.8k | | 559 | 22.8k | // Recurse to the next argument. | 560 | 22.8k | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 22.8k | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&) Line | Count | Source | 556 | 101M | const T &arg, const Ts &...args) { | 557 | 101M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 101M | | 559 | 101M | // Recurse to the next argument. | 560 | 101M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 101M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::hash_code const&) Line | Count | Source | 556 | 27.4M | const T &arg, const Ts &...args) { | 557 | 27.4M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 27.4M | | 559 | 27.4M | // Recurse to the next argument. | 560 | 27.4M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 27.4M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::hash_code const&) Line | Count | Source | 556 | 217 | const T &arg, const Ts &...args) { | 557 | 217 | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 217 | | 559 | 217 | // Recurse to the next argument. | 560 | 217 | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 217 | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Loop const*, llvm::BasicBlock*>(unsigned long, char*, char*, llvm::Loop const* const&, llvm::BasicBlock* const&) Line | Count | Source | 556 | 2.94M | const T &arg, const Ts &...args) { | 557 | 2.94M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.94M | | 559 | 2.94M | // Recurse to the next argument. | 560 | 2.94M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.94M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BasicBlock*>(unsigned long, char*, char*, llvm::BasicBlock* const&) Line | Count | Source | 556 | 2.94M | const T &arg, const Ts &...args) { | 557 | 2.94M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 2.94M | | 559 | 2.94M | // Recurse to the next argument. | 560 | 2.94M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 2.94M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, bool>(unsigned long, char*, char*, llvm::hash_code const&, bool const&) Line | Count | Source | 556 | 11.4M | const T &arg, const Ts &...args) { | 557 | 11.4M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 11.4M | | 559 | 11.4M | // Recurse to the next argument. | 560 | 11.4M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 11.4M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool>(unsigned long, char*, char*, bool const&) Line | Count | Source | 556 | 52.0M | const T &arg, const Ts &...args) { | 557 | 52.0M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 52.0M | | 559 | 52.0M | // Recurse to the next argument. | 560 | 52.0M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 52.0M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int>(unsigned long, char*, char*, unsigned int const&) Line | Count | Source | 556 | 45.1M | const T &arg, const Ts &...args) { | 557 | 45.1M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 45.1M | | 559 | 45.1M | // Recurse to the next argument. | 560 | 45.1M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 45.1M | } |
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&) Line | Count | Source | 556 | 5.84M | const T &arg, const Ts &...args) { | 557 | 5.84M | buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)); | 558 | 5.84M | | 559 | 5.84M | // Recurse to the next argument. | 560 | 5.84M | return combine(length, buffer_ptr, buffer_end, args...); | 561 | 5.84M | } |
|
562 | | |
563 | | /// \brief Base case for recursive, variadic combining. |
564 | | /// |
565 | | /// The base case when combining arguments recursively is reached when all |
566 | | /// arguments have been handled. It flushes the remaining buffer and |
567 | | /// constructs a hash_code. |
568 | 606M | hash_code combine(size_t length, char *buffer_ptr, char *buffer_end) { |
569 | 606M | // Check whether the entire set of values fit in the buffer. If so, we'll |
570 | 606M | // use the optimized short hashing routine and skip state entirely. |
571 | 606M | if (length == 0) |
572 | 606M | return hash_short(buffer, buffer_ptr - buffer, seed); |
573 | 606M | |
574 | 606M | // Mix the final buffer, rotating it if we did a partial fill in order to |
575 | 606M | // simulate doing a mix of the last 64-bytes. That is how the algorithm |
576 | 606M | // works when we have a contiguous byte sequence, and we want to emulate |
577 | 606M | // that here. |
578 | 11 | std::rotate(buffer, buffer_ptr, buffer_end); |
579 | 11 | |
580 | 11 | // Mix this chunk into the current state. |
581 | 11 | state.mix(buffer); |
582 | 11 | length += buffer_ptr - buffer; |
583 | 11 | |
584 | 11 | return state.finalize(length); |
585 | 606M | } |
586 | | }; |
587 | | |
588 | | } // namespace detail |
589 | | } // namespace hashing |
590 | | |
591 | | /// \brief Combine values into a single hash_code. |
592 | | /// |
593 | | /// This routine accepts a varying number of arguments of any type. It will |
594 | | /// attempt to combine them into a single hash_code. For user-defined types it |
595 | | /// attempts to call a \see hash_value overload (via ADL) for the type. For |
596 | | /// integer and pointer types it directly combines their data into the |
597 | | /// resulting hash_code. |
598 | | /// |
599 | | /// The result is suitable for returning from a user's hash_value |
600 | | /// *implementation* for their user-defined type. Consumers of a type should |
601 | | /// *not* call this routine, they should instead call 'hash_value'. |
602 | 605M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { |
603 | 605M | // Recursively hash each argument using a helper class. |
604 | 605M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; |
605 | 605M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); |
606 | 605M | } llvm::hash_code llvm::hash_combine<unsigned int, unsigned int>(unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 2.67k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.67k | // Recursively hash each argument using a helper class. | 604 | 2.67k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.67k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.67k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, bool>(llvm::hash_code const&, bool const&) Line | Count | Source | 602 | 3.08M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3.08M | // Recursively hash each argument using a helper class. | 604 | 3.08M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3.08M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3.08M | } |
llvm::hash_code llvm::hash_combine<llvm::Loop const*, llvm::BasicBlock*>(llvm::Loop const* const&, llvm::BasicBlock* const&) Line | Count | Source | 602 | 2.94M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.94M | // Recursively hash each argument using a helper class. | 604 | 2.94M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.94M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.94M | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, llvm::hash_code>(unsigned int const&, unsigned int const&, llvm::hash_code const&) Line | Count | Source | 602 | 217 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 217 | // Recursively hash each argument using a helper class. | 604 | 217 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 217 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 217 | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::hash_code>(unsigned int const&, llvm::hash_code const&) Line | Count | Source | 602 | 27.4M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 27.4M | // Recursively hash each argument using a helper class. | 604 | 27.4M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 27.4M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 27.4M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&) Line | Count | Source | 602 | 22.8k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 22.8k | // Recursively hash each argument using a helper class. | 604 | 22.8k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 22.8k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 22.8k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, int>(llvm::hash_code const&, int const&) Line | Count | Source | 602 | 303 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 303 | // Recursively hash each argument using a helper class. | 604 | 303 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 303 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 303 | } |
Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::hash_code, char const*>(llvm::hash_code const&, char const* const&) llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::GlobalValue const*>(llvm::hash_code const&, llvm::GlobalValue const* const&) Line | Count | Source | 602 | 15.1k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 15.1k | // Recursively hash each argument using a helper class. | 604 | 15.1k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 15.1k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 15.1k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::BlockAddress const*>(llvm::hash_code const&, llvm::BlockAddress const* const&) Line | Count | Source | 602 | 10 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 10 | // Recursively hash each argument using a helper class. | 604 | 10 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 10 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 10 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::MCSymbol*>(llvm::hash_code const&, llvm::MCSymbol* const&) Line | Count | Source | 602 | 2 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2 | // Recursively hash each argument using a helper class. | 604 | 2 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::MachineBasicBlock*>(llvm::hash_code const&, llvm::MachineBasicBlock* const&) Line | Count | Source | 602 | 7 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 7 | // Recursively hash each argument using a helper class. | 604 | 7 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 7 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 7 | } |
llvm::hash_code llvm::hash_combine<bool, unsigned int>(bool const&, unsigned int const&) Line | Count | Source | 602 | 2.56M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.56M | // Recursively hash each argument using a helper class. | 604 | 2.56M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.56M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.56M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int, bool>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const&, bool const&) Line | Count | Source | 602 | 40.5M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 40.5M | // Recursively hash each argument using a helper class. | 604 | 40.5M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 40.5M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 40.5M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&) Line | Count | Source | 602 | 24.5M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 24.5M | // Recursively hash each argument using a helper class. | 604 | 24.5M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 24.5M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 24.5M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::ConstantInt const*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::ConstantInt const* const&) Line | Count | Source | 602 | 1 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1 | // Recursively hash each argument using a helper class. | 604 | 1 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1 | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::ConstantFP const*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::ConstantFP const* const&) Line | Count | Source | 602 | 225 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 225 | // Recursively hash each argument using a helper class. | 604 | 225 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 225 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 225 | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MachineBasicBlock*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MachineBasicBlock* const&) Line | Count | Source | 602 | 2.66M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.66M | // Recursively hash each argument using a helper class. | 604 | 2.66M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.66M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.66M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, int>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&) Line | Count | Source | 602 | 544k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 544k | // Recursively hash each argument using a helper class. | 604 | 544k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 544k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 544k | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, int, long long>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&, long long const&) Line | Count | Source | 602 | 525k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 525k | // Recursively hash each argument using a helper class. | 604 | 525k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 525k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 525k | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long, char const*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&, char const* const&) Line | Count | Source | 602 | 5.40k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 5.40k | // Recursively hash each argument using a helper class. | 604 | 5.40k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 5.40k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 5.40k | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::GlobalValue const*, long long>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::GlobalValue const* const&, long long const&) Line | Count | Source | 602 | 6.75M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 6.75M | // Recursively hash each argument using a helper class. | 604 | 6.75M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 6.75M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 6.75M | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::BlockAddress const*, long long>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::BlockAddress const* const&, long long const&) Line | Count | Source | 602 | 343 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 343 | // Recursively hash each argument using a helper class. | 604 | 343 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 343 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 343 | } |
llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int const*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const* const&) Line | Count | Source | 602 | 2 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2 | // Recursively hash each argument using a helper class. | 604 | 2 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2 | } |
Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MDNode const*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MDNode const* const&) llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MCSymbol*>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MCSymbol* const&) Line | Count | Source | 602 | 151 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 151 | // Recursively hash each argument using a helper class. | 604 | 151 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 151 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 151 | } |
Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const&) Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::Intrinsic::ID>(llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::Intrinsic::ID const&) llvm::hash_code llvm::hash_combine<unsigned int, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned int const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 602 | 14.6k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 14.6k | // Recursively hash each argument using a helper class. | 604 | 14.6k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 14.6k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 14.6k | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, llvm::MDString*, llvm::MDString*>(unsigned int const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 602 | 3.18k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3.18k | // Recursively hash each argument using a helper class. | 604 | 3.18k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3.18k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3.18k | } |
llvm::hash_code llvm::hash_combine<llvm::MDString*, llvm::Metadata*>(llvm::MDString* const&, llvm::Metadata* const&) Line | Count | Source | 602 | 3.91k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3.91k | // Recursively hash each argument using a helper class. | 604 | 3.91k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3.91k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3.91k | } |
llvm::hash_code llvm::hash_combine<long long, long long>(long long const&, long long const&) Line | Count | Source | 602 | 718 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 718 | // Recursively hash each argument using a helper class. | 604 | 718 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 718 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 718 | } |
llvm::hash_code llvm::hash_combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&) Line | Count | Source | 602 | 173 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 173 | // Recursively hash each argument using a helper class. | 604 | 173 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 173 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 173 | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::Metadata*>(llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 602 | 3.17k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3.17k | // Recursively hash each argument using a helper class. | 604 | 3.17k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3.17k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3.17k | } |
llvm::hash_code llvm::hash_combine<long long, llvm::MDString*>(long long const&, llvm::MDString* const&) Line | Count | Source | 602 | 17.7k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 17.7k | // Recursively hash each argument using a helper class. | 604 | 17.7k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 17.7k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 17.7k | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::MDString*, unsigned long long, unsigned int, unsigned int>(unsigned int const&, llvm::MDString* const&, unsigned long long const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 2.44k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.44k | // Recursively hash each argument using a helper class. | 604 | 2.44k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.44k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.44k | } |
llvm::hash_code llvm::hash_combine<unsigned char, unsigned char, unsigned short, llvm::hash_code, llvm::hash_code>(unsigned char const&, unsigned char const&, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 602 | 28.0M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 28.0M | // Recursively hash each argument using a helper class. | 604 | 28.0M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 28.0M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 28.0M | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 602 | 357 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 357 | // Recursively hash each argument using a helper class. | 604 | 357 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 357 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 357 | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::MDString*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(llvm::Metadata* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&) Line | Count | Source | 602 | 2.85k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.85k | // Recursively hash each argument using a helper class. | 604 | 2.85k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.85k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.85k | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 602 | 2.81M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.81M | // Recursively hash each argument using a helper class. | 604 | 2.81M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.81M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.81M | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(llvm::Metadata* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 12.9k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 12.9k | // Recursively hash each argument using a helper class. | 604 | 12.9k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 12.9k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 12.9k | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, llvm::MDString*>(unsigned int const&, unsigned int const&, llvm::MDString* const&) Line | Count | Source | 602 | 114 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 114 | // Recursively hash each argument using a helper class. | 604 | 114 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 114 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 114 | } |
llvm::hash_code llvm::hash_combine<llvm::StringRef, llvm::StringRef, bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(llvm::StringRef const&, llvm::StringRef const&, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&) Line | Count | Source | 602 | 13.3k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 13.3k | // Recursively hash each argument using a helper class. | 604 | 13.3k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 13.3k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 13.3k | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::MDString*, llvm::MDString*, llvm::MDString*, llvm::MDString*>(llvm::Metadata* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&, llvm::MDString* const&) Line | Count | Source | 602 | 127 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 127 | // Recursively hash each argument using a helper class. | 604 | 127 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 127 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 127 | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::MDString*, llvm::Metadata*, llvm::Metadata*>(unsigned int const&, llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 602 | 1.16k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.16k | // Recursively hash each argument using a helper class. | 604 | 1.16k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.16k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.16k | } |
llvm::hash_code llvm::hash_combine<llvm::Type const*, llvm::hash_code, bool>(llvm::Type const* const&, llvm::hash_code const&, bool const&) Line | Count | Source | 602 | 8.37M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 8.37M | // Recursively hash each argument using a helper class. | 604 | 8.37M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 8.37M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 8.37M | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::Metadata*, unsigned int, unsigned int>(llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 61 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 61 | // Recursively hash each argument using a helper class. | 604 | 61 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 61 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 61 | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::MDString*>(llvm::Metadata* const&, llvm::MDString* const&) Line | Count | Source | 602 | 400 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 400 | // Recursively hash each argument using a helper class. | 604 | 400 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 400 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 400 | } |
llvm::hash_code llvm::hash_combine<llvm::Metadata*, llvm::Metadata*, unsigned int>(llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 602 | 1.44k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.44k | // Recursively hash each argument using a helper class. | 604 | 1.44k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.44k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.44k | } |
llvm::hash_code llvm::hash_combine<llvm::MDString*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int>(llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&) Line | Count | Source | 602 | 1.89k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.89k | // Recursively hash each argument using a helper class. | 604 | 1.89k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.89k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.89k | } |
llvm::hash_code llvm::hash_combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&) Line | Count | Source | 602 | 4.64k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 4.64k | // Recursively hash each argument using a helper class. | 604 | 4.64k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 4.64k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 4.64k | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned char, llvm::Metadata*>(unsigned int const&, unsigned char const&, llvm::Metadata* const&) Line | Count | Source | 602 | 30.5k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 30.5k | // Recursively hash each argument using a helper class. | 604 | 30.5k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 30.5k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 30.5k | } |
llvm::hash_code llvm::hash_combine<llvm::MDString*, llvm::MDString*, llvm::DIFile::ChecksumKind, llvm::MDString*>(llvm::MDString* const&, llvm::MDString* const&, llvm::DIFile::ChecksumKind const&, llvm::MDString* const&) Line | Count | Source | 602 | 10.5k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 10.5k | // Recursively hash each argument using a helper class. | 604 | 10.5k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 10.5k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 10.5k | } |
llvm::hash_code llvm::hash_combine<llvm::ArrayType*, unsigned int>(llvm::ArrayType* const&, unsigned int const&) Line | Count | Source | 602 | 45.2k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 45.2k | // Recursively hash each argument using a helper class. | 604 | 45.2k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 45.2k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 45.2k | } |
llvm::hash_code llvm::hash_combine<llvm::StructType*, unsigned int>(llvm::StructType* const&, unsigned int const&) Line | Count | Source | 602 | 231k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 231k | // Recursively hash each argument using a helper class. | 604 | 231k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 231k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 231k | } |
llvm::hash_code llvm::hash_combine<llvm::VectorType*, unsigned int>(llvm::VectorType* const&, unsigned int const&) Line | Count | Source | 602 | 233k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 233k | // Recursively hash each argument using a helper class. | 604 | 233k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 233k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 233k | } |
llvm::hash_code llvm::hash_combine<llvm::Type*, unsigned int>(llvm::Type* const&, unsigned int const&) Line | Count | Source | 602 | 28.0M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 28.0M | // Recursively hash each argument using a helper class. | 604 | 28.0M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 28.0M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 28.0M | } |
llvm::hash_code llvm::hash_combine<llvm::PointerType*, unsigned int>(llvm::PointerType* const&, unsigned int const&) Line | Count | Source | 602 | 13.3k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 13.3k | // Recursively hash each argument using a helper class. | 604 | 13.3k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 13.3k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 13.3k | } |
llvm::hash_code llvm::hash_combine<llvm::MCSymbol const*, unsigned int, unsigned int, bool, bool, unsigned int>(llvm::MCSymbol const* const&, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&) Line | Count | Source | 602 | 11.2k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 11.2k | // Recursively hash each argument using a helper class. | 604 | 11.2k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 11.2k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 11.2k | } |
llvm::hash_code llvm::hash_combine<llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*>(llvm::Instruction::BinaryOps const&, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 602 | 10.5M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 10.5M | // Recursively hash each argument using a helper class. | 604 | 10.5M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 10.5M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 10.5M | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*>(unsigned int const&, llvm::CmpInst::Predicate const&, llvm::Value* const&, llvm::Value* const&) Line | Count | Source | 602 | 19.4M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 19.4M | // Recursively hash each argument using a helper class. | 604 | 19.4M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 19.4M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 19.4M | } |
llvm::hash_code llvm::hash_combine<llvm::Instruction::CastOps, llvm::Type*, llvm::Value*>(llvm::Instruction::CastOps const&, llvm::Type* const&, llvm::Value* const&) Line | Count | Source | 602 | 10.8M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 10.8M | // Recursively hash each argument using a helper class. | 604 | 10.8M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 10.8M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 10.8M | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::Value*, llvm::hash_code>(unsigned int const&, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 602 | 248k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 248k | // Recursively hash each argument using a helper class. | 604 | 248k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 248k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 248k | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::Value*, llvm::Value*, llvm::hash_code>(unsigned int const&, llvm::Value* const&, llvm::Value* const&, llvm::hash_code const&) Line | Count | Source | 602 | 29.0k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 29.0k | // Recursively hash each argument using a helper class. | 604 | 29.0k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 29.0k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 29.0k | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::Type*, llvm::hash_code>(unsigned int const&, llvm::Type* const&, llvm::hash_code const&) Line | Count | Source | 602 | 31.7M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 31.7M | // Recursively hash each argument using a helper class. | 604 | 31.7M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 31.7M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 31.7M | } |
Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::hash_code, unsigned int, bool>(llvm::hash_code const&, unsigned int const&, bool const&) llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::Type*, llvm::hash_code>(llvm::hash_code const&, llvm::Type* const&, llvm::hash_code const&) Line | Count | Source | 602 | 2.24k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 2.24k | // Recursively hash each argument using a helper class. | 604 | 2.24k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 2.24k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 2.24k | } |
llvm::hash_code llvm::hash_combine<unsigned int, llvm::Type*, unsigned int, bool>(unsigned int const&, llvm::Type* const&, unsigned int const&, bool const&) Line | Count | Source | 602 | 130 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 130 | // Recursively hash each argument using a helper class. | 604 | 130 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 130 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 130 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, unsigned int>(llvm::hash_code const&, unsigned int const&) Line | Count | Source | 602 | 217k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 217k | // Recursively hash each argument using a helper class. | 604 | 217k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 217k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 217k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::MemoryAccess const*>(llvm::hash_code const&, llvm::MemoryAccess const* const&) Line | Count | Source | 602 | 1.12k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.12k | // Recursively hash each argument using a helper class. | 604 | 1.12k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.12k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.12k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::Type*, llvm::Constant*>(llvm::hash_code const&, llvm::Type* const&, llvm::Constant* const&) Line | Count | Source | 602 | 437 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 437 | // Recursively hash each argument using a helper class. | 604 | 437 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 437 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 437 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::Instruction*>(llvm::hash_code const&, llvm::Instruction* const&) Line | Count | Source | 602 | 324 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 324 | // Recursively hash each argument using a helper class. | 604 | 324 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 324 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 324 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::Type*, llvm::Value*>(llvm::hash_code const&, llvm::Type* const&, llvm::Value* const&) Line | Count | Source | 602 | 50 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 50 | // Recursively hash each argument using a helper class. | 604 | 50 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 50 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 50 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::BasicBlock*>(llvm::hash_code const&, llvm::BasicBlock* const&) Line | Count | Source | 602 | 236 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 236 | // Recursively hash each argument using a helper class. | 604 | 236 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 236 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 236 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::hash_code>(llvm::hash_code const&, llvm::hash_code const&) Line | Count | Source | 602 | 12.8M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 12.8M | // Recursively hash each argument using a helper class. | 604 | 12.8M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 12.8M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 12.8M | } |
llvm::hash_code llvm::hash_combine<unsigned char, unsigned char, unsigned int>(unsigned char const&, unsigned char const&, unsigned int const&) Line | Count | Source | 602 | 118k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 118k | // Recursively hash each argument using a helper class. | 604 | 118k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 118k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 118k | } |
llvm::hash_code llvm::hash_combine<unsigned char, unsigned char, unsigned int, short, llvm::hash_code>(unsigned char const&, unsigned char const&, unsigned int const&, short const&, llvm::hash_code const&) Line | Count | Source | 602 | 766k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 766k | // Recursively hash each argument using a helper class. | 604 | 766k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 766k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 766k | } |
Unexecuted instantiation: llvm::hash_code llvm::hash_combine<llvm::fltSemantics const*>(llvm::fltSemantics const* const&) llvm::hash_code llvm::hash_combine<unsigned long long>(unsigned long long const&) Line | Count | Source | 602 | 326M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 326M | // Recursively hash each argument using a helper class. | 604 | 326M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 326M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 326M | } |
llvm::hash_code llvm::hash_combine<void*, void*>(void* const&, void* const&) Line | Count | Source | 602 | 4.57k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 4.57k | // Recursively hash each argument using a helper class. | 604 | 4.57k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 4.57k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 4.57k | } |
llvm::hash_code llvm::hash_combine<clang::NestedNameSpecifier*, void*>(clang::NestedNameSpecifier* const&, void* const&) Line | Count | Source | 602 | 270 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 270 | // Recursively hash each argument using a helper class. | 604 | 270 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 270 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 270 | } |
llvm::hash_code llvm::hash_combine<llvm::coverage::CounterExpression::ExprKind, llvm::coverage::Counter::CounterKind, unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(llvm::coverage::CounterExpression::ExprKind const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&) Line | Count | Source | 602 | 1.58k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.58k | // Recursively hash each argument using a helper class. | 604 | 1.58k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.58k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.58k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, llvm::StringRef>(llvm::hash_code const&, llvm::StringRef const&) Line | Count | Source | 602 | 14 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 14 | // Recursively hash each argument using a helper class. | 604 | 14 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 14 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 14 | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 602 | 1.85k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.85k | // Recursively hash each argument using a helper class. | 604 | 1.85k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.85k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.85k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 602 | 3.73k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3.73k | // Recursively hash each argument using a helper class. | 604 | 3.73k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3.73k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3.73k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, unsigned int, unsigned int>(llvm::hash_code const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 1.85k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.85k | // Recursively hash each argument using a helper class. | 604 | 1.85k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.85k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.85k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool>(llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, bool const&) Line | Count | Source | 602 | 1.18k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.18k | // Recursively hash each argument using a helper class. | 604 | 1.18k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.18k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.18k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int>(llvm::hash_code const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 1.85k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.85k | // Recursively hash each argument using a helper class. | 604 | 1.85k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.85k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.85k | } |
llvm::hash_code llvm::hash_combine<llvm::hash_code, unsigned long long>(llvm::hash_code const&, unsigned long long const&) Line | Count | Source | 602 | 3 | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 3 | // Recursively hash each argument using a helper class. | 604 | 3 | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 3 | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 3 | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, unsigned int>(unsigned int const&, unsigned int const&, unsigned int const&) Line | Count | Source | 602 | 5.82M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 5.82M | // Recursively hash each argument using a helper class. | 604 | 5.82M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 5.82M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 5.82M | } |
llvm::hash_code llvm::hash_combine<unsigned int, unsigned int, llvm::RegisterBankInfo::ValueMapping const*, unsigned int>(unsigned int const&, unsigned int const&, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned int const&) Line | Count | Source | 602 | 7.22M | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 7.22M | // Recursively hash each argument using a helper class. | 604 | 7.22M | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 7.22M | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 7.22M | } |
llvm::hash_code llvm::hash_combine<long long, long>(long long const&, long const&) Line | Count | Source | 602 | 59.0k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 59.0k | // Recursively hash each argument using a helper class. | 604 | 59.0k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 59.0k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 59.0k | } |
llvm::hash_code llvm::hash_combine<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 602 | 1.40k | template <typename ...Ts> hash_code hash_combine(const Ts &...args) { | 603 | 1.40k | // Recursively hash each argument using a helper class. | 604 | 1.40k | ::llvm::hashing::detail::hash_combine_recursive_helper helper; | 605 | 1.40k | return helper.combine(0, helper.buffer, helper.buffer + 64, args...); | 606 | 1.40k | } |
|
607 | | |
608 | | // Implementation details for implementations of hash_value overloads provided |
609 | | // here. |
610 | | namespace hashing { |
611 | | namespace detail { |
612 | | |
613 | | /// \brief Helper to hash the value of a single integer. |
614 | | /// |
615 | | /// Overloads for smaller integer types are not provided to ensure consistent |
616 | | /// behavior in the presence of integral promotions. Essentially, |
617 | | /// "hash_value('4')" and "hash_value('0' + 4)" should be the same. |
618 | 513 | inline hash_code hash_integer_value(uint64_t value) { |
619 | 513 | // Similar to hash_4to8_bytes but using a seed instead of length. |
620 | 513 | const uint64_t seed = get_execution_seed(); |
621 | 513 | const char *s = reinterpret_cast<const char *>(&value); |
622 | 513 | const uint64_t a = fetch32(s); |
623 | 513 | return hash_16_bytes(seed + (a << 3), fetch32(s + 4)); |
624 | 513 | } |
625 | | |
626 | | } // namespace detail |
627 | | } // namespace hashing |
628 | | |
629 | | // Declared and documented above, but defined here so that any of the hashing |
630 | | // infrastructure is available. |
631 | | template <typename T> |
632 | | typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type |
633 | | hash_value(T value) { |
634 | | return ::llvm::hashing::detail::hash_integer_value( |
635 | | static_cast<uint64_t>(value)); |
636 | | } |
637 | | |
638 | | // Declared and documented above, but defined here so that any of the hashing |
639 | | // infrastructure is available. |
640 | 1 | template <typename T> hash_code hash_value(const T *ptr) { |
641 | 1 | return ::llvm::hashing::detail::hash_integer_value( |
642 | 1 | reinterpret_cast<uintptr_t>(ptr)); |
643 | 1 | } |
644 | | |
645 | | // Declared and documented above, but defined here so that any of the hashing |
646 | | // infrastructure is available. |
647 | | template <typename T, typename U> |
648 | | hash_code hash_value(const std::pair<T, U> &arg) { |
649 | | return hash_combine(arg.first, arg.second); |
650 | | } |
651 | | |
652 | | // Declared and documented above, but defined here so that any of the hashing |
653 | | // infrastructure is available. |
654 | | template <typename T> |
655 | 18.9k | hash_code hash_value(const std::basic_string<T> &arg) { |
656 | 18.9k | return hash_combine_range(arg.begin(), arg.end()); |
657 | 18.9k | } |
658 | | |
659 | | } // namespace llvm |
660 | | |
661 | | #endif |