Coverage Report

Created: 2017-10-03 07:32

/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