Coverage Report

Created: 2018-11-13 17:19

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/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
/// 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
0
class hash_code {
73
  size_t value;
74
75
public:
76
  /// Default construct a hash_code.
77
  /// Note that this leaves the value uninitialized.
78
  hash_code() = default;
79
80
  /// Form a hash code directly from a numerical value.
81
1.21G
  hash_code(size_t value) : value(value) {}
82
83
  /// Convert the hash code to its numerical value for use.
84
1.10G
  /*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
76.4k
  friend bool operator!=(const hash_code &lhs, const hash_code &rhs) {
90
76.4k
    return lhs.value != rhs.value;
91
76.4k
  }
92
93
  /// Allow a hash_code to be directly run through hash_value.
94
101M
  friend size_t hash_value(const hash_code &code) { return code.value; }
95
};
96
97
/// 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
/// 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
/// 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
/// 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
/// 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(uint64_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.32G
inline uint64_t fetch64(const char *p) {
146
4.32G
  uint64_t result;
147
4.32G
  memcpy(&result, p, sizeof(result));
148
4.32G
  if (sys::IsBigEndianHost)
149
0
    sys::swapByteOrder(result);
150
4.32G
  return result;
151
4.32G
}
152
153
652M
inline uint32_t fetch32(const char *p) {
154
652M
  uint32_t result;
155
652M
  memcpy(&result, p, sizeof(result));
156
652M
  if (sys::IsBigEndianHost)
157
0
    sys::swapByteOrder(result);
158
652M
  return result;
159
652M
}
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
/// Bitwise right rotate.
168
/// Normally this will compile to a single instruction, especially if the
169
/// shift is a manifest constant.
170
2.98G
inline uint64_t rotate(uint64_t val, size_t shift) {
171
2.98G
  // Avoid shifting by 64: doing so yields an undefined result.
172
2.98G
  return shift == 0 ? 
val0
: ((val >> shift) | (val << (64 - shift)));
173
2.98G
}
174
175
302M
inline uint64_t shift_mix(uint64_t val) {
176
302M
  return val ^ (val >> 47);
177
302M
}
178
179
1.18G
inline uint64_t hash_16_bytes(uint64_t low, uint64_t high) {
180
1.18G
  // Murmur-inspired hashing.
181
1.18G
  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
182
1.18G
  uint64_t a = (low ^ high) * kMul;
183
1.18G
  a ^= (a >> 47);
184
1.18G
  uint64_t b = (high ^ a) * kMul;
185
1.18G
  b ^= (b >> 47);
186
1.18G
  b *= kMul;
187
1.18G
  return b;
188
1.18G
}
189
190
1.52M
inline uint64_t hash_1to3_bytes(const char *s, size_t len, uint64_t seed) {
191
1.52M
  uint8_t a = s[0];
192
1.52M
  uint8_t b = s[len >> 1];
193
1.52M
  uint8_t c = s[len - 1];
194
1.52M
  uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
195
1.52M
  uint32_t z = len + (static_cast<uint32_t>(c) << 2);
196
1.52M
  return shift_mix(y * k2 ^ z * k3 ^ seed) * k2;
197
1.52M
}
198
199
326M
inline uint64_t hash_4to8_bytes(const char *s, size_t len, uint64_t seed) {
200
326M
  uint64_t a = fetch32(s);
201
326M
  return hash_16_bytes(len + (a << 3), seed ^ fetch32(s + len - 4));
202
326M
}
203
204
341M
inline uint64_t hash_9to16_bytes(const char *s, size_t len, uint64_t seed) {
205
341M
  uint64_t a = fetch64(s);
206
341M
  uint64_t b = fetch64(s + len - 8);
207
341M
  return hash_16_bytes(seed ^ a, rotate(b + len, len)) ^ b;
208
341M
}
209
210
385M
inline uint64_t hash_17to32_bytes(const char *s, size_t len, uint64_t seed) {
211
385M
  uint64_t a = fetch64(s) * k1;
212
385M
  uint64_t b = fetch64(s + 8);
213
385M
  uint64_t c = fetch64(s + len - 8) * k2;
214
385M
  uint64_t d = fetch64(s + len - 16) * k0;
215
385M
  return hash_16_bytes(rotate(a - b, 43) + rotate(c ^ seed, 30) + d,
216
385M
                       a + rotate(b ^ k3, 20) - c + len + seed);
217
385M
}
218
219
110M
inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) {
220
110M
  uint64_t z = fetch64(s + 24);
221
110M
  uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0;
222
110M
  uint64_t b = rotate(a + z, 52);
223
110M
  uint64_t c = rotate(a, 37);
224
110M
  a += fetch64(s + 8);
225
110M
  c += rotate(a, 7);
226
110M
  a += fetch64(s + 16);
227
110M
  uint64_t vf = a + z;
228
110M
  uint64_t vs = b + rotate(a, 31) + c;
229
110M
  a = fetch64(s + 16) + fetch64(s + len - 32);
230
110M
  z = fetch64(s + len - 8);
231
110M
  b = rotate(a + z, 52);
232
110M
  c = rotate(a, 37);
233
110M
  a += fetch64(s + len - 24);
234
110M
  c += rotate(a, 7);
235
110M
  a += fetch64(s + len - 16);
236
110M
  uint64_t wf = a + z;
237
110M
  uint64_t ws = b + rotate(a, 31) + c;
238
110M
  uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0);
239
110M
  return shift_mix((seed ^ (r * k0)) + vs) * k2;
240
110M
}
241
242
1.18G
inline uint64_t hash_short(const char *s, size_t length, uint64_t seed) {
243
1.18G
  if (length >= 4 && 
length <= 81.16G
)
244
326M
    return hash_4to8_bytes(s, length, seed);
245
858M
  if (length > 8 && 
length <= 16837M
)
246
341M
    return hash_9to16_bytes(s, length, seed);
247
516M
  if (length > 16 && 
length <= 32496M
)
248
385M
    return hash_17to32_bytes(s, length, seed);
249
130M
  if (length > 32)
250
110M
    return hash_33to64_bytes(s, length, seed);
251
20.4M
  if (length != 0)
252
1.52M
    return hash_1to3_bytes(s, length, seed);
253
18.9M
254
18.9M
  return k2 ^ seed;
255
18.9M
}
256
257
/// 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
0
struct hash_state {
261
  uint64_t h0, h1, h2, h3, h4, h5, h6;
262
263
  /// 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
26.7M
  static hash_state create(const char *s, uint64_t seed) {
267
26.7M
    hash_state state = {
268
26.7M
      0, seed, hash_16_bytes(seed, k1), rotate(seed ^ k1, 49),
269
26.7M
      seed * k1, shift_mix(seed), 0 };
270
26.7M
    state.h6 = hash_16_bytes(state.h4, state.h5);
271
26.7M
    state.mix(s);
272
26.7M
    return state;
273
26.7M
  }
274
275
  /// 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
165M
  static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) {
278
165M
    a += fetch64(s);
279
165M
    uint64_t c = fetch64(s + 24);
280
165M
    b = rotate(b + a + c, 21);
281
165M
    uint64_t d = a;
282
165M
    a += fetch64(s + 8) + fetch64(s + 16);
283
165M
    b += rotate(a, 44) + d;
284
165M
    a += c;
285
165M
  }
286
287
  /// 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
82.7M
  void mix(const char *s) {
291
82.7M
    h0 = rotate(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
292
82.7M
    h1 = rotate(h1 + h4 + fetch64(s + 48), 42) * k1;
293
82.7M
    h0 ^= h6;
294
82.7M
    h1 += h3 + fetch64(s + 40);
295
82.7M
    h2 = rotate(h2 + h5, 33) * k1;
296
82.7M
    h3 = h4 * k1;
297
82.7M
    h4 = h0 + h5;
298
82.7M
    mix_32_bytes(s, h3, h4);
299
82.7M
    h5 = h2 + h6;
300
82.7M
    h6 = h1 + fetch64(s + 16);
301
82.7M
    mix_32_bytes(s + 32, h5, h6);
302
82.7M
    std::swap(h2, h0);
303
82.7M
  }
304
305
  /// Compute the final 64-bit hash code value based on the current
306
  /// state and the length of bytes hashed.
307
26.7M
  uint64_t finalize(size_t length) {
308
26.7M
    return hash_16_bytes(hash_16_bytes(h3, h5) + shift_mix(h1) * k1 + h2,
309
26.7M
                         hash_16_bytes(h4, h6) + shift_mix(length) * k1 + h0);
310
26.7M
  }
311
};
312
313
314
/// 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 uint64_t fixed_seed_override;
320
321
1.21G
inline uint64_t get_execution_seed() {
322
1.21G
  // FIXME: This needs to be a per-execution seed. This is just a placeholder
323
1.21G
  // implementation. Switching to a per-execution seed is likely to flush out
324
1.21G
  // instability bugs and so will happen as its own commit.
325
1.21G
  //
326
1.21G
  // However, if there is a fixed seed override set the first time this is
327
1.21G
  // called, return that instead of the per-execution seed.
328
1.21G
  const uint64_t seed_prime = 0xff51afd7ed558ccdULL;
329
1.21G
  static uint64_t seed = fixed_seed_override ? 
fixed_seed_override0
: seed_prime;
330
1.21G
  return seed;
331
1.21G
}
332
333
334
/// Trait to indicate whether a type's bits can be hashed directly.
335
///
336
/// A type trait which is true if we want to combine values for hashing by
337
/// reading the underlying data. It is false if values of this type must
338
/// first be passed to hash_value, and the resulting hash_codes combined.
339
//
340
// FIXME: We want to replace is_integral_or_enum and is_pointer here with
341
// a predicate which asserts that comparing the underlying storage of two
342
// values of the type for equality is equivalent to comparing the two values
343
// for equality. For all the platforms we care about, this holds for integers
344
// and pointers, but there are platforms where it doesn't and we would like to
345
// support user-defined types which happen to satisfy this property.
346
template <typename T> struct is_hashable_data
347
  : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
348
                                   std::is_pointer<T>::value) &&
349
                                  64 % sizeof(T) == 0)> {};
350
351
// Special case std::pair to detect when both types are viable and when there
352
// is no alignment-derived padding in the pair. This is a bit of a lie because
353
// std::pair isn't truly POD, but it's close enough in all reasonable
354
// implementations for our use case of hashing the underlying data.
355
template <typename T, typename U> struct is_hashable_data<std::pair<T, U> >
356
  : std::integral_constant<bool, (is_hashable_data<T>::value &&
357
                                  is_hashable_data<U>::value &&
358
                                  (sizeof(T) + sizeof(U)) ==
359
                                   sizeof(std::pair<T, U>))> {};
360
361
/// Helper to get the hashable data representation for a type.
362
/// This variant is enabled when the type itself can be used.
363
template <typename T>
364
typename std::enable_if<is_hashable_data<T>::value, T>::type
365
1.00G
get_hashable_data(const T &value) {
366
1.00G
  return value;
367
1.00G
}
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
365
272M
get_hashable_data(const T &value) {
366
272M
  return value;
367
272M
}
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
365
1.75k
get_hashable_data(const T &value) {
366
1.75k
  return value;
367
1.75k
}
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
365
3.51k
get_hashable_data(const T &value) {
366
3.51k
  return value;
367
3.51k
}
Unexecuted instantiation: 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&)
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
365
272
get_hashable_data(const T &value) {
366
272
  return value;
367
272
}
std::__1::enable_if<is_hashable_data<bool>::value, bool>::type llvm::hashing::detail::get_hashable_data<bool>(bool const&)
Line
Count
Source
365
70.6M
get_hashable_data(const T &value) {
366
70.6M
  return value;
367
70.6M
}
std::__1::enable_if<is_hashable_data<int>::value, int>::type llvm::hashing::detail::get_hashable_data<int>(int const&)
Line
Count
Source
365
1.09M
get_hashable_data(const T &value) {
366
1.09M
  return value;
367
1.09M
}
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
365
6.02k
get_hashable_data(const T &value) {
366
6.02k
  return value;
367
6.02k
}
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
365
3.91M
get_hashable_data(const T &value) {
366
3.91M
  return value;
367
3.91M
}
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
365
394
get_hashable_data(const T &value) {
366
394
  return value;
367
394
}
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
365
234
get_hashable_data(const T &value) {
366
234
  return value;
367
234
}
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
365
1.73M
get_hashable_data(const T &value) {
366
1.73M
  return value;
367
1.73M
}
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
365
74.0M
get_hashable_data(const T &value) {
366
74.0M
  return value;
367
74.0M
}
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
365
26.8M
get_hashable_data(const T &value) {
366
26.8M
  return value;
367
26.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
365
15
get_hashable_data(const T &value) {
366
15
  return value;
367
15
}
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
365
771
get_hashable_data(const T &value) {
366
771
  return value;
367
771
}
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
365
18
get_hashable_data(const T &value) {
366
18
  return value;
367
18
}
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<llvm::InlineAsm::AsmDialect>::value, llvm::InlineAsm::AsmDialect>::type llvm::hashing::detail::get_hashable_data<llvm::InlineAsm::AsmDialect>(llvm::InlineAsm::AsmDialect const&)
Line
Count
Source
365
25.4k
get_hashable_data(const T &value) {
366
25.4k
  return value;
367
25.4k
}
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
365
25.4k
get_hashable_data(const T &value) {
366
25.4k
  return value;
367
25.4k
}
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
365
36.6M
get_hashable_data(const T &value) {
366
36.6M
  return value;
367
36.6M
}
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
365
17.1M
get_hashable_data(const T &value) {
366
17.1M
  return value;
367
17.1M
}
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
365
7.07M
get_hashable_data(const T &value) {
366
7.07M
  return value;
367
7.07M
}
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
365
32.8M
get_hashable_data(const T &value) {
366
32.8M
  return value;
367
32.8M
}
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
365
208k
get_hashable_data(const T &value) {
366
208k
  return value;
367
208k
}
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
365
234M
get_hashable_data(const T &value) {
366
234M
  return value;
367
234M
}
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
365
60.5k
get_hashable_data(const T &value) {
366
60.5k
  return value;
367
60.5k
}
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
365
193k
get_hashable_data(const T &value) {
366
193k
  return value;
367
193k
}
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
365
214k
get_hashable_data(const T &value) {
366
214k
  return value;
367
214k
}
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
365
48.6M
get_hashable_data(const T &value) {
366
48.6M
  return value;
367
48.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
365
25.4k
get_hashable_data(const T &value) {
366
25.4k
  return value;
367
25.4k
}
std::__1::enable_if<is_hashable_data<char>::value, char>::type llvm::hashing::detail::get_hashable_data<char>(char const&)
Line
Count
Source
365
494k
get_hashable_data(const T &value) {
366
494k
  return value;
367
494k
}
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
365
1.13k
get_hashable_data(const T &value) {
366
1.13k
  return value;
367
1.13k
}
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
365
131M
get_hashable_data(const T &value) {
366
131M
  return value;
367
131M
}
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
365
464
get_hashable_data(const T &value) {
366
464
  return value;
367
464
}
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
365
277
get_hashable_data(const T &value) {
366
277
  return value;
367
277
}
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
365
32.4k
get_hashable_data(const T &value) {
366
32.4k
  return value;
367
32.4k
}
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
365
7.49M
get_hashable_data(const T &value) {
366
7.49M
  return value;
367
7.49M
}
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
365
12.7M
get_hashable_data(const T &value) {
366
12.7M
  return value;
367
12.7M
}
std::__1::enable_if<is_hashable_data<llvm::SelectPatternFlavor>::value, llvm::SelectPatternFlavor>::type llvm::hashing::detail::get_hashable_data<llvm::SelectPatternFlavor>(llvm::SelectPatternFlavor const&)
Line
Count
Source
365
231k
get_hashable_data(const T &value) {
366
231k
  return value;
367
231k
}
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
365
8.32M
get_hashable_data(const T &value) {
366
8.32M
  return value;
367
8.32M
}
std::__1::enable_if<is_hashable_data<short>::value, short>::type llvm::hashing::detail::get_hashable_data<short>(short const&)
Line
Count
Source
365
1.00M
get_hashable_data(const T &value) {
366
1.00M
  return value;
367
1.00M
}
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<llvm::Value const*>::value, llvm::Value const*>::type llvm::hashing::detail::get_hashable_data<llvm::Value const*>(llvm::Value const* const&)
Line
Count
Source
365
697k
get_hashable_data(const T &value) {
366
697k
  return value;
367
697k
}
std::__1::enable_if<is_hashable_data<void*>::value, void*>::type llvm::hashing::detail::get_hashable_data<void*>(void* const&)
Line
Count
Source
365
44.3k
get_hashable_data(const T &value) {
366
44.3k
  return value;
367
44.3k
}
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
365
909
get_hashable_data(const T &value) {
366
909
  return value;
367
909
}
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
365
14.2M
get_hashable_data(const T &value) {
366
14.2M
  return value;
367
14.2M
}
std::__1::enable_if<is_hashable_data<long>::value, long>::type llvm::hashing::detail::get_hashable_data<long>(long const&)
Line
Count
Source
365
61.8k
get_hashable_data(const T &value) {
366
61.8k
  return value;
367
61.8k
}
std::__1::enable_if<is_hashable_data<clang::IdentifierInfo const*>::value, clang::IdentifierInfo const*>::type llvm::hashing::detail::get_hashable_data<clang::IdentifierInfo const*>(clang::IdentifierInfo const* const&)
Line
Count
Source
365
1
get_hashable_data(const T &value) {
366
1
  return value;
367
1
}
std::__1::enable_if<is_hashable_data<unsigned long>::value, unsigned long>::type llvm::hashing::detail::get_hashable_data<unsigned long>(unsigned long const&)
Line
Count
Source
365
649
get_hashable_data(const T &value) {
366
649
  return value;
367
649
}
std::__1::enable_if<is_hashable_data<llvm::wasm::ValType>::value, llvm::wasm::ValType>::type llvm::hashing::detail::get_hashable_data<llvm::wasm::ValType>(llvm::wasm::ValType const&)
Line
Count
Source
365
624
get_hashable_data(const T &value) {
366
624
  return value;
367
624
}
std::__1::enable_if<is_hashable_data<lld::DefinedAtom::ContentType>::value, lld::DefinedAtom::ContentType>::type llvm::hashing::detail::get_hashable_data<lld::DefinedAtom::ContentType>(lld::DefinedAtom::ContentType const&)
Line
Count
Source
365
54
get_hashable_data(const T &value) {
366
54
  return value;
367
54
}
368
/// Helper to get the hashable data representation for a type.
369
/// This variant is enabled when we must first call hash_value and use the
370
/// result as our data.
371
template <typename T>
372
typename std::enable_if<!is_hashable_data<T>::value, size_t>::type
373
101M
get_hashable_data(const T &value) {
374
101M
  using ::llvm::hash_value;
375
101M
  return hash_value(value);
376
101M
}
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
373
101M
get_hashable_data(const T &value) {
374
101M
  using ::llvm::hash_value;
375
101M
  return hash_value(value);
376
101M
}
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
373
390k
get_hashable_data(const T &value) {
374
390k
  using ::llvm::hash_value;
375
390k
  return hash_value(value);
376
390k
}
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
373
51.7k
get_hashable_data(const T &value) {
374
51.7k
  using ::llvm::hash_value;
375
51.7k
  return hash_value(value);
376
51.7k
}
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
373
18.4k
get_hashable_data(const T &value) {
374
18.4k
  using ::llvm::hash_value;
375
18.4k
  return hash_value(value);
376
18.4k
}
377
378
/// Helper to store data from a value into a buffer and advance the
379
/// pointer into that buffer.
380
///
381
/// This routine first checks whether there is enough space in the provided
382
/// buffer, and if not immediately returns false. If there is space, it
383
/// copies the underlying bytes of value into the buffer, advances the
384
/// buffer_ptr past the copied bytes, and returns true.
385
template <typename T>
386
bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value,
387
1.14G
                       size_t offset = 0) {
388
1.14G
  size_t store_size = sizeof(value) - offset;
389
1.14G
  if (buffer_ptr + store_size > buffer_end)
390
4.62M
    return false;
391
1.13G
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.13G
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.13G
  buffer_ptr += store_size;
394
1.13G
  return true;
395
1.13G
}
bool llvm::hashing::detail::store_and_advance<unsigned int>(char*&, char*, unsigned int const&, unsigned long)
Line
Count
Source
387
272M
                       size_t offset = 0) {
388
272M
  size_t store_size = sizeof(value) - offset;
389
272M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
272M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
272M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
272M
  buffer_ptr += store_size;
394
272M
  return true;
395
272M
}
bool llvm::hashing::detail::store_and_advance<unsigned long>(char*&, char*, unsigned long const&, unsigned long)
Line
Count
Source
387
101M
                       size_t offset = 0) {
388
101M
  size_t store_size = sizeof(value) - offset;
389
101M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
101M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
101M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
101M
  buffer_ptr += store_size;
394
101M
  return true;
395
101M
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::CounterExpression::ExprKind>(char*&, char*, llvm::coverage::CounterExpression::ExprKind const&, unsigned long)
Line
Count
Source
387
1.75k
                       size_t offset = 0) {
388
1.75k
  size_t store_size = sizeof(value) - offset;
389
1.75k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
1.75k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.75k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.75k
  buffer_ptr += store_size;
394
1.75k
  return true;
395
1.75k
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::Counter::CounterKind>(char*&, char*, llvm::coverage::Counter::CounterKind const&, unsigned long)
Line
Count
Source
387
3.51k
                       size_t offset = 0) {
388
3.51k
  size_t store_size = sizeof(value) - offset;
389
3.51k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
3.51k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
3.51k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
3.51k
  buffer_ptr += store_size;
394
3.51k
  return true;
395
3.51k
}
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::Loop const*>(char*&, char*, llvm::Loop const* const&, unsigned long)
bool llvm::hashing::detail::store_and_advance<llvm::BasicBlock*>(char*&, char*, llvm::BasicBlock* const&, unsigned long)
Line
Count
Source
387
272
                       size_t offset = 0) {
388
272
  size_t store_size = sizeof(value) - offset;
389
272
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
272
  const char *value_data = reinterpret_cast<const char *>(&value);
392
272
  memcpy(buffer_ptr, value_data + offset, store_size);
393
272
  buffer_ptr += store_size;
394
272
  return true;
395
272
}
bool llvm::hashing::detail::store_and_advance<bool>(char*&, char*, bool const&, unsigned long)
Line
Count
Source
387
70.6M
                       size_t offset = 0) {
388
70.6M
  size_t store_size = sizeof(value) - offset;
389
70.6M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
70.6M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
70.6M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
70.6M
  buffer_ptr += store_size;
394
70.6M
  return true;
395
70.6M
}
bool llvm::hashing::detail::store_and_advance<int>(char*&, char*, int const&, unsigned long)
Line
Count
Source
387
1.09M
                       size_t offset = 0) {
388
1.09M
  size_t store_size = sizeof(value) - offset;
389
1.09M
  if (buffer_ptr + store_size > buffer_end)
390
4
    return false;
391
1.09M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.09M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.09M
  buffer_ptr += store_size;
394
1.09M
  return true;
395
1.09M
}
bool llvm::hashing::detail::store_and_advance<char const*>(char*&, char*, char const* const&, unsigned long)
Line
Count
Source
387
6.02k
                       size_t offset = 0) {
388
6.02k
  size_t store_size = sizeof(value) - offset;
389
6.02k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
6.02k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
6.02k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
6.02k
  buffer_ptr += store_size;
394
6.02k
  return true;
395
6.02k
}
bool llvm::hashing::detail::store_and_advance<llvm::GlobalValue const*>(char*&, char*, llvm::GlobalValue const* const&, unsigned long)
Line
Count
Source
387
3.91M
                       size_t offset = 0) {
388
3.91M
  size_t store_size = sizeof(value) - offset;
389
3.91M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
3.91M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
3.91M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
3.91M
  buffer_ptr += store_size;
394
3.91M
  return true;
395
3.91M
}
bool llvm::hashing::detail::store_and_advance<llvm::BlockAddress const*>(char*&, char*, llvm::BlockAddress const* const&, unsigned long)
Line
Count
Source
387
394
                       size_t offset = 0) {
388
394
  size_t store_size = sizeof(value) - offset;
389
394
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
394
  const char *value_data = reinterpret_cast<const char *>(&value);
392
394
  memcpy(buffer_ptr, value_data + offset, store_size);
393
394
  buffer_ptr += store_size;
394
394
  return true;
395
394
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol*>(char*&, char*, llvm::MCSymbol* const&, unsigned long)
Line
Count
Source
387
234
                       size_t offset = 0) {
388
234
  size_t store_size = sizeof(value) - offset;
389
234
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
234
  const char *value_data = reinterpret_cast<const char *>(&value);
392
234
  memcpy(buffer_ptr, value_data + offset, store_size);
393
234
  buffer_ptr += store_size;
394
234
  return true;
395
234
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineBasicBlock*>(char*&, char*, llvm::MachineBasicBlock* const&, unsigned long)
Line
Count
Source
387
1.73M
                       size_t offset = 0) {
388
1.73M
  size_t store_size = sizeof(value) - offset;
389
1.73M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
1.73M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.73M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.73M
  buffer_ptr += store_size;
394
1.73M
  return true;
395
1.73M
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineOperand::MachineOperandType>(char*&, char*, llvm::MachineOperand::MachineOperandType const&, unsigned long)
Line
Count
Source
387
74.0M
                       size_t offset = 0) {
388
74.0M
  size_t store_size = sizeof(value) - offset;
389
74.0M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
74.0M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
74.0M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
74.0M
  buffer_ptr += store_size;
394
74.0M
  return true;
395
74.0M
}
bool llvm::hashing::detail::store_and_advance<long long>(char*&, char*, long long const&, unsigned long)
Line
Count
Source
387
26.8M
                       size_t offset = 0) {
388
26.8M
  size_t store_size = sizeof(value) - offset;
389
26.8M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
26.8M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
26.8M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
26.8M
  buffer_ptr += store_size;
394
26.8M
  return true;
395
26.8M
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantInt const*>(char*&, char*, llvm::ConstantInt const* const&, unsigned long)
Line
Count
Source
387
15
                       size_t offset = 0) {
388
15
  size_t store_size = sizeof(value) - offset;
389
15
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
15
  const char *value_data = reinterpret_cast<const char *>(&value);
392
15
  memcpy(buffer_ptr, value_data + offset, store_size);
393
15
  buffer_ptr += store_size;
394
15
  return true;
395
15
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantFP const*>(char*&, char*, llvm::ConstantFP const* const&, unsigned long)
Line
Count
Source
387
771
                       size_t offset = 0) {
388
771
  size_t store_size = sizeof(value) - offset;
389
771
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
771
  const char *value_data = reinterpret_cast<const char *>(&value);
392
771
  memcpy(buffer_ptr, value_data + offset, store_size);
393
771
  buffer_ptr += store_size;
394
771
  return true;
395
771
}
bool llvm::hashing::detail::store_and_advance<unsigned int const*>(char*&, char*, unsigned int const* const&, unsigned long)
Line
Count
Source
387
18
                       size_t offset = 0) {
388
18
  size_t store_size = sizeof(value) - offset;
389
18
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
18
  const char *value_data = reinterpret_cast<const char *>(&value);
392
18
  memcpy(buffer_ptr, value_data + offset, store_size);
393
18
  buffer_ptr += store_size;
394
18
  return true;
395
18
}
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<llvm::InlineAsm::AsmDialect>(char*&, char*, llvm::InlineAsm::AsmDialect const&, unsigned long)
Line
Count
Source
387
25.4k
                       size_t offset = 0) {
388
25.4k
  size_t store_size = sizeof(value) - offset;
389
25.4k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
25.4k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
25.4k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
25.4k
  buffer_ptr += store_size;
394
25.4k
  return true;
395
25.4k
}
bool llvm::hashing::detail::store_and_advance<llvm::FunctionType*>(char*&, char*, llvm::FunctionType* const&, unsigned long)
Line
Count
Source
387
25.4k
                       size_t offset = 0) {
388
25.4k
  size_t store_size = sizeof(value) - offset;
389
25.4k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
25.4k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
25.4k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
25.4k
  buffer_ptr += store_size;
394
25.4k
  return true;
395
25.4k
}
bool llvm::hashing::detail::store_and_advance<unsigned char>(char*&, char*, unsigned char const&, unsigned long)
Line
Count
Source
387
36.6M
                       size_t offset = 0) {
388
36.6M
  size_t store_size = sizeof(value) - offset;
389
36.6M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
36.6M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
36.6M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
36.6M
  buffer_ptr += store_size;
394
36.6M
  return true;
395
36.6M
}
bool llvm::hashing::detail::store_and_advance<unsigned short>(char*&, char*, unsigned short const&, unsigned long)
Line
Count
Source
387
17.1M
                       size_t offset = 0) {
388
17.1M
  size_t store_size = sizeof(value) - offset;
389
17.1M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
17.1M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
17.1M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
17.1M
  buffer_ptr += store_size;
394
17.1M
  return true;
395
17.1M
}
bool llvm::hashing::detail::store_and_advance<llvm::Type const*>(char*&, char*, llvm::Type const* const&, unsigned long)
Line
Count
Source
387
7.07M
                       size_t offset = 0) {
388
7.07M
  size_t store_size = sizeof(value) - offset;
389
7.07M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
7.07M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
7.07M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
7.07M
  buffer_ptr += store_size;
394
7.07M
  return true;
395
7.07M
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata*>(char*&, char*, llvm::Metadata* const&, unsigned long)
Line
Count
Source
387
32.8M
                       size_t offset = 0) {
388
32.8M
  size_t store_size = sizeof(value) - offset;
389
32.8M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
32.8M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
32.8M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
32.8M
  buffer_ptr += store_size;
394
32.8M
  return true;
395
32.8M
}
bool llvm::hashing::detail::store_and_advance<llvm::MDString*>(char*&, char*, llvm::MDString* const&, unsigned long)
Line
Count
Source
387
208k
                       size_t offset = 0) {
388
208k
  size_t store_size = sizeof(value) - offset;
389
208k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
208k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
208k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
208k
  buffer_ptr += store_size;
394
208k
  return true;
395
208k
}
bool llvm::hashing::detail::store_and_advance<unsigned long long>(char*&, char*, unsigned long long const&, unsigned long)
Line
Count
Source
387
234M
                       size_t offset = 0) {
388
234M
  size_t store_size = sizeof(value) - offset;
389
234M
  if (buffer_ptr + store_size > buffer_end)
390
2
    return false;
391
234M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
234M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
234M
  buffer_ptr += store_size;
394
234M
  return true;
395
234M
}
bool llvm::hashing::detail::store_and_advance<llvm::ArrayType*>(char*&, char*, llvm::ArrayType* const&, unsigned long)
Line
Count
Source
387
60.5k
                       size_t offset = 0) {
388
60.5k
  size_t store_size = sizeof(value) - offset;
389
60.5k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
60.5k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
60.5k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
60.5k
  buffer_ptr += store_size;
394
60.5k
  return true;
395
60.5k
}
bool llvm::hashing::detail::store_and_advance<llvm::StructType*>(char*&, char*, llvm::StructType* const&, unsigned long)
Line
Count
Source
387
193k
                       size_t offset = 0) {
388
193k
  size_t store_size = sizeof(value) - offset;
389
193k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
193k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
193k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
193k
  buffer_ptr += store_size;
394
193k
  return true;
395
193k
}
bool llvm::hashing::detail::store_and_advance<llvm::VectorType*>(char*&, char*, llvm::VectorType* const&, unsigned long)
Line
Count
Source
387
214k
                       size_t offset = 0) {
388
214k
  size_t store_size = sizeof(value) - offset;
389
214k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
214k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
214k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
214k
  buffer_ptr += store_size;
394
214k
  return true;
395
214k
}
bool llvm::hashing::detail::store_and_advance<llvm::Type*>(char*&, char*, llvm::Type* const&, unsigned long)
Line
Count
Source
387
48.6M
                       size_t offset = 0) {
388
48.6M
  size_t store_size = sizeof(value) - offset;
389
48.6M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
48.6M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
48.6M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
48.6M
  buffer_ptr += store_size;
394
48.6M
  return true;
395
48.6M
}
bool llvm::hashing::detail::store_and_advance<llvm::PointerType*>(char*&, char*, llvm::PointerType* const&, unsigned long)
Line
Count
Source
387
25.4k
                       size_t offset = 0) {
388
25.4k
  size_t store_size = sizeof(value) - offset;
389
25.4k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
25.4k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
25.4k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
25.4k
  buffer_ptr += store_size;
394
25.4k
  return true;
395
25.4k
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata const*>(char*&, char*, llvm::Metadata const* const&, unsigned long)
Line
Count
Source
387
37.0M
                       size_t offset = 0) {
388
37.0M
  size_t store_size = sizeof(value) - offset;
389
37.0M
  if (buffer_ptr + store_size > buffer_end)
390
4.09M
    return false;
391
32.9M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
32.9M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
32.9M
  buffer_ptr += store_size;
394
32.9M
  return true;
395
32.9M
}
bool llvm::hashing::detail::store_and_advance<char>(char*&, char*, char const&, unsigned long)
Line
Count
Source
387
494k
                       size_t offset = 0) {
388
494k
  size_t store_size = sizeof(value) - offset;
389
494k
  if (buffer_ptr + store_size > buffer_end)
390
3.89k
    return false;
391
490k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
490k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
490k
  buffer_ptr += store_size;
394
490k
  return true;
395
490k
}
bool llvm::hashing::detail::store_and_advance<llvm::MemoryAccess const*>(char*&, char*, llvm::MemoryAccess const* const&, unsigned long)
Line
Count
Source
387
1.13k
                       size_t offset = 0) {
388
1.13k
  size_t store_size = sizeof(value) - offset;
389
1.13k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
1.13k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.13k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.13k
  buffer_ptr += store_size;
394
1.13k
  return true;
395
1.13k
}
bool llvm::hashing::detail::store_and_advance<llvm::Value*>(char*&, char*, llvm::Value* const&, unsigned long)
Line
Count
Source
387
131M
                       size_t offset = 0) {
388
131M
  size_t store_size = sizeof(value) - offset;
389
131M
  if (buffer_ptr + store_size > buffer_end)
390
524k
    return false;
391
131M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
131M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
131M
  buffer_ptr += store_size;
394
131M
  return true;
395
131M
}
bool llvm::hashing::detail::store_and_advance<llvm::Constant*>(char*&, char*, llvm::Constant* const&, unsigned long)
Line
Count
Source
387
464
                       size_t offset = 0) {
388
464
  size_t store_size = sizeof(value) - offset;
389
464
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
464
  const char *value_data = reinterpret_cast<const char *>(&value);
392
464
  memcpy(buffer_ptr, value_data + offset, store_size);
393
464
  buffer_ptr += store_size;
394
464
  return true;
395
464
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction*>(char*&, char*, llvm::Instruction* const&, unsigned long)
Line
Count
Source
387
277
                       size_t offset = 0) {
388
277
  size_t store_size = sizeof(value) - offset;
389
277
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
277
  const char *value_data = reinterpret_cast<const char *>(&value);
392
277
  memcpy(buffer_ptr, value_data + offset, store_size);
393
277
  buffer_ptr += store_size;
394
277
  return true;
395
277
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol const*>(char*&, char*, llvm::MCSymbol const* const&, unsigned long)
Line
Count
Source
387
32.4k
                       size_t offset = 0) {
388
32.4k
  size_t store_size = sizeof(value) - offset;
389
32.4k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
32.4k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
32.4k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
32.4k
  buffer_ptr += store_size;
394
32.4k
  return true;
395
32.4k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::BinaryOps>(char*&, char*, llvm::Instruction::BinaryOps const&, unsigned long)
Line
Count
Source
387
7.49M
                       size_t offset = 0) {
388
7.49M
  size_t store_size = sizeof(value) - offset;
389
7.49M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
7.49M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
7.49M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
7.49M
  buffer_ptr += store_size;
394
7.49M
  return true;
395
7.49M
}
bool llvm::hashing::detail::store_and_advance<llvm::CmpInst::Predicate>(char*&, char*, llvm::CmpInst::Predicate const&, unsigned long)
Line
Count
Source
387
12.7M
                       size_t offset = 0) {
388
12.7M
  size_t store_size = sizeof(value) - offset;
389
12.7M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
12.7M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
12.7M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
12.7M
  buffer_ptr += store_size;
394
12.7M
  return true;
395
12.7M
}
bool llvm::hashing::detail::store_and_advance<llvm::SelectPatternFlavor>(char*&, char*, llvm::SelectPatternFlavor const&, unsigned long)
Line
Count
Source
387
231k
                       size_t offset = 0) {
388
231k
  size_t store_size = sizeof(value) - offset;
389
231k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
231k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
231k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
231k
  buffer_ptr += store_size;
394
231k
  return true;
395
231k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::CastOps>(char*&, char*, llvm::Instruction::CastOps const&, unsigned long)
Line
Count
Source
387
8.32M
                       size_t offset = 0) {
388
8.32M
  size_t store_size = sizeof(value) - offset;
389
8.32M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
8.32M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
8.32M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
8.32M
  buffer_ptr += store_size;
394
8.32M
  return true;
395
8.32M
}
bool llvm::hashing::detail::store_and_advance<short>(char*&, char*, short const&, unsigned long)
Line
Count
Source
387
1.00M
                       size_t offset = 0) {
388
1.00M
  size_t store_size = sizeof(value) - offset;
389
1.00M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
1.00M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1.00M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1.00M
  buffer_ptr += store_size;
394
1.00M
  return true;
395
1.00M
}
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
387
697k
                       size_t offset = 0) {
388
697k
  size_t store_size = sizeof(value) - offset;
389
697k
  if (buffer_ptr + store_size > buffer_end)
390
762
    return false;
391
696k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
696k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
696k
  buffer_ptr += store_size;
394
696k
  return true;
395
696k
}
bool llvm::hashing::detail::store_and_advance<void*>(char*&, char*, void* const&, unsigned long)
Line
Count
Source
387
44.3k
                       size_t offset = 0) {
388
44.3k
  size_t store_size = sizeof(value) - offset;
389
44.3k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
44.3k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
44.3k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
44.3k
  buffer_ptr += store_size;
394
44.3k
  return true;
395
44.3k
}
bool llvm::hashing::detail::store_and_advance<clang::NestedNameSpecifier*>(char*&, char*, clang::NestedNameSpecifier* const&, unsigned long)
Line
Count
Source
387
909
                       size_t offset = 0) {
388
909
  size_t store_size = sizeof(value) - offset;
389
909
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
909
  const char *value_data = reinterpret_cast<const char *>(&value);
392
909
  memcpy(buffer_ptr, value_data + offset, store_size);
393
909
  buffer_ptr += store_size;
394
909
  return true;
395
909
}
bool llvm::hashing::detail::store_and_advance<llvm::RegisterBankInfo::ValueMapping const*>(char*&, char*, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned long)
Line
Count
Source
387
14.2M
                       size_t offset = 0) {
388
14.2M
  size_t store_size = sizeof(value) - offset;
389
14.2M
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
14.2M
  const char *value_data = reinterpret_cast<const char *>(&value);
392
14.2M
  memcpy(buffer_ptr, value_data + offset, store_size);
393
14.2M
  buffer_ptr += store_size;
394
14.2M
  return true;
395
14.2M
}
bool llvm::hashing::detail::store_and_advance<long>(char*&, char*, long const&, unsigned long)
Line
Count
Source
387
61.8k
                       size_t offset = 0) {
388
61.8k
  size_t store_size = sizeof(value) - offset;
389
61.8k
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
61.8k
  const char *value_data = reinterpret_cast<const char *>(&value);
392
61.8k
  memcpy(buffer_ptr, value_data + offset, store_size);
393
61.8k
  buffer_ptr += store_size;
394
61.8k
  return true;
395
61.8k
}
bool llvm::hashing::detail::store_and_advance<clang::IdentifierInfo const*>(char*&, char*, clang::IdentifierInfo const* const&, unsigned long)
Line
Count
Source
387
1
                       size_t offset = 0) {
388
1
  size_t store_size = sizeof(value) - offset;
389
1
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
1
  const char *value_data = reinterpret_cast<const char *>(&value);
392
1
  memcpy(buffer_ptr, value_data + offset, store_size);
393
1
  buffer_ptr += store_size;
394
1
  return true;
395
1
}
bool llvm::hashing::detail::store_and_advance<llvm::wasm::ValType>(char*&, char*, llvm::wasm::ValType const&, unsigned long)
Line
Count
Source
387
624
                       size_t offset = 0) {
388
624
  size_t store_size = sizeof(value) - offset;
389
624
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
624
  const char *value_data = reinterpret_cast<const char *>(&value);
392
624
  memcpy(buffer_ptr, value_data + offset, store_size);
393
624
  buffer_ptr += store_size;
394
624
  return true;
395
624
}
bool llvm::hashing::detail::store_and_advance<lld::DefinedAtom::ContentType>(char*&, char*, lld::DefinedAtom::ContentType const&, unsigned long)
Line
Count
Source
387
54
                       size_t offset = 0) {
388
54
  size_t store_size = sizeof(value) - offset;
389
54
  if (buffer_ptr + store_size > buffer_end)
390
0
    return false;
391
54
  const char *value_data = reinterpret_cast<const char *>(&value);
392
54
  memcpy(buffer_ptr, value_data + offset, store_size);
393
54
  buffer_ptr += store_size;
394
54
  return true;
395
54
}
396
397
/// Implement the combining of integral values into a hash_code.
398
///
399
/// This overload is selected when the value type of the iterator is
400
/// integral. Rather than computing a hash_code for each object and then
401
/// combining them, this (as an optimization) directly combines the integers.
402
template <typename InputIteratorT>
403
26.4M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
26.4M
  const uint64_t seed = get_execution_seed();
405
26.4M
  char buffer[64], *buffer_ptr = buffer;
406
26.4M
  char *const buffer_end = std::end(buffer);
407
106M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
80.2M
                                            get_hashable_data(*first)))
409
79.8M
    ++first;
410
26.4M
  if (first == last)
411
26.0M
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
384k
  assert(buffer_ptr == buffer_end);
413
384k
414
384k
  hash_state state = state.create(buffer, seed);
415
384k
  size_t length = 64;
416
5.01M
  while (first != last) {
417
4.62M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
4.62M
    // when only a partial 64-byte chunk is left.
419
4.62M
    buffer_ptr = buffer;
420
40.0M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
39.6M
                                              get_hashable_data(*first)))
422
35.3M
      ++first;
423
4.62M
424
4.62M
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
4.62M
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
4.62M
    // have a contiguous byte sequence, and we want to emulate that here.
427
4.62M
    std::rotate(buffer, buffer_ptr, buffer_end);
428
4.62M
429
4.62M
    // Mix this chunk into the current state.
430
4.62M
    state.mix(buffer);
431
4.62M
    length += buffer_ptr - buffer;
432
4.62M
  };
433
384k
434
384k
  return state.finalize(length);
435
384k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
403
42.3k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
42.3k
  const uint64_t seed = get_execution_seed();
405
42.3k
  char buffer[64], *buffer_ptr = buffer;
406
42.3k
  char *const buffer_end = std::end(buffer);
407
284k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
258k
                                            get_hashable_data(*first)))
409
242k
    ++first;
410
42.3k
  if (first == last)
411
25.8k
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
16.5k
  assert(buffer_ptr == buffer_end);
413
16.5k
414
16.5k
  hash_state state = state.create(buffer, seed);
415
16.5k
  size_t length = 64;
416
4.11M
  while (first != last) {
417
4.09M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
4.09M
    // when only a partial 64-byte chunk is left.
419
4.09M
    buffer_ptr = buffer;
420
36.8M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
36.7M
                                              get_hashable_data(*first)))
422
32.7M
      ++first;
423
4.09M
424
4.09M
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
4.09M
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
4.09M
    // have a contiguous byte sequence, and we want to emulate that here.
427
4.09M
    std::rotate(buffer, buffer_ptr, buffer_end);
428
4.09M
429
4.09M
    // Mix this chunk into the current state.
430
4.09M
    state.mix(buffer);
431
4.09M
    length += buffer_ptr - buffer;
432
4.09M
  };
433
16.5k
434
16.5k
  return state.finalize(length);
435
16.5k
}
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
403
20.5k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
20.5k
  const uint64_t seed = get_execution_seed();
405
20.5k
  char buffer[64], *buffer_ptr = buffer;
406
20.5k
  char *const buffer_end = std::end(buffer);
407
374k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
357k
                                            get_hashable_data(*first)))
409
353k
    ++first;
410
20.5k
  if (first == last)
411
16.8k
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
3.73k
  assert(buffer_ptr == buffer_end);
413
3.73k
414
3.73k
  hash_state state = state.create(buffer, seed);
415
3.73k
  size_t length = 64;
416
7.62k
  while (first != last) {
417
3.89k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
3.89k
    // when only a partial 64-byte chunk is left.
419
3.89k
    buffer_ptr = buffer;
420
140k
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
136k
                                              get_hashable_data(*first)))
422
136k
      ++first;
423
3.89k
424
3.89k
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
3.89k
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
3.89k
    // have a contiguous byte sequence, and we want to emulate that here.
427
3.89k
    std::rotate(buffer, buffer_ptr, buffer_end);
428
3.89k
429
3.89k
    // Mix this chunk into the current state.
430
3.89k
    state.mix(buffer);
431
3.89k
    length += buffer_ptr - buffer;
432
3.89k
  };
433
3.73k
434
3.73k
  return state.finalize(length);
435
3.73k
}
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
403
26.0M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
26.0M
  const uint64_t seed = get_execution_seed();
405
26.0M
  char buffer[64], *buffer_ptr = buffer;
406
26.0M
  char *const buffer_end = std::end(buffer);
407
104M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
78.9M
                                            get_hashable_data(*first)))
409
78.5M
    ++first;
410
26.0M
  if (first == last)
411
25.7M
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
363k
  assert(buffer_ptr == buffer_end);
413
363k
414
363k
  hash_state state = state.create(buffer, seed);
415
363k
  size_t length = 64;
416
887k
  while (first != last) {
417
524k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
524k
    // when only a partial 64-byte chunk is left.
419
524k
    buffer_ptr = buffer;
420
3.05M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
2.69M
                                              get_hashable_data(*first)))
422
2.53M
      ++first;
423
524k
424
524k
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
524k
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
524k
    // have a contiguous byte sequence, and we want to emulate that here.
427
524k
    std::rotate(buffer, buffer_ptr, buffer_end);
428
524k
429
524k
    // Mix this chunk into the current state.
430
524k
    state.mix(buffer);
431
524k
    length += buffer_ptr - buffer;
432
524k
  };
433
363k
434
363k
  return state.finalize(length);
435
363k
}
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
403
270k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
270k
  const uint64_t seed = get_execution_seed();
405
270k
  char buffer[64], *buffer_ptr = buffer;
406
270k
  char *const buffer_end = std::end(buffer);
407
965k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
695k
                                            get_hashable_data(*first)))
409
694k
    ++first;
410
270k
  if (first == last)
411
270k
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
762
  assert(buffer_ptr == buffer_end);
413
762
414
762
  hash_state state = state.create(buffer, seed);
415
762
  size_t length = 64;
416
1.52k
  while (first != last) {
417
762
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
762
    // when only a partial 64-byte chunk is left.
419
762
    buffer_ptr = buffer;
420
2.19k
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
1.43k
                                              get_hashable_data(*first)))
422
1.43k
      ++first;
423
762
424
762
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
762
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
762
    // have a contiguous byte sequence, and we want to emulate that here.
427
762
    std::rotate(buffer, buffer_ptr, buffer_end);
428
762
429
762
    // Mix this chunk into the current state.
430
762
    state.mix(buffer);
431
762
    length += buffer_ptr - buffer;
432
762
  };
433
762
434
762
  return state.finalize(length);
435
762
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
403
496
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
496
  const uint64_t seed = get_execution_seed();
405
496
  char buffer[64], *buffer_ptr = buffer;
406
496
  char *const buffer_end = std::end(buffer);
407
1.05k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
560
                                            get_hashable_data(*first)))
409
560
    ++first;
410
496
  if (first == last)
411
496
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
0
  assert(buffer_ptr == buffer_end);
413
0
414
0
  hash_state state = state.create(buffer, seed);
415
0
  size_t length = 64;
416
0
  while (first != last) {
417
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
0
    // when only a partial 64-byte chunk is left.
419
0
    buffer_ptr = buffer;
420
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
0
                                              get_hashable_data(*first)))
422
0
      ++first;
423
0
424
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
0
    // have a contiguous byte sequence, and we want to emulate that here.
427
0
    std::rotate(buffer, buffer_ptr, buffer_end);
428
0
429
0
    // Mix this chunk into the current state.
430
0
    state.mix(buffer);
431
0
    length += buffer_ptr - buffer;
432
0
  };
433
0
434
0
  return state.finalize(length);
435
0
}
ItaniumCXXABI.cpp:llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<(anonymous namespace)::DecompositionDeclName::Iterator>((anonymous namespace)::DecompositionDeclName::Iterator, (anonymous namespace)::DecompositionDeclName::Iterator)
Line
Count
Source
403
1
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
404
1
  const uint64_t seed = get_execution_seed();
405
1
  char buffer[64], *buffer_ptr = buffer;
406
1
  char *const buffer_end = std::end(buffer);
407
2
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
408
1
                                            get_hashable_data(*first)))
409
1
    ++first;
410
1
  if (first == last)
411
1
    return hash_short(buffer, buffer_ptr - buffer, seed);
412
0
  assert(buffer_ptr == buffer_end);
413
0
414
0
  hash_state state = state.create(buffer, seed);
415
0
  size_t length = 64;
416
0
  while (first != last) {
417
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
418
0
    // when only a partial 64-byte chunk is left.
419
0
    buffer_ptr = buffer;
420
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
421
0
                                              get_hashable_data(*first)))
422
0
      ++first;
423
0
424
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
425
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
426
0
    // have a contiguous byte sequence, and we want to emulate that here.
427
0
    std::rotate(buffer, buffer_ptr, buffer_end);
428
0
429
0
    // Mix this chunk into the current state.
430
0
    state.mix(buffer);
431
0
    length += buffer_ptr - buffer;
432
0
  };
433
0
434
0
  return state.finalize(length);
435
0
}
436
437
/// Implement the combining of integral values into a hash_code.
438
///
439
/// This overload is selected when the value type of the iterator is integral
440
/// and when the input iterator is actually a pointer. Rather than computing
441
/// a hash_code for each object and then combining them, this (as an
442
/// optimization) directly combines the integers. Also, because the integers
443
/// are stored in contiguous memory, this routine avoids copying each value
444
/// and directly reads from the underlying memory.
445
template <typename ValueT>
446
typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type
447
719M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
719M
  const uint64_t seed = get_execution_seed();
449
719M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
719M
  const char *s_end = reinterpret_cast<const char *>(last);
451
719M
  const size_t length = std::distance(s_begin, s_end);
452
719M
  if (length <= 64)
453
693M
    return hash_short(s_begin, length, seed);
454
26.3M
455
26.3M
  const char *s_aligned_end = s_begin + (length & ~63);
456
26.3M
  hash_state state = state.create(s_begin, seed);
457
26.3M
  s_begin += 64;
458
52.1M
  while (s_begin != s_aligned_end) {
459
25.8M
    state.mix(s_begin);
460
25.8M
    s_begin += 64;
461
25.8M
  }
462
26.3M
  if (length & 63)
463
25.6M
    state.mix(s_end - 64);
464
26.3M
465
26.3M
  return state.finalize(length);
466
26.3M
}
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
447
2.02k
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
2.02k
  const uint64_t seed = get_execution_seed();
449
2.02k
  const char *s_begin = reinterpret_cast<const char *>(first);
450
2.02k
  const char *s_end = reinterpret_cast<const char *>(last);
451
2.02k
  const size_t length = std::distance(s_begin, s_end);
452
2.02k
  if (length <= 64)
453
192
    return hash_short(s_begin, length, seed);
454
1.83k
455
1.83k
  const char *s_aligned_end = s_begin + (length & ~63);
456
1.83k
  hash_state state = state.create(s_begin, seed);
457
1.83k
  s_begin += 64;
458
29.0k
  while (s_begin != s_aligned_end) {
459
27.2k
    state.mix(s_begin);
460
27.2k
    s_begin += 64;
461
27.2k
  }
462
1.83k
  if (length & 63)
463
1.51k
    state.mix(s_end - 64);
464
1.83k
465
1.83k
  return state.finalize(length);
466
1.83k
}
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
447
24.2M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
24.2M
  const uint64_t seed = get_execution_seed();
449
24.2M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
24.2M
  const char *s_end = reinterpret_cast<const char *>(last);
451
24.2M
  const size_t length = std::distance(s_begin, s_end);
452
24.2M
  if (length <= 64)
453
23.4M
    return hash_short(s_begin, length, seed);
454
833k
455
833k
  const char *s_aligned_end = s_begin + (length & ~63);
456
833k
  hash_state state = state.create(s_begin, seed);
457
833k
  s_begin += 64;
458
996k
  while (s_begin != s_aligned_end) {
459
163k
    state.mix(s_begin);
460
163k
    s_begin += 64;
461
163k
  }
462
833k
  if (length & 63)
463
833k
    state.mix(s_end - 64);
464
833k
465
833k
  return state.finalize(length);
466
833k
}
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
447
17.6M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
17.6M
  const uint64_t seed = get_execution_seed();
449
17.6M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
17.6M
  const char *s_end = reinterpret_cast<const char *>(last);
451
17.6M
  const size_t length = std::distance(s_begin, s_end);
452
17.6M
  if (length <= 64)
453
17.5M
    return hash_short(s_begin, length, seed);
454
46.8k
455
46.8k
  const char *s_aligned_end = s_begin + (length & ~63);
456
46.8k
  hash_state state = state.create(s_begin, seed);
457
46.8k
  s_begin += 64;
458
115k
  while (s_begin != s_aligned_end) {
459
68.3k
    state.mix(s_begin);
460
68.3k
    s_begin += 64;
461
68.3k
  }
462
46.8k
  if (length & 63)
463
21.1k
    state.mix(s_end - 64);
464
46.8k
465
46.8k
  return state.finalize(length);
466
46.8k
}
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
447
621M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
621M
  const uint64_t seed = get_execution_seed();
449
621M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
621M
  const char *s_end = reinterpret_cast<const char *>(last);
451
621M
  const size_t length = std::distance(s_begin, s_end);
452
621M
  if (length <= 64)
453
596M
    return hash_short(s_begin, length, seed);
454
25.1M
455
25.1M
  const char *s_aligned_end = s_begin + (length & ~63);
456
25.1M
  hash_state state = state.create(s_begin, seed);
457
25.1M
  s_begin += 64;
458
49.5M
  while (s_begin != s_aligned_end) {
459
24.4M
    state.mix(s_begin);
460
24.4M
    s_begin += 64;
461
24.4M
  }
462
25.1M
  if (length & 63)
463
24.4M
    state.mix(s_end - 64);
464
25.1M
465
25.1M
  return state.finalize(length);
466
25.1M
}
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
447
7.20M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
7.20M
  const uint64_t seed = get_execution_seed();
449
7.20M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
7.20M
  const char *s_end = reinterpret_cast<const char *>(last);
451
7.20M
  const size_t length = std::distance(s_begin, s_end);
452
7.20M
  if (length <= 64)
453
7.17M
    return hash_short(s_begin, length, seed);
454
31.7k
455
31.7k
  const char *s_aligned_end = s_begin + (length & ~63);
456
31.7k
  hash_state state = state.create(s_begin, seed);
457
31.7k
  s_begin += 64;
458
42.6k
  while (s_begin != s_aligned_end) {
459
10.9k
    state.mix(s_begin);
460
10.9k
    s_begin += 64;
461
10.9k
  }
462
31.7k
  if (length & 63)
463
31.2k
    state.mix(s_end - 64);
464
31.7k
465
31.7k
  return state.finalize(length);
466
31.7k
}
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
447
1.01M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
1.01M
  const uint64_t seed = get_execution_seed();
449
1.01M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
1.01M
  const char *s_end = reinterpret_cast<const char *>(last);
451
1.01M
  const size_t length = std::distance(s_begin, s_end);
452
1.01M
  if (length <= 64)
453
1.01M
    return hash_short(s_begin, length, seed);
454
41
455
41
  const char *s_aligned_end = s_begin + (length & ~63);
456
41
  hash_state state = state.create(s_begin, seed);
457
41
  s_begin += 64;
458
47
  while (s_begin != s_aligned_end) {
459
6
    state.mix(s_begin);
460
6
    s_begin += 64;
461
6
  }
462
41
  if (length & 63)
463
40
    state.mix(s_end - 64);
464
41
465
41
  return state.finalize(length);
466
41
}
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
447
1.51M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
1.51M
  const uint64_t seed = get_execution_seed();
449
1.51M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
1.51M
  const char *s_end = reinterpret_cast<const char *>(last);
451
1.51M
  const size_t length = std::distance(s_begin, s_end);
452
1.51M
  if (length <= 64)
453
1.47M
    return hash_short(s_begin, length, seed);
454
40.6k
455
40.6k
  const char *s_aligned_end = s_begin + (length & ~63);
456
40.6k
  hash_state state = state.create(s_begin, seed);
457
40.6k
  s_begin += 64;
458
108k
  while (s_begin != s_aligned_end) {
459
67.9k
    state.mix(s_begin);
460
67.9k
    s_begin += 64;
461
67.9k
  }
462
40.6k
  if (length & 63)
463
40.1k
    state.mix(s_end - 64);
464
40.6k
465
40.6k
  return state.finalize(length);
466
40.6k
}
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
447
2.63k
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
2.63k
  const uint64_t seed = get_execution_seed();
449
2.63k
  const char *s_begin = reinterpret_cast<const char *>(first);
450
2.63k
  const char *s_end = reinterpret_cast<const char *>(last);
451
2.63k
  const size_t length = std::distance(s_begin, s_end);
452
2.63k
  if (length <= 64)
453
2.63k
    return hash_short(s_begin, length, seed);
454
0
455
0
  const char *s_aligned_end = s_begin + (length & ~63);
456
0
  hash_state state = state.create(s_begin, seed);
457
0
  s_begin += 64;
458
0
  while (s_begin != s_aligned_end) {
459
0
    state.mix(s_begin);
460
0
    s_begin += 64;
461
0
  }
462
0
  if (length & 63)
463
0
    state.mix(s_end - 64);
464
0
465
0
  return state.finalize(length);
466
0
}
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
447
19.3M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
19.3M
  const uint64_t seed = get_execution_seed();
449
19.3M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
19.3M
  const char *s_end = reinterpret_cast<const char *>(last);
451
19.3M
  const size_t length = std::distance(s_begin, s_end);
452
19.3M
  if (length <= 64)
453
19.3M
    return hash_short(s_begin, length, seed);
454
0
455
0
  const char *s_aligned_end = s_begin + (length & ~63);
456
0
  hash_state state = state.create(s_begin, seed);
457
0
  s_begin += 64;
458
0
  while (s_begin != s_aligned_end) {
459
0
    state.mix(s_begin);
460
0
    s_begin += 64;
461
0
  }
462
0
  if (length & 63)
463
0
    state.mix(s_end - 64);
464
0
465
0
  return state.finalize(length);
466
0
}
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
447
4.06M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
4.06M
  const uint64_t seed = get_execution_seed();
449
4.06M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
4.06M
  const char *s_end = reinterpret_cast<const char *>(last);
451
4.06M
  const size_t length = std::distance(s_begin, s_end);
452
4.06M
  if (length <= 64)
453
4.06M
    return hash_short(s_begin, length, seed);
454
641
455
641
  const char *s_aligned_end = s_begin + (length & ~63);
456
641
  hash_state state = state.create(s_begin, seed);
457
641
  s_begin += 64;
458
73.6k
  while (s_begin != s_aligned_end) {
459
72.9k
    state.mix(s_begin);
460
72.9k
    s_begin += 64;
461
72.9k
  }
462
641
  if (length & 63)
463
107
    state.mix(s_end - 64);
464
641
465
641
  return state.finalize(length);
466
641
}
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
447
7.15M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
7.15M
  const uint64_t seed = get_execution_seed();
449
7.15M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
7.15M
  const char *s_end = reinterpret_cast<const char *>(last);
451
7.15M
  const size_t length = std::distance(s_begin, s_end);
452
7.15M
  if (length <= 64)
453
7.04M
    return hash_short(s_begin, length, seed);
454
107k
455
107k
  const char *s_aligned_end = s_begin + (length & ~63);
456
107k
  hash_state state = state.create(s_begin, seed);
457
107k
  s_begin += 64;
458
888k
  while (s_begin != s_aligned_end) {
459
781k
    state.mix(s_begin);
460
781k
    s_begin += 64;
461
781k
  }
462
107k
  if (length & 63)
463
106k
    state.mix(s_end - 64);
464
107k
465
107k
  return state.finalize(length);
466
107k
}
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
447
8.32M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
8.32M
  const uint64_t seed = get_execution_seed();
449
8.32M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
8.32M
  const char *s_end = reinterpret_cast<const char *>(last);
451
8.32M
  const size_t length = std::distance(s_begin, s_end);
452
8.32M
  if (length <= 64)
453
8.14M
    return hash_short(s_begin, length, seed);
454
171k
455
171k
  const char *s_aligned_end = s_begin + (length & ~63);
456
171k
  hash_state state = state.create(s_begin, seed);
457
171k
  s_begin += 64;
458
332k
  while (s_begin != s_aligned_end) {
459
161k
    state.mix(s_begin);
460
161k
    s_begin += 64;
461
161k
  }
462
171k
  if (length & 63)
463
166k
    state.mix(s_end - 64);
464
171k
465
171k
  return state.finalize(length);
466
171k
}
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
447
7.78M
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
7.78M
  const uint64_t seed = get_execution_seed();
449
7.78M
  const char *s_begin = reinterpret_cast<const char *>(first);
450
7.78M
  const char *s_end = reinterpret_cast<const char *>(last);
451
7.78M
  const size_t length = std::distance(s_begin, s_end);
452
7.78M
  if (length <= 64)
453
7.78M
    return hash_short(s_begin, length, seed);
454
853
455
853
  const char *s_aligned_end = s_begin + (length & ~63);
456
853
  hash_state state = state.create(s_begin, seed);
457
853
  s_begin += 64;
458
1.22k
  while (s_begin != s_aligned_end) {
459
369
    state.mix(s_begin);
460
369
    s_begin += 64;
461
369
  }
462
853
  if (length & 63)
463
853
    state.mix(s_end - 64);
464
853
465
853
  return state.finalize(length);
466
853
}
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
447
4.96k
hash_combine_range_impl(ValueT *first, ValueT *last) {
448
4.96k
  const uint64_t seed = get_execution_seed();
449
4.96k
  const char *s_begin = reinterpret_cast<const char *>(first);
450
4.96k
  const char *s_end = reinterpret_cast<const char *>(last);
451
4.96k
  const size_t length = std::distance(s_begin, s_end);
452
4.96k
  if (length <= 64)
453
3.60k
    return hash_short(s_begin, length, seed);
454
1.36k
455
1.36k
  const char *s_aligned_end = s_begin + (length & ~63);
456
1.36k
  hash_state state = state.create(s_begin, seed);
457
1.36k
  s_begin += 64;
458
1.95k
  while (s_begin != s_aligned_end) {
459
590
    state.mix(s_begin);
460
590
    s_begin += 64;
461
590
  }
462
1.36k
  if (length & 63)
463
1.28k
    state.mix(s_end - 64);
464
1.36k
465
1.36k
  return state.finalize(length);
466
1.36k
}
467
468
} // namespace detail
469
} // namespace hashing
470
471
472
/// Compute a hash_code for a sequence of values.
473
///
474
/// This hashes a sequence of values. It produces the same hash_code as
475
/// 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences
476
/// and is significantly faster given pointers and types which can be hashed as
477
/// a sequence of bytes.
478
template <typename InputIteratorT>
479
746M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
746M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
746M
}
llvm::hash_code llvm::hash_combine_range<unsigned int*>(unsigned int*, unsigned int*)
Line
Count
Source
479
2.02k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
2.02k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
2.02k
}
llvm::hash_code llvm::hash_combine_range<unsigned long*>(unsigned long*, unsigned long*)
Line
Count
Source
479
24.2M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
24.2M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
24.2M
}
llvm::hash_code llvm::hash_combine_range<llvm::Constant* const*>(llvm::Constant* const*, llvm::Constant* const*)
Line
Count
Source
479
17.6M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
17.6M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
17.6M
}
llvm::hash_code llvm::hash_combine_range<unsigned int const*>(unsigned int const*, unsigned int const*)
Line
Count
Source
479
621M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
621M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
621M
}
llvm::hash_code llvm::hash_combine_range<llvm::Type* const*>(llvm::Type* const*, llvm::Type* const*)
Line
Count
Source
479
7.20M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
7.20M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
7.20M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long const*>(unsigned long long const*, unsigned long long const*)
Line
Count
Source
479
1.01M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
1.01M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
1.01M
}
llvm::hash_code llvm::hash_combine_range<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
479
42.3k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
42.3k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
42.3k
}
llvm::hash_code llvm::hash_combine_range<llvm::Metadata* const*>(llvm::Metadata* const*, llvm::Metadata* const*)
Line
Count
Source
479
1.51M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
1.51M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
1.51M
}
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
479
20.5k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
20.5k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
20.5k
}
llvm::hash_code llvm::hash_combine_range<llvm::Value* const*>(llvm::Value* const*, llvm::Value* const*)
Line
Count
Source
479
2.63k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
2.63k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
2.63k
}
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
479
26.0M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
26.0M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
26.0M
}
llvm::hash_code llvm::hash_combine_range<llvm::SCEV const* const*>(llvm::SCEV const* const*, llvm::SCEV const* const*)
Line
Count
Source
479
19.3M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
19.3M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
19.3M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long*>(unsigned long long*, unsigned long long*)
Line
Count
Source
479
4.06M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
4.06M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
4.06M
}
llvm::hash_code llvm::hash_combine_range<char const*>(char const*, char const*)
Line
Count
Source
479
7.15M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
7.15M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
7.15M
}
llvm::hash_code llvm::hash_combine_range<llvm::BasicBlock**>(llvm::BasicBlock**, llvm::BasicBlock**)
Line
Count
Source
479
8.32M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
8.32M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
8.32M
}
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
479
270k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
270k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
270k
}
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
479
7.78M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
7.78M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
7.78M
}
llvm::hash_code llvm::hash_combine_range<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
479
496
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
496
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
496
}
ItaniumCXXABI.cpp:llvm::hash_code llvm::hash_combine_range<(anonymous namespace)::DecompositionDeclName::Iterator>((anonymous namespace)::DecompositionDeclName::Iterator, (anonymous namespace)::DecompositionDeclName::Iterator)
Line
Count
Source
479
1
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
1
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
1
}
llvm::hash_code llvm::hash_combine_range<unsigned char const*>(unsigned char const*, unsigned char const*)
Line
Count
Source
479
4.96k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
480
4.96k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
481
4.96k
}
482
483
484
// Implementation details for hash_combine.
485
namespace hashing {
486
namespace detail {
487
488
/// Helper class to manage the recursive combining of hash_combine
489
/// arguments.
490
///
491
/// This class exists to manage the state and various calls involved in the
492
/// recursive combining of arguments used in hash_combine. It is particularly
493
/// useful at minimizing the code in the recursive calls to ease the pain
494
/// caused by a lack of variadic functions.
495
struct hash_combine_recursive_helper {
496
  char buffer[64];
497
  hash_state state;
498
  const uint64_t seed;
499
500
public:
501
  /// Construct a recursive hash combining helper.
502
  ///
503
  /// This sets up the state for a recursive hash combine, including getting
504
  /// the seed and buffer setup.
505
  hash_combine_recursive_helper()
506
464M
    : seed(get_execution_seed()) {}
507
508
  /// Combine one chunk of data into the current in-flight hash.
509
  ///
510
  /// This merges one chunk of data into the hash. First it tries to buffer
511
  /// the data. If the buffer is full, it hashes the buffer into its
512
  /// hash_state, empties it, and then merges the new chunk in. This also
513
  /// handles cases where the data straddles the end of the buffer.
514
  template <typename T>
515
1.02G
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.02G
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
6
      // Check for skew which prevents the buffer from being packed, and do
518
6
      // a partial store into the buffer to fill it. This is only a concern
519
6
      // with the variadic combine because that formation can have varying
520
6
      // argument types.
521
6
      size_t partial_store_size = buffer_end - buffer_ptr;
522
6
      memcpy(buffer_ptr, &data, partial_store_size);
523
6
524
6
      // If the store fails, our buffer is full and ready to hash. We have to
525
6
      // either initialize the hash state (on the first full buffer) or mix
526
6
      // this buffer into the existing hash state. Length tracks the *hashed*
527
6
      // length, not the buffered length.
528
6
      if (length == 0) {
529
6
        state = state.create(buffer, seed);
530
6
        length = 64;
531
6
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
6
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
6
      // data.
538
6
      buffer_ptr = buffer;
539
6
540
6
      // Try again to store into the buffer -- this cannot fail as we only
541
6
      // store types smaller than the buffer.
542
6
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
6
                             partial_store_size))
544
0
        abort();
545
1.02G
    }
546
1.02G
    return buffer_ptr;
547
1.02G
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int>(unsigned long&, char*, char*, unsigned int)
Line
Count
Source
515
272M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
272M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
272M
    }
546
272M
    return buffer_ptr;
547
272M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long>(unsigned long&, char*, char*, unsigned long)
Line
Count
Source
515
101M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
101M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
101M
    }
546
101M
    return buffer_ptr;
547
101M
  }
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
515
1.75k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.75k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
1.75k
    }
546
1.75k
    return buffer_ptr;
547
1.75k
  }
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
515
3.51k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
3.51k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
3.51k
    }
546
3.51k
    return buffer_ptr;
547
3.51k
  }
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Loop const*>(unsigned long&, char*, char*, llvm::Loop const*)
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BasicBlock*>(unsigned long&, char*, char*, llvm::BasicBlock*)
Line
Count
Source
515
272
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
272
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
272
    }
546
272
    return buffer_ptr;
547
272
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<bool>(unsigned long&, char*, char*, bool)
Line
Count
Source
515
70.6M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
70.6M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
70.6M
    }
546
70.6M
    return buffer_ptr;
547
70.6M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<int>(unsigned long&, char*, char*, int)
Line
Count
Source
515
1.09M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.09M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
4
      // Check for skew which prevents the buffer from being packed, and do
518
4
      // a partial store into the buffer to fill it. This is only a concern
519
4
      // with the variadic combine because that formation can have varying
520
4
      // argument types.
521
4
      size_t partial_store_size = buffer_end - buffer_ptr;
522
4
      memcpy(buffer_ptr, &data, partial_store_size);
523
4
524
4
      // If the store fails, our buffer is full and ready to hash. We have to
525
4
      // either initialize the hash state (on the first full buffer) or mix
526
4
      // this buffer into the existing hash state. Length tracks the *hashed*
527
4
      // length, not the buffered length.
528
4
      if (length == 0) {
529
4
        state = state.create(buffer, seed);
530
4
        length = 64;
531
4
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
4
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
4
      // data.
538
4
      buffer_ptr = buffer;
539
4
540
4
      // Try again to store into the buffer -- this cannot fail as we only
541
4
      // store types smaller than the buffer.
542
4
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
4
                             partial_store_size))
544
0
        abort();
545
1.09M
    }
546
1.09M
    return buffer_ptr;
547
1.09M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<char const*>(unsigned long&, char*, char*, char const*)
Line
Count
Source
515
6.02k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
6.02k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
6.02k
    }
546
6.02k
    return buffer_ptr;
547
6.02k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::GlobalValue const*>(unsigned long&, char*, char*, llvm::GlobalValue const*)
Line
Count
Source
515
3.91M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
3.91M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
3.91M
    }
546
3.91M
    return buffer_ptr;
547
3.91M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BlockAddress const*>(unsigned long&, char*, char*, llvm::BlockAddress const*)
Line
Count
Source
515
394
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
394
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
394
    }
546
394
    return buffer_ptr;
547
394
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol*>(unsigned long&, char*, char*, llvm::MCSymbol*)
Line
Count
Source
515
234
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
234
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
234
    }
546
234
    return buffer_ptr;
547
234
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineBasicBlock*>(unsigned long&, char*, char*, llvm::MachineBasicBlock*)
Line
Count
Source
515
1.73M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.73M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
1.73M
    }
546
1.73M
    return buffer_ptr;
547
1.73M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineOperand::MachineOperandType>(unsigned long&, char*, char*, llvm::MachineOperand::MachineOperandType)
Line
Count
Source
515
74.0M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
74.0M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
74.0M
    }
546
74.0M
    return buffer_ptr;
547
74.0M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long long>(unsigned long&, char*, char*, long long)
Line
Count
Source
515
26.8M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
26.8M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
26.8M
    }
546
26.8M
    return buffer_ptr;
547
26.8M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantInt const*>(unsigned long&, char*, char*, llvm::ConstantInt const*)
Line
Count
Source
515
15
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
15
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
15
    }
546
15
    return buffer_ptr;
547
15
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantFP const*>(unsigned long&, char*, char*, llvm::ConstantFP const*)
Line
Count
Source
515
771
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
771
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
771
    }
546
771
    return buffer_ptr;
547
771
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int const*>(unsigned long&, char*, char*, unsigned int const*)
Line
Count
Source
515
18
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
18
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
18
    }
546
18
    return buffer_ptr;
547
18
  }
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDNode const*>(unsigned long&, char*, char*, llvm::MDNode const*)
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<llvm::InlineAsm::AsmDialect>(unsigned long&, char*, char*, llvm::InlineAsm::AsmDialect)
Line
Count
Source
515
25.4k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
25.4k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
25.4k
    }
546
25.4k
    return buffer_ptr;
547
25.4k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::FunctionType*>(unsigned long&, char*, char*, llvm::FunctionType*)
Line
Count
Source
515
25.4k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
25.4k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
25.4k
    }
546
25.4k
    return buffer_ptr;
547
25.4k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned char>(unsigned long&, char*, char*, unsigned char)
Line
Count
Source
515
36.6M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
36.6M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
36.6M
    }
546
36.6M
    return buffer_ptr;
547
36.6M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned short>(unsigned long&, char*, char*, unsigned short)
Line
Count
Source
515
17.1M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
17.1M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
17.1M
    }
546
17.1M
    return buffer_ptr;
547
17.1M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type const*>(unsigned long&, char*, char*, llvm::Type const*)
Line
Count
Source
515
7.07M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
7.07M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
7.07M
    }
546
7.07M
    return buffer_ptr;
547
7.07M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Metadata*>(unsigned long&, char*, char*, llvm::Metadata*)
Line
Count
Source
515
32.8M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
32.8M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
32.8M
    }
546
32.8M
    return buffer_ptr;
547
32.8M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDString*>(unsigned long&, char*, char*, llvm::MDString*)
Line
Count
Source
515
208k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
208k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
208k
    }
546
208k
    return buffer_ptr;
547
208k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long long>(unsigned long&, char*, char*, unsigned long long)
Line
Count
Source
515
234M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
234M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
2
      // Check for skew which prevents the buffer from being packed, and do
518
2
      // a partial store into the buffer to fill it. This is only a concern
519
2
      // with the variadic combine because that formation can have varying
520
2
      // argument types.
521
2
      size_t partial_store_size = buffer_end - buffer_ptr;
522
2
      memcpy(buffer_ptr, &data, partial_store_size);
523
2
524
2
      // If the store fails, our buffer is full and ready to hash. We have to
525
2
      // either initialize the hash state (on the first full buffer) or mix
526
2
      // this buffer into the existing hash state. Length tracks the *hashed*
527
2
      // length, not the buffered length.
528
2
      if (length == 0) {
529
2
        state = state.create(buffer, seed);
530
2
        length = 64;
531
2
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
2
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
2
      // data.
538
2
      buffer_ptr = buffer;
539
2
540
2
      // Try again to store into the buffer -- this cannot fail as we only
541
2
      // store types smaller than the buffer.
542
2
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
2
                             partial_store_size))
544
0
        abort();
545
234M
    }
546
234M
    return buffer_ptr;
547
234M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ArrayType*>(unsigned long&, char*, char*, llvm::ArrayType*)
Line
Count
Source
515
60.5k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
60.5k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
60.5k
    }
546
60.5k
    return buffer_ptr;
547
60.5k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::StructType*>(unsigned long&, char*, char*, llvm::StructType*)
Line
Count
Source
515
193k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
193k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
193k
    }
546
193k
    return buffer_ptr;
547
193k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::VectorType*>(unsigned long&, char*, char*, llvm::VectorType*)
Line
Count
Source
515
214k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
214k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
214k
    }
546
214k
    return buffer_ptr;
547
214k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type*>(unsigned long&, char*, char*, llvm::Type*)
Line
Count
Source
515
48.6M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
48.6M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
48.6M
    }
546
48.6M
    return buffer_ptr;
547
48.6M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::PointerType*>(unsigned long&, char*, char*, llvm::PointerType*)
Line
Count
Source
515
25.4k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
25.4k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
25.4k
    }
546
25.4k
    return buffer_ptr;
547
25.4k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol const*>(unsigned long&, char*, char*, llvm::MCSymbol const*)
Line
Count
Source
515
32.4k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
32.4k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
32.4k
    }
546
32.4k
    return buffer_ptr;
547
32.4k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::BinaryOps>(unsigned long&, char*, char*, llvm::Instruction::BinaryOps)
Line
Count
Source
515
7.49M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
7.49M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
7.49M
    }
546
7.49M
    return buffer_ptr;
547
7.49M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Value*>(unsigned long&, char*, char*, llvm::Value*)
Line
Count
Source
515
49.8M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
49.8M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
49.8M
    }
546
49.8M
    return buffer_ptr;
547
49.8M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::CmpInst::Predicate>(unsigned long&, char*, char*, llvm::CmpInst::Predicate)
Line
Count
Source
515
12.7M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
12.7M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
12.7M
    }
546
12.7M
    return buffer_ptr;
547
12.7M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::SelectPatternFlavor>(unsigned long&, char*, char*, llvm::SelectPatternFlavor)
Line
Count
Source
515
231k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
231k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
231k
    }
546
231k
    return buffer_ptr;
547
231k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::CastOps>(unsigned long&, char*, char*, llvm::Instruction::CastOps)
Line
Count
Source
515
8.32M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
8.32M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
8.32M
    }
546
8.32M
    return buffer_ptr;
547
8.32M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MemoryAccess const*>(unsigned long&, char*, char*, llvm::MemoryAccess const*)
Line
Count
Source
515
1.13k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.13k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
1.13k
    }
546
1.13k
    return buffer_ptr;
547
1.13k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Constant*>(unsigned long&, char*, char*, llvm::Constant*)
Line
Count
Source
515
464
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
464
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
464
    }
546
464
    return buffer_ptr;
547
464
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction*>(unsigned long&, char*, char*, llvm::Instruction*)
Line
Count
Source
515
277
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
277
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
277
    }
546
277
    return buffer_ptr;
547
277
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<short>(unsigned long&, char*, char*, short)
Line
Count
Source
515
1.00M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
1.00M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
1.00M
    }
546
1.00M
    return buffer_ptr;
547
1.00M
  }
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<void*>(unsigned long&, char*, char*, void*)
Line
Count
Source
515
44.3k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
44.3k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
44.3k
    }
546
44.3k
    return buffer_ptr;
547
44.3k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<clang::NestedNameSpecifier*>(unsigned long&, char*, char*, clang::NestedNameSpecifier*)
Line
Count
Source
515
909
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
909
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
909
    }
546
909
    return buffer_ptr;
547
909
  }
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
515
14.2M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
14.2M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
14.2M
    }
546
14.2M
    return buffer_ptr;
547
14.2M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long>(unsigned long&, char*, char*, long)
Line
Count
Source
515
61.8k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
61.8k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
61.8k
    }
546
61.8k
    return buffer_ptr;
547
61.8k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::wasm::ValType>(unsigned long&, char*, char*, llvm::wasm::ValType)
Line
Count
Source
515
624
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
624
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
624
    }
546
624
    return buffer_ptr;
547
624
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<lld::DefinedAtom::ContentType>(unsigned long&, char*, char*, lld::DefinedAtom::ContentType)
Line
Count
Source
515
54
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
516
54
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
517
0
      // Check for skew which prevents the buffer from being packed, and do
518
0
      // a partial store into the buffer to fill it. This is only a concern
519
0
      // with the variadic combine because that formation can have varying
520
0
      // argument types.
521
0
      size_t partial_store_size = buffer_end - buffer_ptr;
522
0
      memcpy(buffer_ptr, &data, partial_store_size);
523
0
524
0
      // If the store fails, our buffer is full and ready to hash. We have to
525
0
      // either initialize the hash state (on the first full buffer) or mix
526
0
      // this buffer into the existing hash state. Length tracks the *hashed*
527
0
      // length, not the buffered length.
528
0
      if (length == 0) {
529
0
        state = state.create(buffer, seed);
530
0
        length = 64;
531
0
      } else {
532
0
        // Mix this chunk into the current state and bump length up by 64.
533
0
        state.mix(buffer);
534
0
        length += 64;
535
0
      }
536
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
537
0
      // data.
538
0
      buffer_ptr = buffer;
539
0
540
0
      // Try again to store into the buffer -- this cannot fail as we only
541
0
      // store types smaller than the buffer.
542
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
543
0
                             partial_store_size))
544
0
        abort();
545
54
    }
546
54
    return buffer_ptr;
547
54
  }
548
549
  /// Recursive, variadic combining method.
550
  ///
551
  /// This function recurses through each argument, combining that argument
552
  /// into a single hash.
553
  template <typename T, typename ...Ts>
554
  hash_code combine(size_t length, char *buffer_ptr, char *buffer_end,
555
1.02G
                    const T &arg, const Ts &...args) {
556
1.02G
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.02G
558
1.02G
    // Recurse to the next argument.
559
1.02G
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.02G
  }
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
555
206
                    const T &arg, const Ts &...args) {
556
206
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
206
558
206
    // Recurse to the next argument.
559
206
    return combine(length, buffer_ptr, buffer_end, args...);
560
206
  }
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
555
18.0M
                    const T &arg, const Ts &...args) {
556
18.0M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
18.0M
558
18.0M
    // Recurse to the next argument.
559
18.0M
    return combine(length, buffer_ptr, buffer_end, args...);
560
18.0M
  }
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
555
68.1M
                    const T &arg, const Ts &...args) {
556
68.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
68.1M
558
68.1M
    // Recurse to the next argument.
559
68.1M
    return combine(length, buffer_ptr, buffer_end, args...);
560
68.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
555
771k
                    const T &arg, const Ts &...args) {
556
771k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
771k
558
771k
    // Recurse to the next argument.
559
771k
    return combine(length, buffer_ptr, buffer_end, args...);
560
771k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int>(unsigned long, char*, char*, unsigned int const&)
Line
Count
Source
555
35.3M
                    const T &arg, const Ts &...args) {
556
35.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
35.3M
558
35.3M
    // Recurse to the next argument.
559
35.3M
    return combine(length, buffer_ptr, buffer_end, args...);
560
35.3M
  }
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
555
1.75k
                    const T &arg, const Ts &...args) {
556
1.75k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.75k
558
1.75k
    // Recurse to the next argument.
559
1.75k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.75k
  }
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
555
1.75k
                    const T &arg, const Ts &...args) {
556
1.75k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.75k
558
1.75k
    // Recurse to the next argument.
559
1.75k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.75k
  }
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
555
1.75k
                    const T &arg, const Ts &...args) {
556
1.75k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.75k
558
1.75k
    // Recurse to the next argument.
559
1.75k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.75k
  }
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
555
1.75k
                    const T &arg, const Ts &...args) {
556
1.75k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.75k
558
1.75k
    // Recurse to the next argument.
559
1.75k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.75k
  }
Unexecuted instantiation: 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&)
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BasicBlock*>(unsigned long, char*, char*, llvm::BasicBlock* const&)
Line
Count
Source
555
272
                    const T &arg, const Ts &...args) {
556
272
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
272
558
272
    // Recurse to the next argument.
559
272
    return combine(length, buffer_ptr, buffer_end, args...);
560
272
  }
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
555
7.20M
                    const T &arg, const Ts &...args) {
556
7.20M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
7.20M
558
7.20M
    // Recurse to the next argument.
559
7.20M
    return combine(length, buffer_ptr, buffer_end, args...);
560
7.20M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool>(unsigned long, char*, char*, bool const&)
Line
Count
Source
555
68.4M
                    const T &arg, const Ts &...args) {
556
68.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
68.4M
558
68.4M
    // Recurse to the next argument.
559
68.4M
    return combine(length, buffer_ptr, buffer_end, args...);
560
68.4M
  }
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
555
97.6k
                    const T &arg, const Ts &...args) {
556
97.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
97.6k
558
97.6k
    // Recurse to the next argument.
559
97.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
97.6k
  }
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
555
97.6k
                    const T &arg, const Ts &...args) {
556
97.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
97.6k
558
97.6k
    // Recurse to the next argument.
559
97.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
97.6k
  }
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
555
97.6k
                    const T &arg, const Ts &...args) {
556
97.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
97.6k
558
97.6k
    // Recurse to the next argument.
559
97.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
97.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&)
Line
Count
Source
555
97.6k
                    const T &arg, const Ts &...args) {
556
97.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
97.6k
558
97.6k
    // Recurse to the next argument.
559
97.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
97.6k
  }
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
555
187
                    const T &arg, const Ts &...args) {
556
187
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
187
558
187
    // Recurse to the next argument.
559
187
    return combine(length, buffer_ptr, buffer_end, args...);
560
187
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int>(unsigned long, char*, char*, int const&)
Line
Count
Source
555
638k
                    const T &arg, const Ts &...args) {
556
638k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
638k
558
638k
    // Recurse to the next argument.
559
638k
    return combine(length, buffer_ptr, buffer_end, args...);
560
638k
  }
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&)
Line
Count
Source
555
3
                    const T &arg, const Ts &...args) {
556
3
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3
558
3
    // Recurse to the next argument.
559
3
    return combine(length, buffer_ptr, buffer_end, args...);
560
3
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<char const*>(unsigned long, char*, char*, char const* const&)
Line
Count
Source
555
6.02k
                    const T &arg, const Ts &...args) {
556
6.02k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
6.02k
558
6.02k
    // Recurse to the next argument.
559
6.02k
    return combine(length, buffer_ptr, buffer_end, args...);
560
6.02k
  }
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
555
53.2k
                    const T &arg, const Ts &...args) {
556
53.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
53.2k
558
53.2k
    // Recurse to the next argument.
559
53.2k
    return combine(length, buffer_ptr, buffer_end, args...);
560
53.2k
  }
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
555
53.2k
                    const T &arg, const Ts &...args) {
556
53.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
53.2k
558
53.2k
    // Recurse to the next argument.
559
53.2k
    return combine(length, buffer_ptr, buffer_end, args...);
560
53.2k
  }
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
555
12
                    const T &arg, const Ts &...args) {
556
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
12
558
12
    // Recurse to the next argument.
559
12
    return combine(length, buffer_ptr, buffer_end, args...);
560
12
  }
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
555
12
                    const T &arg, const Ts &...args) {
556
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
12
558
12
    // Recurse to the next argument.
559
12
    return combine(length, buffer_ptr, buffer_end, args...);
560
12
  }
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
555
14
                    const T &arg, const Ts &...args) {
556
14
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
14
558
14
    // Recurse to the next argument.
559
14
    return combine(length, buffer_ptr, buffer_end, args...);
560
14
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MCSymbol* const&)
Line
Count
Source
555
234
                    const T &arg, const Ts &...args) {
556
234
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
234
558
234
    // Recurse to the next argument.
559
234
    return combine(length, buffer_ptr, buffer_end, args...);
560
234
  }
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
555
8
                    const T &arg, const Ts &...args) {
556
8
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
8
558
8
    // Recurse to the next argument.
559
8
    return combine(length, buffer_ptr, buffer_end, args...);
560
8
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineBasicBlock* const&)
Line
Count
Source
555
1.73M
                    const T &arg, const Ts &...args) {
556
1.73M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.73M
558
1.73M
    // Recurse to the next argument.
559
1.73M
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.73M
  }
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
555
2.13M
                    const T &arg, const Ts &...args) {
556
2.13M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.13M
558
2.13M
    // Recurse to the next argument.
559
2.13M
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.13M
  }
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
555
363k
                    const T &arg, const Ts &...args) {
556
363k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
363k
558
363k
    // Recurse to the next argument.
559
363k
    return combine(length, buffer_ptr, buffer_end, args...);
560
363k
  }
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
555
44.9M
                    const T &arg, const Ts &...args) {
556
44.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
44.9M
558
44.9M
    // Recurse to the next argument.
559
44.9M
    return combine(length, buffer_ptr, buffer_end, args...);
560
44.9M
  }
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
555
44.9M
                    const T &arg, const Ts &...args) {
556
44.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
44.9M
558
44.9M
    // Recurse to the next argument.
559
44.9M
    return combine(length, buffer_ptr, buffer_end, args...);
560
44.9M
  }
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
555
44.9M
                    const T &arg, const Ts &...args) {
556
44.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
44.9M
558
44.9M
    // Recurse to the next argument.
559
44.9M
    return combine(length, buffer_ptr, buffer_end, args...);
560
44.9M
  }
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
555
22.4M
                    const T &arg, const Ts &...args) {
556
22.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
22.4M
558
22.4M
    // Recurse to the next argument.
559
22.4M
    return combine(length, buffer_ptr, buffer_end, args...);
560
22.4M
  }
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
555
22.4M
                    const T &arg, const Ts &...args) {
556
22.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
22.4M
558
22.4M
    // Recurse to the next argument.
559
22.4M
    return combine(length, buffer_ptr, buffer_end, args...);
560
22.4M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long>(unsigned long, char*, char*, long long const&)
Line
Count
Source
555
26.7M
                    const T &arg, const Ts &...args) {
556
26.7M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
26.7M
558
26.7M
    // Recurse to the next argument.
559
26.7M
    return combine(length, buffer_ptr, buffer_end, args...);
560
26.7M
  }
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
555
15
                    const T &arg, const Ts &...args) {
556
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
15
558
15
    // Recurse to the next argument.
559
15
    return combine(length, buffer_ptr, buffer_end, args...);
560
15
  }
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
555
15
                    const T &arg, const Ts &...args) {
556
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
15
558
15
    // Recurse to the next argument.
559
15
    return combine(length, buffer_ptr, buffer_end, args...);
560
15
  }
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
555
15
                    const T &arg, const Ts &...args) {
556
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
15
558
15
    // Recurse to the next argument.
559
15
    return combine(length, buffer_ptr, buffer_end, args...);
560
15
  }
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
555
771
                    const T &arg, const Ts &...args) {
556
771
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
771
558
771
    // Recurse to the next argument.
559
771
    return combine(length, buffer_ptr, buffer_end, args...);
560
771
  }
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
555
771
                    const T &arg, const Ts &...args) {
556
771
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
771
558
771
    // Recurse to the next argument.
559
771
    return combine(length, buffer_ptr, buffer_end, args...);
560
771
  }
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
555
771
                    const T &arg, const Ts &...args) {
556
771
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
771
558
771
    // Recurse to the next argument.
559
771
    return combine(length, buffer_ptr, buffer_end, args...);
560
771
  }
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
555
1.73M
                    const T &arg, const Ts &...args) {
556
1.73M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.73M
558
1.73M
    // Recurse to the next argument.
559
1.73M
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.73M
  }
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
555
1.73M
                    const T &arg, const Ts &...args) {
556
1.73M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.73M
558
1.73M
    // Recurse to the next argument.
559
1.73M
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.73M
  }
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
555
637k
                    const T &arg, const Ts &...args) {
556
637k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
637k
558
637k
    // Recurse to the next argument.
559
637k
    return combine(length, buffer_ptr, buffer_end, args...);
560
637k
  }
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
555
637k
                    const T &arg, const Ts &...args) {
556
637k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
637k
558
637k
    // Recurse to the next argument.
559
637k
    return combine(length, buffer_ptr, buffer_end, args...);
560
637k
  }
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
555
426k
                    const T &arg, const Ts &...args) {
556
426k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
426k
558
426k
    // Recurse to the next argument.
559
426k
    return combine(length, buffer_ptr, buffer_end, args...);
560
426k
  }
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
555
426k
                    const T &arg, const Ts &...args) {
556
426k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
426k
558
426k
    // Recurse to the next argument.
559
426k
    return combine(length, buffer_ptr, buffer_end, args...);
560
426k
  }
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
555
426k
                    const T &arg, const Ts &...args) {
556
426k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
426k
558
426k
    // Recurse to the next argument.
559
426k
    return combine(length, buffer_ptr, buffer_end, args...);
560
426k
  }
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
555
6.01k
                    const T &arg, const Ts &...args) {
556
6.01k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
6.01k
558
6.01k
    // Recurse to the next argument.
559
6.01k
    return combine(length, buffer_ptr, buffer_end, args...);
560
6.01k
  }
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
555
6.01k
                    const T &arg, const Ts &...args) {
556
6.01k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
6.01k
558
6.01k
    // Recurse to the next argument.
559
6.01k
    return combine(length, buffer_ptr, buffer_end, args...);
560
6.01k
  }
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
555
6.01k
                    const T &arg, const Ts &...args) {
556
6.01k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
6.01k
558
6.01k
    // Recurse to the next argument.
559
6.01k
    return combine(length, buffer_ptr, buffer_end, args...);
560
6.01k
  }
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
555
3.85M
                    const T &arg, const Ts &...args) {
556
3.85M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.85M
558
3.85M
    // Recurse to the next argument.
559
3.85M
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.85M
  }
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
555
3.85M
                    const T &arg, const Ts &...args) {
556
3.85M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.85M
558
3.85M
    // Recurse to the next argument.
559
3.85M
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.85M
  }
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
555
3.85M
                    const T &arg, const Ts &...args) {
556
3.85M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.85M
558
3.85M
    // Recurse to the next argument.
559
3.85M
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.85M
  }
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
555
382
                    const T &arg, const Ts &...args) {
556
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
382
558
382
    // Recurse to the next argument.
559
382
    return combine(length, buffer_ptr, buffer_end, args...);
560
382
  }
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
555
382
                    const T &arg, const Ts &...args) {
556
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
382
558
382
    // Recurse to the next argument.
559
382
    return combine(length, buffer_ptr, buffer_end, args...);
560
382
  }
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
555
382
                    const T &arg, const Ts &...args) {
556
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
382
558
382
    // Recurse to the next argument.
559
382
    return combine(length, buffer_ptr, buffer_end, args...);
560
382
  }
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
555
18
                    const T &arg, const Ts &...args) {
556
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
18
558
18
    // Recurse to the next argument.
559
18
    return combine(length, buffer_ptr, buffer_end, args...);
560
18
  }
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
555
18
                    const T &arg, const Ts &...args) {
556
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
18
558
18
    // Recurse to the next argument.
559
18
    return combine(length, buffer_ptr, buffer_end, args...);
560
18
  }
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
555
18
                    const T &arg, const Ts &...args) {
556
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
18
558
18
    // Recurse to the next argument.
559
18
    return combine(length, buffer_ptr, buffer_end, args...);
560
18
  }
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&)
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::MDNode const*>(unsigned long, char*, char*, llvm::MDNode const* const&)
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
555
220
                    const T &arg, const Ts &...args) {
556
220
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
220
558
220
    // Recurse to the next argument.
559
220
    return combine(length, buffer_ptr, buffer_end, args...);
560
220
  }
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
555
220
                    const T &arg, const Ts &...args) {
556
220
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
220
558
220
    // Recurse to the next argument.
559
220
    return combine(length, buffer_ptr, buffer_end, args...);
560
220
  }
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&)
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<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::Intrinsic::ID>(unsigned long, char*, char*, llvm::Intrinsic::ID const&)
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::FunctionType*>(unsigned long, char*, char*, llvm::FunctionType* const&)
Line
Count
Source
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
17.1M
                    const T &arg, const Ts &...args) {
556
17.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.1M
558
17.1M
    // Recurse to the next argument.
559
17.1M
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.1M
  }
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
555
17.1M
                    const T &arg, const Ts &...args) {
556
17.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.1M
558
17.1M
    // Recurse to the next argument.
559
17.1M
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.1M
  }
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
555
17.1M
                    const T &arg, const Ts &...args) {
556
17.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.1M
558
17.1M
    // Recurse to the next argument.
559
17.1M
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.1M
  }
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
555
25.4M
                    const T &arg, const Ts &...args) {
556
25.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4M
558
25.4M
    // Recurse to the next argument.
559
25.4M
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4M
  }
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
555
7.07M
                    const T &arg, const Ts &...args) {
556
7.07M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
7.07M
558
7.07M
    // Recurse to the next argument.
559
7.07M
    return combine(length, buffer_ptr, buffer_end, args...);
560
7.07M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
555
16.2M
                    const T &arg, const Ts &...args) {
556
16.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
16.2M
558
16.2M
    // Recurse to the next argument.
559
16.2M
    return combine(length, buffer_ptr, buffer_end, args...);
560
16.2M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
555
16.2M
                    const T &arg, const Ts &...args) {
556
16.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
16.2M
558
16.2M
    // Recurse to the next argument.
559
16.2M
    return combine(length, buffer_ptr, buffer_end, args...);
560
16.2M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
555
16.2M
                    const T &arg, const Ts &...args) {
556
16.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
16.2M
558
16.2M
    // Recurse to the next argument.
559
16.2M
    return combine(length, buffer_ptr, buffer_end, args...);
560
16.2M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, bool>(unsigned long, char*, char*, llvm::Metadata* const&, bool const&)
Line
Count
Source
555
16.2M
                    const T &arg, const Ts &...args) {
556
16.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
16.2M
558
16.2M
    // Recurse to the next argument.
559
16.2M
    return combine(length, buffer_ptr, buffer_end, args...);
560
16.2M
  }
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
555
114
                    const T &arg, const Ts &...args) {
556
114
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
114
558
114
    // Recurse to the next argument.
559
114
    return combine(length, buffer_ptr, buffer_end, args...);
560
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
555
2.12k
                    const T &arg, const Ts &...args) {
556
2.12k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.12k
558
2.12k
    // Recurse to the next argument.
559
2.12k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.12k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&)
Line
Count
Source
555
54.4k
                    const T &arg, const Ts &...args) {
556
54.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
54.4k
558
54.4k
    // Recurse to the next argument.
559
54.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
54.4k
  }
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
555
771
                    const T &arg, const Ts &...args) {
556
771
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
771
558
771
    // Recurse to the next argument.
559
771
    return combine(length, buffer_ptr, buffer_end, args...);
560
771
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, long long>(unsigned long, char*, char*, llvm::Metadata* const&, long long const&)
Line
Count
Source
555
83
                    const T &arg, const Ts &...args) {
556
83
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
83
558
83
    // Recurse to the next argument.
559
83
    return combine(length, buffer_ptr, buffer_end, args...);
560
83
  }
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
555
18.9k
                    const T &arg, const Ts &...args) {
556
18.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
18.9k
558
18.9k
    // Recurse to the next argument.
559
18.9k
    return combine(length, buffer_ptr, buffer_end, args...);
560
18.9k
  }
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
555
3.88k
                    const T &arg, const Ts &...args) {
556
3.88k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.88k
558
3.88k
    // Recurse to the next argument.
559
3.88k
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.88k
  }
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
555
3.88k
                    const T &arg, const Ts &...args) {
556
3.88k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.88k
558
3.88k
    // Recurse to the next argument.
559
3.88k
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.88k
  }
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
555
3.88k
                    const T &arg, const Ts &...args) {
556
3.88k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.88k
558
3.88k
    // Recurse to the next argument.
559
3.88k
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.88k
  }
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
555
4.66k
                    const T &arg, const Ts &...args) {
556
4.66k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
4.66k
558
4.66k
    // Recurse to the next argument.
559
4.66k
    return combine(length, buffer_ptr, buffer_end, args...);
560
4.66k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&)
Line
Count
Source
555
143k
                    const T &arg, const Ts &...args) {
556
143k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
143k
558
143k
    // Recurse to the next argument.
559
143k
    return combine(length, buffer_ptr, buffer_end, args...);
560
143k
  }
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
555
17.6k
                    const T &arg, const Ts &...args) {
556
17.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.6k
558
17.6k
    // Recurse to the next argument.
559
17.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.6k
  }
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
555
17.6k
                    const T &arg, const Ts &...args) {
556
17.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.6k
558
17.6k
    // Recurse to the next argument.
559
17.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.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
555
17.6k
                    const T &arg, const Ts &...args) {
556
17.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.6k
558
17.6k
    // Recurse to the next argument.
559
17.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.6k
  }
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
555
17.6k
                    const T &arg, const Ts &...args) {
556
17.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.6k
558
17.6k
    // Recurse to the next argument.
559
17.6k
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.6k
  }
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
555
23.2k
                    const T &arg, const Ts &...args) {
556
23.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
23.2k
558
23.2k
    // Recurse to the next argument.
559
23.2k
    return combine(length, buffer_ptr, buffer_end, args...);
560
23.2k
  }
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
555
23.2k
                    const T &arg, const Ts &...args) {
556
23.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
23.2k
558
23.2k
    // Recurse to the next argument.
559
23.2k
    return combine(length, buffer_ptr, buffer_end, args...);
560
23.2k
  }
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
555
5.54k
                    const T &arg, const Ts &...args) {
556
5.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
5.54k
558
5.54k
    // Recurse to the next argument.
559
5.54k
    return combine(length, buffer_ptr, buffer_end, args...);
560
5.54k
  }
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
555
5.54k
                    const T &arg, const Ts &...args) {
556
5.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
5.54k
558
5.54k
    // Recurse to the next argument.
559
5.54k
    return combine(length, buffer_ptr, buffer_end, args...);
560
5.54k
  }
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
555
5.54k
                    const T &arg, const Ts &...args) {
556
5.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
5.54k
558
5.54k
    // Recurse to the next argument.
559
5.54k
    return combine(length, buffer_ptr, buffer_end, args...);
560
5.54k
  }
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
555
5.54k
                    const T &arg, const Ts &...args) {
556
5.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
5.54k
558
5.54k
    // Recurse to the next argument.
559
5.54k
    return combine(length, buffer_ptr, buffer_end, args...);
560
5.54k
  }
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
555
5.54k
                    const T &arg, const Ts &...args) {
556
5.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
5.54k
558
5.54k
    // Recurse to the next argument.
559
5.54k
    return combine(length, buffer_ptr, buffer_end, args...);
560
5.54k
  }
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
555
12.9k
                    const T &arg, const Ts &...args) {
556
12.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
12.9k
558
12.9k
    // Recurse to the next argument.
559
12.9k
    return combine(length, buffer_ptr, buffer_end, args...);
560
12.9k
  }
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
555
122k
                    const T &arg, const Ts &...args) {
556
122k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
122k
558
122k
    // Recurse to the next argument.
559
122k
    return combine(length, buffer_ptr, buffer_end, args...);
560
122k
  }
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
555
122k
                    const T &arg, const Ts &...args) {
556
122k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
122k
558
122k
    // Recurse to the next argument.
559
122k
    return combine(length, buffer_ptr, buffer_end, args...);
560
122k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
555
28.4k
                    const T &arg, const Ts &...args) {
556
28.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
28.4k
558
28.4k
    // Recurse to the next argument.
559
28.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
28.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
555
28.4k
                    const T &arg, const Ts &...args) {
556
28.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
28.4k
558
28.4k
    // Recurse to the next argument.
559
28.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
28.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
555
28.4k
                    const T &arg, const Ts &...args) {
556
28.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
28.4k
558
28.4k
    // Recurse to the next argument.
559
28.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
28.4k
  }
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
555
32.8k
                    const T &arg, const Ts &...args) {
556
32.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
32.8k
558
32.8k
    // Recurse to the next argument.
559
32.8k
    return combine(length, buffer_ptr, buffer_end, args...);
560
32.8k
  }
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
555
3.23k
                    const T &arg, const Ts &...args) {
556
3.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.23k
558
3.23k
    // Recurse to the next argument.
559
3.23k
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.23k
  }
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
555
3.23k
                    const T &arg, const Ts &...args) {
556
3.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
3.23k
558
3.23k
    // Recurse to the next argument.
559
3.23k
    return combine(length, buffer_ptr, buffer_end, args...);
560
3.23k
  }
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
555
64
                    const T &arg, const Ts &...args) {
556
64
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
64
558
64
    // Recurse to the next argument.
559
64
    return combine(length, buffer_ptr, buffer_end, args...);
560
64
  }
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
555
21.5k
                    const T &arg, const Ts &...args) {
556
21.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
21.5k
558
21.5k
    // Recurse to the next argument.
559
21.5k
    return combine(length, buffer_ptr, buffer_end, args...);
560
21.5k
  }
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
555
500
                    const T &arg, const Ts &...args) {
556
500
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
500
558
500
    // Recurse to the next argument.
559
500
    return combine(length, buffer_ptr, buffer_end, args...);
560
500
  }
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
555
133
                    const T &arg, const Ts &...args) {
556
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
133
558
133
    // Recurse to the next argument.
559
133
    return combine(length, buffer_ptr, buffer_end, args...);
560
133
  }
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
555
133
                    const T &arg, const Ts &...args) {
556
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
133
558
133
    // Recurse to the next argument.
559
133
    return combine(length, buffer_ptr, buffer_end, args...);
560
133
  }
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
555
133
                    const T &arg, const Ts &...args) {
556
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
133
558
133
    // Recurse to the next argument.
559
133
    return combine(length, buffer_ptr, buffer_end, args...);
560
133
  }
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
555
1.21k
                    const T &arg, const Ts &...args) {
556
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.21k
558
1.21k
    // Recurse to the next argument.
559
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.21k
  }
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
555
1.21k
                    const T &arg, const Ts &...args) {
556
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
1.21k
558
1.21k
    // Recurse to the next argument.
559
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
560
1.21k
  }
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.85k
  }
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.85k
  }
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.85k
  }
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.85k
  }
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
555
2.85k
                    const T &arg, const Ts &...args) {
556
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.85k
558
2.85k
    // Recurse to the next argument.
559
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
560
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
555
21.4k
                    const T &arg, const Ts &...args) {
556
21.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
21.4k
558
21.4k
    // Recurse to the next argument.
559
21.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
21.4k
  }
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
555
21.4k
                    const T &arg, const Ts &...args) {
556
21.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
21.4k
558
21.4k
    // Recurse to the next argument.
559
21.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
21.4k
  }
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
555
21.4k
                    const T &arg, const Ts &...args) {
556
21.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
21.4k
558
21.4k
    // Recurse to the next argument.
559
21.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
21.4k
  }
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
555
21.4k
                    const T &arg, const Ts &...args) {
556
21.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
21.4k
558
21.4k
    // Recurse to the next argument.
559
21.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
21.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, unsigned int const&)
Line
Count
Source
555
54
                    const T &arg, const Ts &...args) {
556
54
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
54
558
54
    // Recurse to the next argument.
559
54
    return combine(length, buffer_ptr, buffer_end, args...);
560
54
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, unsigned int const&)
Line
Count
Source
555
54
                    const T &arg, const Ts &...args) {
556
54
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
54
558
54
    // Recurse to the next argument.
559
54
    return combine(length, buffer_ptr, buffer_end, args...);
560
54
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
167
                    const T &arg, const Ts &...args) {
556
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
167
558
167
    // Recurse to the next argument.
559
167
    return combine(length, buffer_ptr, buffer_end, args...);
560
167
  }
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
555
2.00k
                    const T &arg, const Ts &...args) {
556
2.00k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.00k
558
2.00k
    // Recurse to the next argument.
559
2.00k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.00k
  }
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
555
2.00k
                    const T &arg, const Ts &...args) {
556
2.00k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.00k
558
2.00k
    // Recurse to the next argument.
559
2.00k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.00k
  }
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
555
2.00k
                    const T &arg, const Ts &...args) {
556
2.00k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.00k
558
2.00k
    // Recurse to the next argument.
559
2.00k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.00k
  }
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
555
2.00k
                    const T &arg, const Ts &...args) {
556
2.00k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
2.00k
558
2.00k
    // Recurse to the next argument.
559
2.00k
    return combine(length, buffer_ptr, buffer_end, args...);
560
2.00k
  }
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
555
4.23k
                    const T &arg, const Ts &...args) {
556
4.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
4.23k
558
4.23k
    // Recurse to the next argument.
559
4.23k
    return combine(length, buffer_ptr, buffer_end, args...);
560
4.23k
  }
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
555
4.23k
                    const T &arg, const Ts &...args) {
556
4.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
4.23k
558
4.23k
    // Recurse to the next argument.
559
4.23k
    return combine(length, buffer_ptr, buffer_end, args...);
560
4.23k
  }
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
555
143
                    const T &arg, const Ts &...args) {
556
143
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
143
558
143
    // Recurse to the next argument.
559
143
    return combine(length, buffer_ptr, buffer_end, args...);
560
143
  }
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
555
143
                    const T &arg, const Ts &...args) {
556
143
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
143
558
143
    // Recurse to the next argument.
559
143
    return combine(length, buffer_ptr, buffer_end, args...);
560
143
  }
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
555
60.5k
                    const T &arg, const Ts &...args) {
556
60.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
60.5k
558
60.5k
    // Recurse to the next argument.
559
60.5k
    return combine(length, buffer_ptr, buffer_end, args...);
560
60.5k
  }
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
555
193k
                    const T &arg, const Ts &...args) {
556
193k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
193k
558
193k
    // Recurse to the next argument.
559
193k
    return combine(length, buffer_ptr, buffer_end, args...);
560
193k
  }
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
555
214k
                    const T &arg, const Ts &...args) {
556
214k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
214k
558
214k
    // Recurse to the next argument.
559
214k
    return combine(length, buffer_ptr, buffer_end, args...);
560
214k
  }
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
555
17.1M
                    const T &arg, const Ts &...args) {
556
17.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
17.1M
558
17.1M
    // Recurse to the next argument.
559
17.1M
    return combine(length, buffer_ptr, buffer_end, args...);
560
17.1M
  }
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
555
25.4k
                    const T &arg, const Ts &...args) {
556
25.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
25.4k
558
25.4k
    // Recurse to the next argument.
559
25.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
25.4k
  }
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
555
32.4k
                    const T &arg, const Ts &...args) {
556
32.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
32.4k
558
32.4k
    // Recurse to the next argument.
559
32.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
32.4k
  }
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
555
32.4k
                    const T &arg, const Ts &...args) {
556
32.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
32.4k
558
32.4k
    // Recurse to the next argument.
559
32.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
32.4k
  }
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
555
32.4k
                    const T &arg, const Ts &...args) {
556
32.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
32.4k
558
32.4k
    // Recurse to the next argument.
559
32.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
32.4k
  }
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
555
32.4k
                    const T &arg, const Ts &...args) {
556
32.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
32.4k
558
32.4k
    // Recurse to the next argument.
559
32.4k
    return combine(length, buffer_ptr, buffer_end, args...);
560
32.4k
  }
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
555
7.49M
                    const T &arg, const Ts &...args) {
556
7.49M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
7.49M
558
7.49M
    // Recurse to the next argument.
559
7.49M
    return combine(length, buffer_ptr, buffer_end, args...);
560
7.49M
  }
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
555
20.4M
                    const T &arg, const Ts &...args) {
556
20.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
20.4M
558
20.4M
    // Recurse to the next argument.
559
20.4M
    return combine(length, buffer_ptr, buffer_end, args...);
560
20.4M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&)
Line
Count
Source
555
28.8M
                    const T &arg, const Ts &...args) {
556
28.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
28.8M
558
28.8M
    // Recurse to the next argument.
559
28.8M
    return combine(length, buffer_ptr, buffer_end, args...);
560
28.8M
  }
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
555
12.7M
                    const T &arg, const Ts &...args) {
556
12.7M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
12.7M
558
12.7M
    // Recurse to the next argument.
559
12.7M
    return combine(length, buffer_ptr, buffer_end, args...);
560
12.7M
  }
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
555
12.7M
                    const T &arg, const Ts &...args) {
556
12.7M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
12.7M
558
12.7M
    // Recurse to the next argument.
559
12.7M
    return combine(length, buffer_ptr, buffer_end, args...);
560
12.7M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::SelectPatternFlavor, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, unsigned int const&, llvm::SelectPatternFlavor const&, llvm::Value* const&, llvm::Value* const&)
Line
Count
Source
555
231k
                    const T &arg, const Ts &...args) {
556
231k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
231k
558
231k
    // Recurse to the next argument.
559
231k
    return combine(length, buffer_ptr, buffer_end, args...);
560
231k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::SelectPatternFlavor, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::SelectPatternFlavor const&, llvm::Value* const&, llvm::Value* const&)
Line
Count
Source
555
231k
                    const T &arg, const Ts &...args) {
556
231k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
231k
558
231k
    // Recurse to the next argument.
559
231k
    return combine(length, buffer_ptr, buffer_end, args...);
560
231k
  }
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
555
8.32M
                    const T &arg, const Ts &...args) {
556
8.32M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
8.32M
558
8.32M
    // Recurse to the next argument.
559
8.32M
    return combine(length, buffer_ptr, buffer_end, args...);
560
8.32M
  }
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
555
8.32M
                    const T &arg, const Ts &...args) {
556
8.32M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
8.32M
558
8.32M
    // Recurse to the next argument.
559
8.32M
    return combine(length, buffer_ptr, buffer_end, args...);
560
8.32M
  }
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
555
362k
                    const T &arg, const Ts &...args) {
556
362k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
362k
558
362k
    // Recurse to the next argument.
559
362k
    return combine(length, buffer_ptr, buffer_end, args...);
560
362k
  }
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
555
483k
                    const T &arg, const Ts &...args) {
556
483k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
483k
558
483k
    // Recurse to the next argument.
559
483k
    return combine(length, buffer_ptr, buffer_end, args...);
560
483k
  }
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
555
121k
                    const T &arg, const Ts &...args) {
556
121k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
121k
558
121k
    // Recurse to the next argument.
559
121k
    return combine(length, buffer_ptr, buffer_end, args...);
560
121k
  }
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
555
121k
                    const T &arg, const Ts &...args) {
556
121k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
557
121k
558
121k
    // Recurse to the next argument.
559
121k
    return combine(length, buffer_ptr, buffer_end, args...);
560
121k
  }
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
555
2.41k
                    const T &arg, const Ts &...args) {
556
2.41k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg)