Coverage Report

Created: 2018-07-19 03:59

/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.14G
  hash_code(size_t value) : value(value) {}
82
83
  /// Convert the hash code to its numerical value for use.
84
1.04G
  /*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
15.6k
  friend bool operator!=(const hash_code &lhs, const hash_code &rhs) {
90
15.6k
    return lhs.value != rhs.value;
91
15.6k
  }
92
93
  /// Allow a hash_code to be directly run through hash_value.
94
98.4M
  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(size_t fixed_value);
137
138
139
// All of the implementation details of actually computing the various hash
140
// code values are held within this namespace. These routines are included in
141
// the header file mainly to allow inlining and constant propagation.
142
namespace hashing {
143
namespace detail {
144
145
4.00G
inline uint64_t fetch64(const char *p) {
146
4.00G
  uint64_t result;
147
4.00G
  memcpy(&result, p, sizeof(result));
148
4.00G
  if (sys::IsBigEndianHost)
149
0
    sys::swapByteOrder(result);
150
4.00G
  return result;
151
4.00G
}
152
153
605M
inline uint32_t fetch32(const char *p) {
154
605M
  uint32_t result;
155
605M
  memcpy(&result, p, sizeof(result));
156
605M
  if (sys::IsBigEndianHost)
157
0
    sys::swapByteOrder(result);
158
605M
  return result;
159
605M
}
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.76G
inline uint64_t rotate(uint64_t val, size_t shift) {
171
2.76G
  // Avoid shifting by 64: doing so yields an undefined result.
172
2.76G
  return shift == 0 ? 
val0
: ((val >> shift) | (val << (64 - shift)));
173
2.76G
}
174
175
275M
inline uint64_t shift_mix(uint64_t val) {
176
275M
  return val ^ (val >> 47);
177
275M
}
178
179
1.11G
inline uint64_t hash_16_bytes(uint64_t low, uint64_t high) {
180
1.11G
  // Murmur-inspired hashing.
181
1.11G
  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
182
1.11G
  uint64_t a = (low ^ high) * kMul;
183
1.11G
  a ^= (a >> 47);
184
1.11G
  uint64_t b = (high ^ a) * kMul;
185
1.11G
  b ^= (b >> 47);
186
1.11G
  b *= kMul;
187
1.11G
  return b;
188
1.11G
}
189
190
1.50M
inline uint64_t hash_1to3_bytes(const char *s, size_t len, uint64_t seed) {
191
1.50M
  uint8_t a = s[0];
192
1.50M
  uint8_t b = s[len >> 1];
193
1.50M
  uint8_t c = s[len - 1];
194
1.50M
  uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
195
1.50M
  uint32_t z = len + (static_cast<uint32_t>(c) << 2);
196
1.50M
  return shift_mix(y * k2 ^ z * k3 ^ seed) * k2;
197
1.50M
}
198
199
302M
inline uint64_t hash_4to8_bytes(const char *s, size_t len, uint64_t seed) {
200
302M
  uint64_t a = fetch32(s);
201
302M
  return hash_16_bytes(len + (a << 3), seed ^ fetch32(s + len - 4));
202
302M
}
203
204
330M
inline uint64_t hash_9to16_bytes(const char *s, size_t len, uint64_t seed) {
205
330M
  uint64_t a = fetch64(s);
206
330M
  uint64_t b = fetch64(s + len - 8);
207
330M
  return hash_16_bytes(seed ^ a, rotate(b + len, len)) ^ b;
208
330M
}
209
210
365M
inline uint64_t hash_17to32_bytes(const char *s, size_t len, uint64_t seed) {
211
365M
  uint64_t a = fetch64(s) * k1;
212
365M
  uint64_t b = fetch64(s + 8);
213
365M
  uint64_t c = fetch64(s + len - 8) * k2;
214
365M
  uint64_t d = fetch64(s + len - 16) * k0;
215
365M
  return hash_16_bytes(rotate(a - b, 43) + rotate(c ^ seed, 30) + d,
216
365M
                       a + rotate(b ^ k3, 20) - c + len + seed);
217
365M
}
218
219
101M
inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) {
220
101M
  uint64_t z = fetch64(s + 24);
221
101M
  uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0;
222
101M
  uint64_t b = rotate(a + z, 52);
223
101M
  uint64_t c = rotate(a, 37);
224
101M
  a += fetch64(s + 8);
225
101M
  c += rotate(a, 7);
226
101M
  a += fetch64(s + 16);
227
101M
  uint64_t vf = a + z;
228
101M
  uint64_t vs = b + rotate(a, 31) + c;
229
101M
  a = fetch64(s + 16) + fetch64(s + len - 32);
230
101M
  z = fetch64(s + len - 8);
231
101M
  b = rotate(a + z, 52);
232
101M
  c = rotate(a, 37);
233
101M
  a += fetch64(s + len - 24);
234
101M
  c += rotate(a, 7);
235
101M
  a += fetch64(s + len - 16);
236
101M
  uint64_t wf = a + z;
237
101M
  uint64_t ws = b + rotate(a, 31) + c;
238
101M
  uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0);
239
101M
  return shift_mix((seed ^ (r * k0)) + vs) * k2;
240
101M
}
241
242
1.12G
inline uint64_t hash_short(const char *s, size_t length, uint64_t seed) {
243
1.12G
  if (length >= 4 && 
length <= 81.10G
)
244
302M
    return hash_4to8_bytes(s, length, seed);
245
818M
  if (length > 8 && 
length <= 16798M
)
246
330M
    return hash_9to16_bytes(s, length, seed);
247
487M
  if (length > 16 && 
length <= 32467M
)
248
365M
    return hash_17to32_bytes(s, length, seed);
249
122M
  if (length > 32)
250
101M
    return hash_33to64_bytes(s, length, seed);
251
20.2M
  if (length != 0)
252
1.50M
    return hash_1to3_bytes(s, length, seed);
253
18.7M
254
18.7M
  return k2 ^ seed;
255
18.7M
}
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
23.5M
  static hash_state create(const char *s, uint64_t seed) {
267
23.5M
    hash_state state = {
268
23.5M
      0, seed, hash_16_bytes(seed, k1), rotate(seed ^ k1, 49),
269
23.5M
      seed * k1, shift_mix(seed), 0 };
270
23.5M
    state.h6 = hash_16_bytes(state.h4, state.h5);
271
23.5M
    state.mix(s);
272
23.5M
    return state;
273
23.5M
  }
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
143M
  static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) {
278
143M
    a += fetch64(s);
279
143M
    uint64_t c = fetch64(s + 24);
280
143M
    b = rotate(b + a + c, 21);
281
143M
    uint64_t d = a;
282
143M
    a += fetch64(s + 8) + fetch64(s + 16);
283
143M
    b += rotate(a, 44) + d;
284
143M
    a += c;
285
143M
  }
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
71.8M
  void mix(const char *s) {
291
71.8M
    h0 = rotate(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
292
71.8M
    h1 = rotate(h1 + h4 + fetch64(s + 48), 42) * k1;
293
71.8M
    h0 ^= h6;
294
71.8M
    h1 += h3 + fetch64(s + 40);
295
71.8M
    h2 = rotate(h2 + h5, 33) * k1;
296
71.8M
    h3 = h4 * k1;
297
71.8M
    h4 = h0 + h5;
298
71.8M
    mix_32_bytes(s, h3, h4);
299
71.8M
    h5 = h2 + h6;
300
71.8M
    h6 = h1 + fetch64(s + 16);
301
71.8M
    mix_32_bytes(s + 32, h5, h6);
302
71.8M
    std::swap(h2, h0);
303
71.8M
  }
304
305
  /// Compute the final 64-bit hash code value based on the current
306
  /// state and the length of bytes hashed.
307
23.5M
  uint64_t finalize(size_t length) {
308
23.5M
    return hash_16_bytes(hash_16_bytes(h3, h5) + shift_mix(h1) * k1 + h2,
309
23.5M
                         hash_16_bytes(h4, h6) + shift_mix(length) * k1 + h0);
310
23.5M
  }
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 size_t fixed_seed_override;
320
321
1.14G
inline size_t get_execution_seed() {
322
1.14G
  // FIXME: This needs to be a per-execution seed. This is just a placeholder
323
1.14G
  // implementation. Switching to a per-execution seed is likely to flush out
324
1.14G
  // instability bugs and so will happen as its own commit.
325
1.14G
  //
326
1.14G
  // However, if there is a fixed seed override set the first time this is
327
1.14G
  // called, return that instead of the per-execution seed.
328
1.14G
  const uint64_t seed_prime = 0xff51afd7ed558ccdULL;
329
1.14G
  static size_t seed = fixed_seed_override ? 
fixed_seed_override0
330
1.14G
                                           : (size_t)seed_prime;
331
1.14G
  return seed;
332
1.14G
}
333
334
335
/// Trait to indicate whether a type's bits can be hashed directly.
336
///
337
/// A type trait which is true if we want to combine values for hashing by
338
/// reading the underlying data. It is false if values of this type must
339
/// first be passed to hash_value, and the resulting hash_codes combined.
340
//
341
// FIXME: We want to replace is_integral_or_enum and is_pointer here with
342
// a predicate which asserts that comparing the underlying storage of two
343
// values of the type for equality is equivalent to comparing the two values
344
// for equality. For all the platforms we care about, this holds for integers
345
// and pointers, but there are platforms where it doesn't and we would like to
346
// support user-defined types which happen to satisfy this property.
347
template <typename T> struct is_hashable_data
348
  : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
349
                                   std::is_pointer<T>::value) &&
350
                                  64 % sizeof(T) == 0)> {};
351
352
// Special case std::pair to detect when both types are viable and when there
353
// is no alignment-derived padding in the pair. This is a bit of a lie because
354
// std::pair isn't truly POD, but it's close enough in all reasonable
355
// implementations for our use case of hashing the underlying data.
356
template <typename T, typename U> struct is_hashable_data<std::pair<T, U> >
357
  : std::integral_constant<bool, (is_hashable_data<T>::value &&
358
                                  is_hashable_data<U>::value &&
359
                                  (sizeof(T) + sizeof(U)) ==
360
                                   sizeof(std::pair<T, U>))> {};
361
362
/// Helper to get the hashable data representation for a type.
363
/// This variant is enabled when the type itself can be used.
364
template <typename T>
365
typename std::enable_if<is_hashable_data<T>::value, T>::type
366
957M
get_hashable_data(const T &value) {
367
957M
  return value;
368
957M
}
std::__1::enable_if<is_hashable_data<unsigned int>::value, unsigned int>::type llvm::hashing::detail::get_hashable_data<unsigned int>(unsigned int const&)
Line
Count
Source
366
266M
get_hashable_data(const T &value) {
367
266M
  return value;
368
266M
}
std::__1::enable_if<is_hashable_data<llvm::coverage::CounterExpression::ExprKind>::value, llvm::coverage::CounterExpression::ExprKind>::type llvm::hashing::detail::get_hashable_data<llvm::coverage::CounterExpression::ExprKind>(llvm::coverage::CounterExpression::ExprKind const&)
Line
Count
Source
366
1.74k
get_hashable_data(const T &value) {
367
1.74k
  return value;
368
1.74k
}
std::__1::enable_if<is_hashable_data<llvm::coverage::Counter::CounterKind>::value, llvm::coverage::Counter::CounterKind>::type llvm::hashing::detail::get_hashable_data<llvm::coverage::Counter::CounterKind>(llvm::coverage::Counter::CounterKind const&)
Line
Count
Source
366
3.48k
get_hashable_data(const T &value) {
367
3.48k
  return value;
368
3.48k
}
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
366
262
get_hashable_data(const T &value) {
367
262
  return value;
368
262
}
std::__1::enable_if<is_hashable_data<bool>::value, bool>::type llvm::hashing::detail::get_hashable_data<bool>(bool const&)
Line
Count
Source
366
52.9M
get_hashable_data(const T &value) {
367
52.9M
  return value;
368
52.9M
}
std::__1::enable_if<is_hashable_data<int>::value, int>::type llvm::hashing::detail::get_hashable_data<int>(int const&)
Line
Count
Source
366
1.04M
get_hashable_data(const T &value) {
367
1.04M
  return value;
368
1.04M
}
std::__1::enable_if<is_hashable_data<char const*>::value, char const*>::type llvm::hashing::detail::get_hashable_data<char const*>(char const* const&)
Line
Count
Source
366
5.93k
get_hashable_data(const T &value) {
367
5.93k
  return value;
368
5.93k
}
std::__1::enable_if<is_hashable_data<llvm::GlobalValue const*>::value, llvm::GlobalValue const*>::type llvm::hashing::detail::get_hashable_data<llvm::GlobalValue const*>(llvm::GlobalValue const* const&)
Line
Count
Source
366
3.87M
get_hashable_data(const T &value) {
367
3.87M
  return value;
368
3.87M
}
std::__1::enable_if<is_hashable_data<llvm::BlockAddress const*>::value, llvm::BlockAddress const*>::type llvm::hashing::detail::get_hashable_data<llvm::BlockAddress const*>(llvm::BlockAddress const* const&)
Line
Count
Source
366
382
get_hashable_data(const T &value) {
367
382
  return value;
368
382
}
std::__1::enable_if<is_hashable_data<llvm::MCSymbol*>::value, llvm::MCSymbol*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol*>(llvm::MCSymbol* const&)
Line
Count
Source
366
160
get_hashable_data(const T &value) {
367
160
  return value;
368
160
}
std::__1::enable_if<is_hashable_data<llvm::MachineBasicBlock*>::value, llvm::MachineBasicBlock*>::type llvm::hashing::detail::get_hashable_data<llvm::MachineBasicBlock*>(llvm::MachineBasicBlock* const&)
Line
Count
Source
366
1.66M
get_hashable_data(const T &value) {
367
1.66M
  return value;
368
1.66M
}
std::__1::enable_if<is_hashable_data<llvm::MachineOperand::MachineOperandType>::value, llvm::MachineOperand::MachineOperandType>::type llvm::hashing::detail::get_hashable_data<llvm::MachineOperand::MachineOperandType>(llvm::MachineOperand::MachineOperandType const&)
Line
Count
Source
366
72.0M
get_hashable_data(const T &value) {
367
72.0M
  return value;
368
72.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
366
26.2M
get_hashable_data(const T &value) {
367
26.2M
  return value;
368
26.2M
}
std::__1::enable_if<is_hashable_data<llvm::ConstantInt const*>::value, llvm::ConstantInt const*>::type llvm::hashing::detail::get_hashable_data<llvm::ConstantInt const*>(llvm::ConstantInt const* const&)
Line
Count
Source
366
15
get_hashable_data(const T &value) {
367
15
  return value;
368
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
366
241
get_hashable_data(const T &value) {
367
241
  return value;
368
241
}
std::__1::enable_if<is_hashable_data<unsigned int const*>::value, unsigned int const*>::type llvm::hashing::detail::get_hashable_data<unsigned int const*>(unsigned int const* const&)
Line
Count
Source
366
12
get_hashable_data(const T &value) {
367
12
  return value;
368
12
}
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
366
24.5k
get_hashable_data(const T &value) {
367
24.5k
  return value;
368
24.5k
}
std::__1::enable_if<is_hashable_data<llvm::FunctionType*>::value, llvm::FunctionType*>::type llvm::hashing::detail::get_hashable_data<llvm::FunctionType*>(llvm::FunctionType* const&)
Line
Count
Source
366
24.5k
get_hashable_data(const T &value) {
367
24.5k
  return value;
368
24.5k
}
std::__1::enable_if<is_hashable_data<unsigned char>::value, unsigned char>::type llvm::hashing::detail::get_hashable_data<unsigned char>(unsigned char const&)
Line
Count
Source
366
36.3M
get_hashable_data(const T &value) {
367
36.3M
  return value;
368
36.3M
}
std::__1::enable_if<is_hashable_data<unsigned short>::value, unsigned short>::type llvm::hashing::detail::get_hashable_data<unsigned short>(unsigned short const&)
Line
Count
Source
366
16.9M
get_hashable_data(const T &value) {
367
16.9M
  return value;
368
16.9M
}
std::__1::enable_if<is_hashable_data<llvm::Type const*>::value, llvm::Type const*>::type llvm::hashing::detail::get_hashable_data<llvm::Type const*>(llvm::Type const* const&)
Line
Count
Source
366
7.12M
get_hashable_data(const T &value) {
367
7.12M
  return value;
368
7.12M
}
std::__1::enable_if<is_hashable_data<llvm::Metadata*>::value, llvm::Metadata*>::type llvm::hashing::detail::get_hashable_data<llvm::Metadata*>(llvm::Metadata* const&)
Line
Count
Source
366
32.1M
get_hashable_data(const T &value) {
367
32.1M
  return value;
368
32.1M
}
std::__1::enable_if<is_hashable_data<llvm::MDString*>::value, llvm::MDString*>::type llvm::hashing::detail::get_hashable_data<llvm::MDString*>(llvm::MDString* const&)
Line
Count
Source
366
202k
get_hashable_data(const T &value) {
367
202k
  return value;
368
202k
}
std::__1::enable_if<is_hashable_data<unsigned long long>::value, unsigned long long>::type llvm::hashing::detail::get_hashable_data<unsigned long long>(unsigned long long const&)
Line
Count
Source
366
224M
get_hashable_data(const T &value) {
367
224M
  return value;
368
224M
}
std::__1::enable_if<is_hashable_data<llvm::ArrayType*>::value, llvm::ArrayType*>::type llvm::hashing::detail::get_hashable_data<llvm::ArrayType*>(llvm::ArrayType* const&)
Line
Count
Source
366
59.0k
get_hashable_data(const T &value) {
367
59.0k
  return value;
368
59.0k
}
std::__1::enable_if<is_hashable_data<llvm::StructType*>::value, llvm::StructType*>::type llvm::hashing::detail::get_hashable_data<llvm::StructType*>(llvm::StructType* const&)
Line
Count
Source
366
189k
get_hashable_data(const T &value) {
367
189k
  return value;
368
189k
}
std::__1::enable_if<is_hashable_data<llvm::VectorType*>::value, llvm::VectorType*>::type llvm::hashing::detail::get_hashable_data<llvm::VectorType*>(llvm::VectorType* const&)
Line
Count
Source
366
210k
get_hashable_data(const T &value) {
367
210k
  return value;
368
210k
}
std::__1::enable_if<is_hashable_data<llvm::Type*>::value, llvm::Type*>::type llvm::hashing::detail::get_hashable_data<llvm::Type*>(llvm::Type* const&)
Line
Count
Source
366
47.0M
get_hashable_data(const T &value) {
367
47.0M
  return value;
368
47.0M
}
std::__1::enable_if<is_hashable_data<llvm::PointerType*>::value, llvm::PointerType*>::type llvm::hashing::detail::get_hashable_data<llvm::PointerType*>(llvm::PointerType* const&)
Line
Count
Source
366
24.5k
get_hashable_data(const T &value) {
367
24.5k
  return value;
368
24.5k
}
std::__1::enable_if<is_hashable_data<char>::value, char>::type llvm::hashing::detail::get_hashable_data<char>(char const&)
Line
Count
Source
366
484k
get_hashable_data(const T &value) {
367
484k
  return value;
368
484k
}
std::__1::enable_if<is_hashable_data<llvm::MemoryAccess const*>::value, llvm::MemoryAccess const*>::type llvm::hashing::detail::get_hashable_data<llvm::MemoryAccess const*>(llvm::MemoryAccess const* const&)
Line
Count
Source
366
1.08k
get_hashable_data(const T &value) {
367
1.08k
  return value;
368
1.08k
}
std::__1::enable_if<is_hashable_data<llvm::Value*>::value, llvm::Value*>::type llvm::hashing::detail::get_hashable_data<llvm::Value*>(llvm::Value* const&)
Line
Count
Source
366
125M
get_hashable_data(const T &value) {
367
125M
  return value;
368
125M
}
std::__1::enable_if<is_hashable_data<llvm::Constant*>::value, llvm::Constant*>::type llvm::hashing::detail::get_hashable_data<llvm::Constant*>(llvm::Constant* const&)
Line
Count
Source
366
461
get_hashable_data(const T &value) {
367
461
  return value;
368
461
}
std::__1::enable_if<is_hashable_data<llvm::Instruction*>::value, llvm::Instruction*>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction*>(llvm::Instruction* const&)
Line
Count
Source
366
264
get_hashable_data(const T &value) {
367
264
  return value;
368
264
}
std::__1::enable_if<is_hashable_data<llvm::MCSymbol const*>::value, llvm::MCSymbol const*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol const*>(llvm::MCSymbol const* const&)
Line
Count
Source
366
31.8k
get_hashable_data(const T &value) {
367
31.8k
  return value;
368
31.8k
}
std::__1::enable_if<is_hashable_data<llvm::Instruction::BinaryOps>::value, llvm::Instruction::BinaryOps>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction::BinaryOps>(llvm::Instruction::BinaryOps const&)
Line
Count
Source
366
7.25M
get_hashable_data(const T &value) {
367
7.25M
  return value;
368
7.25M
}
std::__1::enable_if<is_hashable_data<llvm::CmpInst::Predicate>::value, llvm::CmpInst::Predicate>::type llvm::hashing::detail::get_hashable_data<llvm::CmpInst::Predicate>(llvm::CmpInst::Predicate const&)
Line
Count
Source
366
12.4M
get_hashable_data(const T &value) {
367
12.4M
  return value;
368
12.4M
}
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
366
224k
get_hashable_data(const T &value) {
367
224k
  return value;
368
224k
}
std::__1::enable_if<is_hashable_data<llvm::Instruction::CastOps>::value, llvm::Instruction::CastOps>::type llvm::hashing::detail::get_hashable_data<llvm::Instruction::CastOps>(llvm::Instruction::CastOps const&)
Line
Count
Source
366
7.90M
get_hashable_data(const T &value) {
367
7.90M
  return value;
368
7.90M
}
std::__1::enable_if<is_hashable_data<short>::value, short>::type llvm::hashing::detail::get_hashable_data<short>(short const&)
Line
Count
Source
366
991k
get_hashable_data(const T &value) {
367
991k
  return value;
368
991k
}
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
366
679k
get_hashable_data(const T &value) {
367
679k
  return value;
368
679k
}
std::__1::enable_if<is_hashable_data<void*>::value, void*>::type llvm::hashing::detail::get_hashable_data<void*>(void* const&)
Line
Count
Source
366
33.9k
get_hashable_data(const T &value) {
367
33.9k
  return value;
368
33.9k
}
std::__1::enable_if<is_hashable_data<clang::NestedNameSpecifier*>::value, clang::NestedNameSpecifier*>::type llvm::hashing::detail::get_hashable_data<clang::NestedNameSpecifier*>(clang::NestedNameSpecifier* const&)
Line
Count
Source
366
782
get_hashable_data(const T &value) {
367
782
  return value;
368
782
}
std::__1::enable_if<is_hashable_data<llvm::RegisterBankInfo::ValueMapping const*>::value, llvm::RegisterBankInfo::ValueMapping const*>::type llvm::hashing::detail::get_hashable_data<llvm::RegisterBankInfo::ValueMapping const*>(llvm::RegisterBankInfo::ValueMapping const* const&)
Line
Count
Source
366
14.1M
get_hashable_data(const T &value) {
367
14.1M
  return value;
368
14.1M
}
std::__1::enable_if<is_hashable_data<long>::value, long>::type llvm::hashing::detail::get_hashable_data<long>(long const&)
Line
Count
Source
366
61.7k
get_hashable_data(const T &value) {
367
61.7k
  return value;
368
61.7k
}
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
366
1
get_hashable_data(const T &value) {
367
1
  return value;
368
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
366
2.40k
get_hashable_data(const T &value) {
367
2.40k
  return value;
368
2.40k
}
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
366
54
get_hashable_data(const T &value) {
367
54
  return value;
368
54
}
369
/// Helper to get the hashable data representation for a type.
370
/// This variant is enabled when we must first call hash_value and use the
371
/// result as our data.
372
template <typename T>
373
typename std::enable_if<!is_hashable_data<T>::value, size_t>::type
374
98.9M
get_hashable_data(const T &value) {
375
98.9M
  using ::llvm::hash_value;
376
98.9M
  return hash_value(value);
377
98.9M
}
std::__1::enable_if<!(is_hashable_data<llvm::hash_code>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::hash_code>(llvm::hash_code const&)
Line
Count
Source
374
98.4M
get_hashable_data(const T &value) {
375
98.4M
  using ::llvm::hash_value;
376
98.4M
  return hash_value(value);
377
98.4M
}
std::__1::enable_if<!(is_hashable_data<llvm::MachineOperand>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::MachineOperand>(llvm::MachineOperand const&)
Line
Count
Source
374
385k
get_hashable_data(const T &value) {
375
385k
  using ::llvm::hash_value;
376
385k
  return hash_value(value);
377
385k
}
std::__1::enable_if<!(is_hashable_data<llvm::StringRef>::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::StringRef>(llvm::StringRef const&)
Line
Count
Source
374
49.8k
get_hashable_data(const T &value) {
375
49.8k
  using ::llvm::hash_value;
376
49.8k
  return hash_value(value);
377
49.8k
}
std::__1::enable_if<!(is_hashable_data<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&)
Line
Count
Source
374
18.1k
get_hashable_data(const T &value) {
375
18.1k
  using ::llvm::hash_value;
376
18.1k
  return hash_value(value);
377
18.1k
}
std::__1::enable_if<!(is_hashable_data<llvm::ArrayRef<unsigned char> >::value), unsigned long>::type llvm::hashing::detail::get_hashable_data<llvm::ArrayRef<unsigned char> >(llvm::ArrayRef<unsigned char> const&)
Line
Count
Source
374
2.37k
get_hashable_data(const T &value) {
375
2.37k
  using ::llvm::hash_value;
376
2.37k
  return hash_value(value);
377
2.37k
}
378
379
/// Helper to store data from a value into a buffer and advance the
380
/// pointer into that buffer.
381
///
382
/// This routine first checks whether there is enough space in the provided
383
/// buffer, and if not immediately returns false. If there is space, it
384
/// copies the underlying bytes of value into the buffer, advances the
385
/// buffer_ptr past the copied bytes, and returns true.
386
template <typename T>
387
bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value,
388
1.09G
                       size_t offset = 0) {
389
1.09G
  size_t store_size = sizeof(value) - offset;
390
1.09G
  if (buffer_ptr + store_size > buffer_end)
391
4.44M
    return false;
392
1.08G
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1.08G
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1.08G
  buffer_ptr += store_size;
395
1.08G
  return true;
396
1.08G
}
bool llvm::hashing::detail::store_and_advance<unsigned int>(char*&, char*, unsigned int const&, unsigned long)
Line
Count
Source
388
266M
                       size_t offset = 0) {
389
266M
  size_t store_size = sizeof(value) - offset;
390
266M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
266M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
266M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
266M
  buffer_ptr += store_size;
395
266M
  return true;
396
266M
}
bool llvm::hashing::detail::store_and_advance<unsigned long>(char*&, char*, unsigned long const&, unsigned long)
Line
Count
Source
388
98.9M
                       size_t offset = 0) {
389
98.9M
  size_t store_size = sizeof(value) - offset;
390
98.9M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
98.9M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
98.9M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
98.9M
  buffer_ptr += store_size;
395
98.9M
  return true;
396
98.9M
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::CounterExpression::ExprKind>(char*&, char*, llvm::coverage::CounterExpression::ExprKind const&, unsigned long)
Line
Count
Source
388
1.74k
                       size_t offset = 0) {
389
1.74k
  size_t store_size = sizeof(value) - offset;
390
1.74k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
1.74k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1.74k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1.74k
  buffer_ptr += store_size;
395
1.74k
  return true;
396
1.74k
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::Counter::CounterKind>(char*&, char*, llvm::coverage::Counter::CounterKind const&, unsigned long)
Line
Count
Source
388
3.48k
                       size_t offset = 0) {
389
3.48k
  size_t store_size = sizeof(value) - offset;
390
3.48k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
3.48k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
3.48k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
3.48k
  buffer_ptr += store_size;
395
3.48k
  return true;
396
3.48k
}
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
388
262
                       size_t offset = 0) {
389
262
  size_t store_size = sizeof(value) - offset;
390
262
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
262
  const char *value_data = reinterpret_cast<const char *>(&value);
393
262
  memcpy(buffer_ptr, value_data + offset, store_size);
394
262
  buffer_ptr += store_size;
395
262
  return true;
396
262
}
bool llvm::hashing::detail::store_and_advance<bool>(char*&, char*, bool const&, unsigned long)
Line
Count
Source
388
52.9M
                       size_t offset = 0) {
389
52.9M
  size_t store_size = sizeof(value) - offset;
390
52.9M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
52.9M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
52.9M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
52.9M
  buffer_ptr += store_size;
395
52.9M
  return true;
396
52.9M
}
bool llvm::hashing::detail::store_and_advance<int>(char*&, char*, int const&, unsigned long)
Line
Count
Source
388
1.04M
                       size_t offset = 0) {
389
1.04M
  size_t store_size = sizeof(value) - offset;
390
1.04M
  if (buffer_ptr + store_size > buffer_end)
391
4
    return false;
392
1.04M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1.04M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1.04M
  buffer_ptr += store_size;
395
1.04M
  return true;
396
1.04M
}
bool llvm::hashing::detail::store_and_advance<char const*>(char*&, char*, char const* const&, unsigned long)
Line
Count
Source
388
5.93k
                       size_t offset = 0) {
389
5.93k
  size_t store_size = sizeof(value) - offset;
390
5.93k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
5.93k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
5.93k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
5.93k
  buffer_ptr += store_size;
395
5.93k
  return true;
396
5.93k
}
bool llvm::hashing::detail::store_and_advance<llvm::GlobalValue const*>(char*&, char*, llvm::GlobalValue const* const&, unsigned long)
Line
Count
Source
388
3.87M
                       size_t offset = 0) {
389
3.87M
  size_t store_size = sizeof(value) - offset;
390
3.87M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
3.87M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
3.87M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
3.87M
  buffer_ptr += store_size;
395
3.87M
  return true;
396
3.87M
}
bool llvm::hashing::detail::store_and_advance<llvm::BlockAddress const*>(char*&, char*, llvm::BlockAddress const* const&, unsigned long)
Line
Count
Source
388
382
                       size_t offset = 0) {
389
382
  size_t store_size = sizeof(value) - offset;
390
382
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
382
  const char *value_data = reinterpret_cast<const char *>(&value);
393
382
  memcpy(buffer_ptr, value_data + offset, store_size);
394
382
  buffer_ptr += store_size;
395
382
  return true;
396
382
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol*>(char*&, char*, llvm::MCSymbol* const&, unsigned long)
Line
Count
Source
388
160
                       size_t offset = 0) {
389
160
  size_t store_size = sizeof(value) - offset;
390
160
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
160
  const char *value_data = reinterpret_cast<const char *>(&value);
393
160
  memcpy(buffer_ptr, value_data + offset, store_size);
394
160
  buffer_ptr += store_size;
395
160
  return true;
396
160
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineBasicBlock*>(char*&, char*, llvm::MachineBasicBlock* const&, unsigned long)
Line
Count
Source
388
1.66M
                       size_t offset = 0) {
389
1.66M
  size_t store_size = sizeof(value) - offset;
390
1.66M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
1.66M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1.66M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1.66M
  buffer_ptr += store_size;
395
1.66M
  return true;
396
1.66M
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineOperand::MachineOperandType>(char*&, char*, llvm::MachineOperand::MachineOperandType const&, unsigned long)
Line
Count
Source
388
72.0M
                       size_t offset = 0) {
389
72.0M
  size_t store_size = sizeof(value) - offset;
390
72.0M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
72.0M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
72.0M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
72.0M
  buffer_ptr += store_size;
395
72.0M
  return true;
396
72.0M
}
bool llvm::hashing::detail::store_and_advance<long long>(char*&, char*, long long const&, unsigned long)
Line
Count
Source
388
26.2M
                       size_t offset = 0) {
389
26.2M
  size_t store_size = sizeof(value) - offset;
390
26.2M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
26.2M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
26.2M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
26.2M
  buffer_ptr += store_size;
395
26.2M
  return true;
396
26.2M
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantInt const*>(char*&, char*, llvm::ConstantInt const* const&, unsigned long)
Line
Count
Source
388
15
                       size_t offset = 0) {
389
15
  size_t store_size = sizeof(value) - offset;
390
15
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
15
  const char *value_data = reinterpret_cast<const char *>(&value);
393
15
  memcpy(buffer_ptr, value_data + offset, store_size);
394
15
  buffer_ptr += store_size;
395
15
  return true;
396
15
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantFP const*>(char*&, char*, llvm::ConstantFP const* const&, unsigned long)
Line
Count
Source
388
241
                       size_t offset = 0) {
389
241
  size_t store_size = sizeof(value) - offset;
390
241
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
241
  const char *value_data = reinterpret_cast<const char *>(&value);
393
241
  memcpy(buffer_ptr, value_data + offset, store_size);
394
241
  buffer_ptr += store_size;
395
241
  return true;
396
241
}
bool llvm::hashing::detail::store_and_advance<unsigned int const*>(char*&, char*, unsigned int const* const&, unsigned long)
Line
Count
Source
388
12
                       size_t offset = 0) {
389
12
  size_t store_size = sizeof(value) - offset;
390
12
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
12
  const char *value_data = reinterpret_cast<const char *>(&value);
393
12
  memcpy(buffer_ptr, value_data + offset, store_size);
394
12
  buffer_ptr += store_size;
395
12
  return true;
396
12
}
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
388
24.5k
                       size_t offset = 0) {
389
24.5k
  size_t store_size = sizeof(value) - offset;
390
24.5k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
24.5k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
24.5k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
24.5k
  buffer_ptr += store_size;
395
24.5k
  return true;
396
24.5k
}
bool llvm::hashing::detail::store_and_advance<llvm::FunctionType*>(char*&, char*, llvm::FunctionType* const&, unsigned long)
Line
Count
Source
388
24.5k
                       size_t offset = 0) {
389
24.5k
  size_t store_size = sizeof(value) - offset;
390
24.5k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
24.5k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
24.5k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
24.5k
  buffer_ptr += store_size;
395
24.5k
  return true;
396
24.5k
}
bool llvm::hashing::detail::store_and_advance<unsigned char>(char*&, char*, unsigned char const&, unsigned long)
Line
Count
Source
388
36.3M
                       size_t offset = 0) {
389
36.3M
  size_t store_size = sizeof(value) - offset;
390
36.3M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
36.3M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
36.3M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
36.3M
  buffer_ptr += store_size;
395
36.3M
  return true;
396
36.3M
}
bool llvm::hashing::detail::store_and_advance<unsigned short>(char*&, char*, unsigned short const&, unsigned long)
Line
Count
Source
388
16.9M
                       size_t offset = 0) {
389
16.9M
  size_t store_size = sizeof(value) - offset;
390
16.9M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
16.9M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
16.9M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
16.9M
  buffer_ptr += store_size;
395
16.9M
  return true;
396
16.9M
}
bool llvm::hashing::detail::store_and_advance<llvm::Type const*>(char*&, char*, llvm::Type const* const&, unsigned long)
Line
Count
Source
388
7.12M
                       size_t offset = 0) {
389
7.12M
  size_t store_size = sizeof(value) - offset;
390
7.12M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
7.12M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
7.12M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
7.12M
  buffer_ptr += store_size;
395
7.12M
  return true;
396
7.12M
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata*>(char*&, char*, llvm::Metadata* const&, unsigned long)
Line
Count
Source
388
32.1M
                       size_t offset = 0) {
389
32.1M
  size_t store_size = sizeof(value) - offset;
390
32.1M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
32.1M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
32.1M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
32.1M
  buffer_ptr += store_size;
395
32.1M
  return true;
396
32.1M
}
bool llvm::hashing::detail::store_and_advance<llvm::MDString*>(char*&, char*, llvm::MDString* const&, unsigned long)
Line
Count
Source
388
202k
                       size_t offset = 0) {
389
202k
  size_t store_size = sizeof(value) - offset;
390
202k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
202k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
202k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
202k
  buffer_ptr += store_size;
395
202k
  return true;
396
202k
}
bool llvm::hashing::detail::store_and_advance<unsigned long long>(char*&, char*, unsigned long long const&, unsigned long)
Line
Count
Source
388
224M
                       size_t offset = 0) {
389
224M
  size_t store_size = sizeof(value) - offset;
390
224M
  if (buffer_ptr + store_size > buffer_end)
391
2
    return false;
392
224M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
224M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
224M
  buffer_ptr += store_size;
395
224M
  return true;
396
224M
}
bool llvm::hashing::detail::store_and_advance<llvm::ArrayType*>(char*&, char*, llvm::ArrayType* const&, unsigned long)
Line
Count
Source
388
59.0k
                       size_t offset = 0) {
389
59.0k
  size_t store_size = sizeof(value) - offset;
390
59.0k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
59.0k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
59.0k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
59.0k
  buffer_ptr += store_size;
395
59.0k
  return true;
396
59.0k
}
bool llvm::hashing::detail::store_and_advance<llvm::StructType*>(char*&, char*, llvm::StructType* const&, unsigned long)
Line
Count
Source
388
189k
                       size_t offset = 0) {
389
189k
  size_t store_size = sizeof(value) - offset;
390
189k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
189k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
189k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
189k
  buffer_ptr += store_size;
395
189k
  return true;
396
189k
}
bool llvm::hashing::detail::store_and_advance<llvm::VectorType*>(char*&, char*, llvm::VectorType* const&, unsigned long)
Line
Count
Source
388
210k
                       size_t offset = 0) {
389
210k
  size_t store_size = sizeof(value) - offset;
390
210k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
210k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
210k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
210k
  buffer_ptr += store_size;
395
210k
  return true;
396
210k
}
bool llvm::hashing::detail::store_and_advance<llvm::Type*>(char*&, char*, llvm::Type* const&, unsigned long)
Line
Count
Source
388
47.0M
                       size_t offset = 0) {
389
47.0M
  size_t store_size = sizeof(value) - offset;
390
47.0M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
47.0M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
47.0M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
47.0M
  buffer_ptr += store_size;
395
47.0M
  return true;
396
47.0M
}
bool llvm::hashing::detail::store_and_advance<llvm::PointerType*>(char*&, char*, llvm::PointerType* const&, unsigned long)
Line
Count
Source
388
24.5k
                       size_t offset = 0) {
389
24.5k
  size_t store_size = sizeof(value) - offset;
390
24.5k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
24.5k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
24.5k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
24.5k
  buffer_ptr += store_size;
395
24.5k
  return true;
396
24.5k
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata const*>(char*&, char*, llvm::Metadata const* const&, unsigned long)
Line
Count
Source
388
36.8M
                       size_t offset = 0) {
389
36.8M
  size_t store_size = sizeof(value) - offset;
390
36.8M
  if (buffer_ptr + store_size > buffer_end)
391
4.08M
    return false;
392
32.7M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
32.7M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
32.7M
  buffer_ptr += store_size;
395
32.7M
  return true;
396
32.7M
}
bool llvm::hashing::detail::store_and_advance<char>(char*&, char*, char const&, unsigned long)
Line
Count
Source
388
484k
                       size_t offset = 0) {
389
484k
  size_t store_size = sizeof(value) - offset;
390
484k
  if (buffer_ptr + store_size > buffer_end)
391
3.80k
    return false;
392
480k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
480k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
480k
  buffer_ptr += store_size;
395
480k
  return true;
396
480k
}
bool llvm::hashing::detail::store_and_advance<llvm::MemoryAccess const*>(char*&, char*, llvm::MemoryAccess const* const&, unsigned long)
Line
Count
Source
388
1.08k
                       size_t offset = 0) {
389
1.08k
  size_t store_size = sizeof(value) - offset;
390
1.08k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
1.08k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1.08k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1.08k
  buffer_ptr += store_size;
395
1.08k
  return true;
396
1.08k
}
bool llvm::hashing::detail::store_and_advance<llvm::Value*>(char*&, char*, llvm::Value* const&, unsigned long)
Line
Count
Source
388
125M
                       size_t offset = 0) {
389
125M
  size_t store_size = sizeof(value) - offset;
390
125M
  if (buffer_ptr + store_size > buffer_end)
391
354k
    return false;
392
124M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
124M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
124M
  buffer_ptr += store_size;
395
124M
  return true;
396
124M
}
bool llvm::hashing::detail::store_and_advance<llvm::Constant*>(char*&, char*, llvm::Constant* const&, unsigned long)
Line
Count
Source
388
461
                       size_t offset = 0) {
389
461
  size_t store_size = sizeof(value) - offset;
390
461
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
461
  const char *value_data = reinterpret_cast<const char *>(&value);
393
461
  memcpy(buffer_ptr, value_data + offset, store_size);
394
461
  buffer_ptr += store_size;
395
461
  return true;
396
461
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction*>(char*&, char*, llvm::Instruction* const&, unsigned long)
Line
Count
Source
388
264
                       size_t offset = 0) {
389
264
  size_t store_size = sizeof(value) - offset;
390
264
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
264
  const char *value_data = reinterpret_cast<const char *>(&value);
393
264
  memcpy(buffer_ptr, value_data + offset, store_size);
394
264
  buffer_ptr += store_size;
395
264
  return true;
396
264
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol const*>(char*&, char*, llvm::MCSymbol const* const&, unsigned long)
Line
Count
Source
388
31.8k
                       size_t offset = 0) {
389
31.8k
  size_t store_size = sizeof(value) - offset;
390
31.8k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
31.8k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
31.8k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
31.8k
  buffer_ptr += store_size;
395
31.8k
  return true;
396
31.8k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::BinaryOps>(char*&, char*, llvm::Instruction::BinaryOps const&, unsigned long)
Line
Count
Source
388
7.25M
                       size_t offset = 0) {
389
7.25M
  size_t store_size = sizeof(value) - offset;
390
7.25M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
7.25M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
7.25M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
7.25M
  buffer_ptr += store_size;
395
7.25M
  return true;
396
7.25M
}
bool llvm::hashing::detail::store_and_advance<llvm::CmpInst::Predicate>(char*&, char*, llvm::CmpInst::Predicate const&, unsigned long)
Line
Count
Source
388
12.4M
                       size_t offset = 0) {
389
12.4M
  size_t store_size = sizeof(value) - offset;
390
12.4M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
12.4M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
12.4M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
12.4M
  buffer_ptr += store_size;
395
12.4M
  return true;
396
12.4M
}
bool llvm::hashing::detail::store_and_advance<llvm::SelectPatternFlavor>(char*&, char*, llvm::SelectPatternFlavor const&, unsigned long)
Line
Count
Source
388
224k
                       size_t offset = 0) {
389
224k
  size_t store_size = sizeof(value) - offset;
390
224k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
224k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
224k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
224k
  buffer_ptr += store_size;
395
224k
  return true;
396
224k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::CastOps>(char*&, char*, llvm::Instruction::CastOps const&, unsigned long)
Line
Count
Source
388
7.90M
                       size_t offset = 0) {
389
7.90M
  size_t store_size = sizeof(value) - offset;
390
7.90M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
7.90M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
7.90M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
7.90M
  buffer_ptr += store_size;
395
7.90M
  return true;
396
7.90M
}
bool llvm::hashing::detail::store_and_advance<short>(char*&, char*, short const&, unsigned long)
Line
Count
Source
388
991k
                       size_t offset = 0) {
389
991k
  size_t store_size = sizeof(value) - offset;
390
991k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
991k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
991k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
991k
  buffer_ptr += store_size;
395
991k
  return true;
396
991k
}
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::fltSemantics const*>(char*&, char*, llvm::fltSemantics const* const&, unsigned long)
bool llvm::hashing::detail::store_and_advance<llvm::Value const*>(char*&, char*, llvm::Value const* const&, unsigned long)
Line
Count
Source
388
679k
                       size_t offset = 0) {
389
679k
  size_t store_size = sizeof(value) - offset;
390
679k
  if (buffer_ptr + store_size > buffer_end)
391
90
    return false;
392
679k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
679k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
679k
  buffer_ptr += store_size;
395
679k
  return true;
396
679k
}
bool llvm::hashing::detail::store_and_advance<void*>(char*&, char*, void* const&, unsigned long)
Line
Count
Source
388
33.9k
                       size_t offset = 0) {
389
33.9k
  size_t store_size = sizeof(value) - offset;
390
33.9k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
33.9k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
33.9k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
33.9k
  buffer_ptr += store_size;
395
33.9k
  return true;
396
33.9k
}
bool llvm::hashing::detail::store_and_advance<clang::NestedNameSpecifier*>(char*&, char*, clang::NestedNameSpecifier* const&, unsigned long)
Line
Count
Source
388
782
                       size_t offset = 0) {
389
782
  size_t store_size = sizeof(value) - offset;
390
782
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
782
  const char *value_data = reinterpret_cast<const char *>(&value);
393
782
  memcpy(buffer_ptr, value_data + offset, store_size);
394
782
  buffer_ptr += store_size;
395
782
  return true;
396
782
}
bool llvm::hashing::detail::store_and_advance<llvm::RegisterBankInfo::ValueMapping const*>(char*&, char*, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned long)
Line
Count
Source
388
14.1M
                       size_t offset = 0) {
389
14.1M
  size_t store_size = sizeof(value) - offset;
390
14.1M
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
14.1M
  const char *value_data = reinterpret_cast<const char *>(&value);
393
14.1M
  memcpy(buffer_ptr, value_data + offset, store_size);
394
14.1M
  buffer_ptr += store_size;
395
14.1M
  return true;
396
14.1M
}
bool llvm::hashing::detail::store_and_advance<long>(char*&, char*, long const&, unsigned long)
Line
Count
Source
388
61.7k
                       size_t offset = 0) {
389
61.7k
  size_t store_size = sizeof(value) - offset;
390
61.7k
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
61.7k
  const char *value_data = reinterpret_cast<const char *>(&value);
393
61.7k
  memcpy(buffer_ptr, value_data + offset, store_size);
394
61.7k
  buffer_ptr += store_size;
395
61.7k
  return true;
396
61.7k
}
bool llvm::hashing::detail::store_and_advance<clang::IdentifierInfo const*>(char*&, char*, clang::IdentifierInfo const* const&, unsigned long)
Line
Count
Source
388
1
                       size_t offset = 0) {
389
1
  size_t store_size = sizeof(value) - offset;
390
1
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
1
  const char *value_data = reinterpret_cast<const char *>(&value);
393
1
  memcpy(buffer_ptr, value_data + offset, store_size);
394
1
  buffer_ptr += store_size;
395
1
  return true;
396
1
}
bool llvm::hashing::detail::store_and_advance<lld::DefinedAtom::ContentType>(char*&, char*, lld::DefinedAtom::ContentType const&, unsigned long)
Line
Count
Source
388
54
                       size_t offset = 0) {
389
54
  size_t store_size = sizeof(value) - offset;
390
54
  if (buffer_ptr + store_size > buffer_end)
391
0
    return false;
392
54
  const char *value_data = reinterpret_cast<const char *>(&value);
393
54
  memcpy(buffer_ptr, value_data + offset, store_size);
394
54
  buffer_ptr += store_size;
395
54
  return true;
396
54
}
397
398
/// Implement the combining of integral values into a hash_code.
399
///
400
/// This overload is selected when the value type of the iterator is
401
/// integral. Rather than computing a hash_code for each object and then
402
/// combining them, this (as an optimization) directly combines the integers.
403
template <typename InputIteratorT>
404
25.3M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
25.3M
  const size_t seed = get_execution_seed();
406
25.3M
  char buffer[64], *buffer_ptr = buffer;
407
25.3M
  char *const buffer_end = std::end(buffer);
408
100M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
75.8M
                                            get_hashable_data(*first)))
410
75.5M
    ++first;
411
25.3M
  if (first == last)
412
25.1M
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
209k
  assert(buffer_ptr == buffer_end);
414
209k
415
209k
  hash_state state = state.create(buffer, seed);
416
209k
  size_t length = 64;
417
4.65M
  while (first != last) {
418
4.44M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
4.44M
    // when only a partial 64-byte chunk is left.
420
4.44M
    buffer_ptr = buffer;
421
39.1M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
38.9M
                                              get_hashable_data(*first)))
423
34.6M
      ++first;
424
4.44M
425
4.44M
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
4.44M
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
4.44M
    // have a contiguous byte sequence, and we want to emulate that here.
428
4.44M
    std::rotate(buffer, buffer_ptr, buffer_end);
429
4.44M
430
4.44M
    // Mix this chunk into the current state.
431
4.44M
    state.mix(buffer);
432
4.44M
    length += buffer_ptr - buffer;
433
4.44M
  };
434
209k
435
209k
  return state.finalize(length);
436
209k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
404
17.5k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
17.5k
  const size_t seed = get_execution_seed();
406
17.5k
  char buffer[64], *buffer_ptr = buffer;
407
17.5k
  char *const buffer_end = std::end(buffer);
408
113k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
104k
                                            get_hashable_data(*first)))
410
95.8k
    ++first;
411
17.5k
  if (first == last)
412
9.17k
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
8.35k
  assert(buffer_ptr == buffer_end);
414
8.35k
415
8.35k
  hash_state state = state.create(buffer, seed);
416
8.35k
  size_t length = 64;
417
4.09M
  while (first != last) {
418
4.08M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
4.08M
    // when only a partial 64-byte chunk is left.
420
4.08M
    buffer_ptr = buffer;
421
36.7M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
36.7M
                                              get_hashable_data(*first)))
423
32.6M
      ++first;
424
4.08M
425
4.08M
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
4.08M
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
4.08M
    // have a contiguous byte sequence, and we want to emulate that here.
428
4.08M
    std::rotate(buffer, buffer_ptr, buffer_end);
429
4.08M
430
4.08M
    // Mix this chunk into the current state.
431
4.08M
    state.mix(buffer);
432
4.08M
    length += buffer_ptr - buffer;
433
4.08M
  };
434
8.35k
435
8.35k
  return state.finalize(length);
436
8.35k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>)
Line
Count
Source
404
20.1k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
20.1k
  const size_t seed = get_execution_seed();
406
20.1k
  char buffer[64], *buffer_ptr = buffer;
407
20.1k
  char *const buffer_end = std::end(buffer);
408
366k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
350k
                                            get_hashable_data(*first)))
410
346k
    ++first;
411
20.1k
  if (first == last)
412
16.4k
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
3.66k
  assert(buffer_ptr == buffer_end);
414
3.66k
415
3.66k
  hash_state state = state.create(buffer, seed);
416
3.66k
  size_t length = 64;
417
7.46k
  while (first != last) {
418
3.80k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
3.80k
    // when only a partial 64-byte chunk is left.
420
3.80k
    buffer_ptr = buffer;
421
137k
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
133k
                                              get_hashable_data(*first)))
423
133k
      ++first;
424
3.80k
425
3.80k
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
3.80k
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
3.80k
    // have a contiguous byte sequence, and we want to emulate that here.
428
3.80k
    std::rotate(buffer, buffer_ptr, buffer_end);
429
3.80k
430
3.80k
    // Mix this chunk into the current state.
431
3.80k
    state.mix(buffer);
432
3.80k
    length += buffer_ptr - buffer;
433
3.80k
  };
434
3.66k
435
3.66k
  return state.finalize(length);
436
3.66k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::User::value_op_iterator>(llvm::User::value_op_iterator, llvm::User::value_op_iterator)
Line
Count
Source
404
25.0M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
25.0M
  const size_t seed = get_execution_seed();
406
25.0M
  char buffer[64], *buffer_ptr = buffer;
407
25.0M
  char *const buffer_end = std::end(buffer);
408
99.4M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
74.6M
                                            get_hashable_data(*first)))
410
74.4M
    ++first;
411
25.0M
  if (first == last)
412
24.8M
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
197k
  assert(buffer_ptr == buffer_end);
414
197k
415
197k
  hash_state state = state.create(buffer, seed);
416
197k
  size_t length = 64;
417
552k
  while (first != last) {
418
354k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
354k
    // when only a partial 64-byte chunk is left.
420
354k
    buffer_ptr = buffer;
421
2.21M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
2.01M
                                              get_hashable_data(*first)))
423
1.86M
      ++first;
424
354k
425
354k
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
354k
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
354k
    // have a contiguous byte sequence, and we want to emulate that here.
428
354k
    std::rotate(buffer, buffer_ptr, buffer_end);
429
354k
430
354k
    // Mix this chunk into the current state.
431
354k
    state.mix(buffer);
432
354k
    length += buffer_ptr - buffer;
433
354k
  };
434
197k
435
197k
  return state.finalize(length);
436
197k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::User::const_value_op_iterator>(llvm::User::const_value_op_iterator, llvm::User::const_value_op_iterator)
Line
Count
Source
404
265k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
265k
  const size_t seed = get_execution_seed();
406
265k
  char buffer[64], *buffer_ptr = buffer;
407
265k
  char *const buffer_end = std::end(buffer);
408
944k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
679k
                                            get_hashable_data(*first)))
410
679k
    ++first;
411
265k
  if (first == last)
412
265k
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
90
  assert(buffer_ptr == buffer_end);
414
90
415
90
  hash_state state = state.create(buffer, seed);
416
90
  size_t length = 64;
417
180
  while (first != last) {
418
90
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
90
    // when only a partial 64-byte chunk is left.
420
90
    buffer_ptr = buffer;
421
180
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
90
                                              get_hashable_data(*first)))
423
90
      ++first;
424
90
425
90
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
90
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
90
    // have a contiguous byte sequence, and we want to emulate that here.
428
90
    std::rotate(buffer, buffer_ptr, buffer_end);
429
90
430
90
    // Mix this chunk into the current state.
431
90
    state.mix(buffer);
432
90
    length += buffer_ptr - buffer;
433
90
  };
434
90
435
90
  return state.finalize(length);
436
90
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
404
504
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
504
  const size_t seed = get_execution_seed();
406
504
  char buffer[64], *buffer_ptr = buffer;
407
504
  char *const buffer_end = std::end(buffer);
408
1.07k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
568
                                            get_hashable_data(*first)))
410
568
    ++first;
411
504
  if (first == last)
412
504
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
0
  assert(buffer_ptr == buffer_end);
414
0
415
0
  hash_state state = state.create(buffer, seed);
416
0
  size_t length = 64;
417
0
  while (first != last) {
418
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
0
    // when only a partial 64-byte chunk is left.
420
0
    buffer_ptr = buffer;
421
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
0
                                              get_hashable_data(*first)))
423
0
      ++first;
424
0
425
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
0
    // have a contiguous byte sequence, and we want to emulate that here.
428
0
    std::rotate(buffer, buffer_ptr, buffer_end);
429
0
430
0
    // Mix this chunk into the current state.
431
0
    state.mix(buffer);
432
0
    length += buffer_ptr - buffer;
433
0
  };
434
0
435
0
  return state.finalize(length);
436
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
404
1
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
405
1
  const size_t seed = get_execution_seed();
406
1
  char buffer[64], *buffer_ptr = buffer;
407
1
  char *const buffer_end = std::end(buffer);
408
2
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
409
1
                                            get_hashable_data(*first)))
410
1
    ++first;
411
1
  if (first == last)
412
1
    return hash_short(buffer, buffer_ptr - buffer, seed);
413
0
  assert(buffer_ptr == buffer_end);
414
0
415
0
  hash_state state = state.create(buffer, seed);
416
0
  size_t length = 64;
417
0
  while (first != last) {
418
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
419
0
    // when only a partial 64-byte chunk is left.
420
0
    buffer_ptr = buffer;
421
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
422
0
                                              get_hashable_data(*first)))
423
0
      ++first;
424
0
425
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
426
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
427
0
    // have a contiguous byte sequence, and we want to emulate that here.
428
0
    std::rotate(buffer, buffer_ptr, buffer_end);
429
0
430
0
    // Mix this chunk into the current state.
431
0
    state.mix(buffer);
432
0
    length += buffer_ptr - buffer;
433
0
  };
434
0
435
0
  return state.finalize(length);
436
0
}
437
438
/// Implement the combining of integral values into a hash_code.
439
///
440
/// This overload is selected when the value type of the iterator is integral
441
/// and when the input iterator is actually a pointer. Rather than computing
442
/// a hash_code for each object and then combining them, this (as an
443
/// optimization) directly combines the integers. Also, because the integers
444
/// are stored in contiguous memory, this routine avoids copying each value
445
/// and directly reads from the underlying memory.
446
template <typename ValueT>
447
typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type
448
671M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
671M
  const size_t seed = get_execution_seed();
450
671M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
671M
  const char *s_end = reinterpret_cast<const char *>(last);
452
671M
  const size_t length = std::distance(s_begin, s_end);
453
671M
  if (length <= 64)
454
647M
    return hash_short(s_begin, length, seed);
455
23.3M
456
23.3M
  const char *s_aligned_end = s_begin + (length & ~63);
457
23.3M
  hash_state state = state.create(s_begin, seed);
458
23.3M
  s_begin += 64;
459
44.3M
  while (s_begin != s_aligned_end) {
460
20.9M
    state.mix(s_begin);
461
20.9M
    s_begin += 64;
462
20.9M
  }
463
23.3M
  if (length & 63)
464
22.8M
    state.mix(s_end - 64);
465
23.3M
466
23.3M
  return state.finalize(length);
467
23.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
448
2.02k
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
2.02k
  const size_t seed = get_execution_seed();
450
2.02k
  const char *s_begin = reinterpret_cast<const char *>(first);
451
2.02k
  const char *s_end = reinterpret_cast<const char *>(last);
452
2.02k
  const size_t length = std::distance(s_begin, s_end);
453
2.02k
  if (length <= 64)
454
192
    return hash_short(s_begin, length, seed);
455
1.83k
456
1.83k
  const char *s_aligned_end = s_begin + (length & ~63);
457
1.83k
  hash_state state = state.create(s_begin, seed);
458
1.83k
  s_begin += 64;
459
29.0k
  while (s_begin != s_aligned_end) {
460
27.2k
    state.mix(s_begin);
461
27.2k
    s_begin += 64;
462
27.2k
  }
463
1.83k
  if (length & 63)
464
1.51k
    state.mix(s_end - 64);
465
1.83k
466
1.83k
  return state.finalize(length);
467
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
448
23.5M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
23.5M
  const size_t seed = get_execution_seed();
450
23.5M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
23.5M
  const char *s_end = reinterpret_cast<const char *>(last);
452
23.5M
  const size_t length = std::distance(s_begin, s_end);
453
23.5M
  if (length <= 64)
454
22.7M
    return hash_short(s_begin, length, seed);
455
823k
456
823k
  const char *s_aligned_end = s_begin + (length & ~63);
457
823k
  hash_state state = state.create(s_begin, seed);
458
823k
  s_begin += 64;
459
984k
  while (s_begin != s_aligned_end) {
460
161k
    state.mix(s_begin);
461
161k
    s_begin += 64;
462
161k
  }
463
823k
  if (length & 63)
464
823k
    state.mix(s_end - 64);
465
823k
466
823k
  return state.finalize(length);
467
823k
}
std::__1::enable_if<is_hashable_data<llvm::Constant* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Constant* const>(llvm::Constant* const*, llvm::Constant* const*)
Line
Count
Source
448
17.4M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
17.4M
  const size_t seed = get_execution_seed();
450
17.4M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
17.4M
  const char *s_end = reinterpret_cast<const char *>(last);
452
17.4M
  const size_t length = std::distance(s_begin, s_end);
453
17.4M
  if (length <= 64)
454
17.3M
    return hash_short(s_begin, length, seed);
455
46.4k
456
46.4k
  const char *s_aligned_end = s_begin + (length & ~63);
457
46.4k
  hash_state state = state.create(s_begin, seed);
458
46.4k
  s_begin += 64;
459
123k
  while (s_begin != s_aligned_end) {
460
76.9k
    state.mix(s_begin);
461
76.9k
    s_begin += 64;
462
76.9k
  }
463
46.4k
  if (length & 63)
464
20.5k
    state.mix(s_end - 64);
465
46.4k
466
46.4k
  return state.finalize(length);
467
46.4k
}
std::__1::enable_if<is_hashable_data<unsigned int const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned int const>(unsigned int const*, unsigned int const*)
Line
Count
Source
448
576M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
576M
  const size_t seed = get_execution_seed();
450
576M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
576M
  const char *s_end = reinterpret_cast<const char *>(last);
452
576M
  const size_t length = std::distance(s_begin, s_end);
453
576M
  if (length <= 64)
454
554M
    return hash_short(s_begin, length, seed);
455
22.1M
456
22.1M
  const char *s_aligned_end = s_begin + (length & ~63);
457
22.1M
  hash_state state = state.create(s_begin, seed);
458
22.1M
  s_begin += 64;
459
41.7M
  while (s_begin != s_aligned_end) {
460
19.6M
    state.mix(s_begin);
461
19.6M
    s_begin += 64;
462
19.6M
  }
463
22.1M
  if (length & 63)
464
21.6M
    state.mix(s_end - 64);
465
22.1M
466
22.1M
  return state.finalize(length);
467
22.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
448
7.27M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
7.27M
  const size_t seed = get_execution_seed();
450
7.27M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
7.27M
  const char *s_end = reinterpret_cast<const char *>(last);
452
7.27M
  const size_t length = std::distance(s_begin, s_end);
453
7.27M
  if (length <= 64)
454
7.23M
    return hash_short(s_begin, length, seed);
455
40.8k
456
40.8k
  const char *s_aligned_end = s_begin + (length & ~63);
457
40.8k
  hash_state state = state.create(s_begin, seed);
458
40.8k
  s_begin += 64;
459
59.8k
  while (s_begin != s_aligned_end) {
460
19.0k
    state.mix(s_begin);
461
19.0k
    s_begin += 64;
462
19.0k
  }
463
40.8k
  if (length & 63)
464
40.2k
    state.mix(s_end - 64);
465
40.8k
466
40.8k
  return state.finalize(length);
467
40.8k
}
std::__1::enable_if<is_hashable_data<unsigned long long const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned long long const>(unsigned long long const*, unsigned long long const*)
Line
Count
Source
448
1.00M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
1.00M
  const size_t seed = get_execution_seed();
450
1.00M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
1.00M
  const char *s_end = reinterpret_cast<const char *>(last);
452
1.00M
  const size_t length = std::distance(s_begin, s_end);
453
1.00M
  if (length <= 64)
454
1.00M
    return hash_short(s_begin, length, seed);
455
39
456
39
  const char *s_aligned_end = s_begin + (length & ~63);
457
39
  hash_state state = state.create(s_begin, seed);
458
39
  s_begin += 64;
459
45
  while (s_begin != s_aligned_end) {
460
6
    state.mix(s_begin);
461
6
    s_begin += 64;
462
6
  }
463
39
  if (length & 63)
464
38
    state.mix(s_end - 64);
465
39
466
39
  return state.finalize(length);
467
39
}
std::__1::enable_if<is_hashable_data<llvm::Metadata* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Metadata* const>(llvm::Metadata* const*, llvm::Metadata* const*)
Line
Count
Source
448
1.38M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
1.38M
  const size_t seed = get_execution_seed();
450
1.38M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
1.38M
  const char *s_end = reinterpret_cast<const char *>(last);
452
1.38M
  const size_t length = std::distance(s_begin, s_end);
453
1.38M
  if (length <= 64)
454
1.34M
    return hash_short(s_begin, length, seed);
455
37.7k
456
37.7k
  const char *s_aligned_end = s_begin + (length & ~63);
457
37.7k
  hash_state state = state.create(s_begin, seed);
458
37.7k
  s_begin += 64;
459
105k
  while (s_begin != s_aligned_end) {
460
67.4k
    state.mix(s_begin);
461
67.4k
    s_begin += 64;
462
67.4k
  }
463
37.7k
  if (length & 63)
464
37.3k
    state.mix(s_end - 64);
465
37.7k
466
37.7k
  return state.finalize(length);
467
37.7k
}
std::__1::enable_if<is_hashable_data<llvm::Value* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Value* const>(llvm::Value* const*, llvm::Value* const*)
Line
Count
Source
448
2.47k
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
2.47k
  const size_t seed = get_execution_seed();
450
2.47k
  const char *s_begin = reinterpret_cast<const char *>(first);
451
2.47k
  const char *s_end = reinterpret_cast<const char *>(last);
452
2.47k
  const size_t length = std::distance(s_begin, s_end);
453
2.47k
  if (length <= 64)
454
2.47k
    return hash_short(s_begin, length, seed);
455
0
456
0
  const char *s_aligned_end = s_begin + (length & ~63);
457
0
  hash_state state = state.create(s_begin, seed);
458
0
  s_begin += 64;
459
0
  while (s_begin != s_aligned_end) {
460
0
    state.mix(s_begin);
461
0
    s_begin += 64;
462
0
  }
463
0
  if (length & 63)
464
0
    state.mix(s_end - 64);
465
0
466
0
  return state.finalize(length);
467
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
448
17.8M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
17.8M
  const size_t seed = get_execution_seed();
450
17.8M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
17.8M
  const char *s_end = reinterpret_cast<const char *>(last);
452
17.8M
  const size_t length = std::distance(s_begin, s_end);
453
17.8M
  if (length <= 64)
454
17.8M
    return hash_short(s_begin, length, seed);
455
0
456
0
  const char *s_aligned_end = s_begin + (length & ~63);
457
0
  hash_state state = state.create(s_begin, seed);
458
0
  s_begin += 64;
459
0
  while (s_begin != s_aligned_end) {
460
0
    state.mix(s_begin);
461
0
    s_begin += 64;
462
0
  }
463
0
  if (length & 63)
464
0
    state.mix(s_end - 64);
465
0
466
0
  return state.finalize(length);
467
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
448
3.95M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
3.95M
  const size_t seed = get_execution_seed();
450
3.95M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
3.95M
  const char *s_end = reinterpret_cast<const char *>(last);
452
3.95M
  const size_t length = std::distance(s_begin, s_end);
453
3.95M
  if (length <= 64)
454
3.95M
    return hash_short(s_begin, length, seed);
455
644
456
644
  const char *s_aligned_end = s_begin + (length & ~63);
457
644
  hash_state state = state.create(s_begin, seed);
458
644
  s_begin += 64;
459
73.6k
  while (s_begin != s_aligned_end) {
460
73.0k
    state.mix(s_begin);
461
73.0k
    s_begin += 64;
462
73.0k
  }
463
644
  if (length & 63)
464
109
    state.mix(s_end - 64);
465
644
466
644
  return state.finalize(length);
467
644
}
std::__1::enable_if<is_hashable_data<char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<char const>(char const*, char const*)
Line
Count
Source
448
6.51M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
6.51M
  const size_t seed = get_execution_seed();
450
6.51M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
6.51M
  const char *s_end = reinterpret_cast<const char *>(last);
452
6.51M
  const size_t length = std::distance(s_begin, s_end);
453
6.51M
  if (length <= 64)
454
6.41M
    return hash_short(s_begin, length, seed);
455
102k
456
102k
  const char *s_aligned_end = s_begin + (length & ~63);
457
102k
  hash_state state = state.create(s_begin, seed);
458
102k
  s_begin += 64;
459
875k
  while (s_begin != s_aligned_end) {
460
773k
    state.mix(s_begin);
461
773k
    s_begin += 64;
462
773k
  }
463
102k
  if (length & 63)
464
101k
    state.mix(s_end - 64);
465
102k
466
102k
  return state.finalize(length);
467
102k
}
std::__1::enable_if<is_hashable_data<llvm::BasicBlock*>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::BasicBlock*>(llvm::BasicBlock**, llvm::BasicBlock**)
Line
Count
Source
448
7.98M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
7.98M
  const size_t seed = get_execution_seed();
450
7.98M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
7.98M
  const char *s_end = reinterpret_cast<const char *>(last);
452
7.98M
  const size_t length = std::distance(s_begin, s_end);
453
7.98M
  if (length <= 64)
454
7.81M
    return hash_short(s_begin, length, seed);
455
170k
456
170k
  const char *s_aligned_end = s_begin + (length & ~63);
457
170k
  hash_state state = state.create(s_begin, seed);
458
170k
  s_begin += 64;
459
330k
  while (s_begin != s_aligned_end) {
460
160k
    state.mix(s_begin);
461
160k
    s_begin += 64;
462
160k
  }
463
170k
  if (length & 63)
464
165k
    state.mix(s_end - 64);
465
170k
466
170k
  return state.finalize(length);
467
170k
}
std::__1::enable_if<is_hashable_data<llvm::RegisterBankInfo::ValueMapping const* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::RegisterBankInfo::ValueMapping const* const>(llvm::RegisterBankInfo::ValueMapping const* const*, llvm::RegisterBankInfo::ValueMapping const* const*)
Line
Count
Source
448
7.65M
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
7.65M
  const size_t seed = get_execution_seed();
450
7.65M
  const char *s_begin = reinterpret_cast<const char *>(first);
451
7.65M
  const char *s_end = reinterpret_cast<const char *>(last);
452
7.65M
  const size_t length = std::distance(s_begin, s_end);
453
7.65M
  if (length <= 64)
454
7.65M
    return hash_short(s_begin, length, seed);
455
480
456
480
  const char *s_aligned_end = s_begin + (length & ~63);
457
480
  hash_state state = state.create(s_begin, seed);
458
480
  s_begin += 64;
459
629
  while (s_begin != s_aligned_end) {
460
149
    state.mix(s_begin);
461
149
    s_begin += 64;
462
149
  }
463
480
  if (length & 63)
464
480
    state.mix(s_end - 64);
465
480
466
480
  return state.finalize(length);
467
480
}
std::__1::enable_if<is_hashable_data<unsigned char const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned char const>(unsigned char const*, unsigned char const*)
Line
Count
Source
448
4.01k
hash_combine_range_impl(ValueT *first, ValueT *last) {
449
4.01k
  const size_t seed = get_execution_seed();
450
4.01k
  const char *s_begin = reinterpret_cast<const char *>(first);
451
4.01k
  const char *s_end = reinterpret_cast<const char *>(last);
452
4.01k
  const size_t length = std::distance(s_begin, s_end);
453
4.01k
  if (length <= 64)
454
3.69k
    return hash_short(s_begin, length, seed);
455
317
456
317
  const char *s_aligned_end = s_begin + (length & ~63);
457
317
  hash_state state = state.create(s_begin, seed);
458
317
  s_begin += 64;
459
594
  while (s_begin != s_aligned_end) {
460
277
    state.mix(s_begin);
461
277
    s_begin += 64;
462
277
  }
463
317
  if (length & 63)
464
282
    state.mix(s_end - 64);
465
317
466
317
  return state.finalize(length);
467
317
}
468
469
} // namespace detail
470
} // namespace hashing
471
472
473
/// Compute a hash_code for a sequence of values.
474
///
475
/// This hashes a sequence of values. It produces the same hash_code as
476
/// 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences
477
/// and is significantly faster given pointers and types which can be hashed as
478
/// a sequence of bytes.
479
template <typename InputIteratorT>
480
696M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
696M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
696M
}
llvm::hash_code llvm::hash_combine_range<unsigned int*>(unsigned int*, unsigned int*)
Line
Count
Source
480
2.02k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
2.02k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
2.02k
}
llvm::hash_code llvm::hash_combine_range<unsigned long*>(unsigned long*, unsigned long*)
Line
Count
Source
480
23.5M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
23.5M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
23.5M
}
llvm::hash_code llvm::hash_combine_range<llvm::Constant* const*>(llvm::Constant* const*, llvm::Constant* const*)
Line
Count
Source
480
17.4M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
17.4M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
17.4M
}
llvm::hash_code llvm::hash_combine_range<unsigned int const*>(unsigned int const*, unsigned int const*)
Line
Count
Source
480
576M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
576M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
576M
}
llvm::hash_code llvm::hash_combine_range<llvm::Type* const*>(llvm::Type* const*, llvm::Type* const*)
Line
Count
Source
480
7.27M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
7.27M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
7.27M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long const*>(unsigned long long const*, unsigned long long const*)
Line
Count
Source
480
1.00M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
1.00M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
1.00M
}
llvm::hash_code llvm::hash_combine_range<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
480
17.5k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
17.5k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
17.5k
}
llvm::hash_code llvm::hash_combine_range<llvm::Metadata* const*>(llvm::Metadata* const*, llvm::Metadata* const*)
Line
Count
Source
480
1.38M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
1.38M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
1.38M
}
llvm::hash_code llvm::hash_combine_range<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>)
Line
Count
Source
480
20.1k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
20.1k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
20.1k
}
llvm::hash_code llvm::hash_combine_range<llvm::Value* const*>(llvm::Value* const*, llvm::Value* const*)
Line
Count
Source
480
2.47k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
2.47k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
2.47k
}
llvm::hash_code llvm::hash_combine_range<llvm::User::value_op_iterator>(llvm::User::value_op_iterator, llvm::User::value_op_iterator)
Line
Count
Source
480
25.0M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
25.0M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
25.0M
}
llvm::hash_code llvm::hash_combine_range<llvm::SCEV const* const*>(llvm::SCEV const* const*, llvm::SCEV const* const*)
Line
Count
Source
480
17.8M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
17.8M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
17.8M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long*>(unsigned long long*, unsigned long long*)
Line
Count
Source
480
3.95M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
3.95M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
3.95M
}
llvm::hash_code llvm::hash_combine_range<char const*>(char const*, char const*)
Line
Count
Source
480
6.51M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
6.51M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
6.51M
}
llvm::hash_code llvm::hash_combine_range<llvm::BasicBlock**>(llvm::BasicBlock**, llvm::BasicBlock**)
Line
Count
Source
480
7.98M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
7.98M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
7.98M
}
llvm::hash_code llvm::hash_combine_range<llvm::User::const_value_op_iterator>(llvm::User::const_value_op_iterator, llvm::User::const_value_op_iterator)
Line
Count
Source
480
265k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
265k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
265k
}
llvm::hash_code llvm::hash_combine_range<llvm::RegisterBankInfo::ValueMapping const* const*>(llvm::RegisterBankInfo::ValueMapping const* const*, llvm::RegisterBankInfo::ValueMapping const* const*)
Line
Count
Source
480
7.65M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
7.65M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
7.65M
}
llvm::hash_code llvm::hash_combine_range<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
480
504
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
504
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
504
}
ItaniumCXXABI.cpp:llvm::hash_code llvm::hash_combine_range<(anonymous namespace)::DecompositionDeclName::Iterator>((anonymous namespace)::DecompositionDeclName::Iterator, (anonymous namespace)::DecompositionDeclName::Iterator)
Line
Count
Source
480
1
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
1
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
1
}
llvm::hash_code llvm::hash_combine_range<unsigned char const*>(unsigned char const*, unsigned char const*)
Line
Count
Source
480
4.02k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
481
4.02k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
482
4.02k
}
483
484
485
// Implementation details for hash_combine.
486
namespace hashing {
487
namespace detail {
488
489
/// Helper class to manage the recursive combining of hash_combine
490
/// arguments.
491
///
492
/// This class exists to manage the state and various calls involved in the
493
/// recursive combining of arguments used in hash_combine. It is particularly
494
/// useful at minimizing the code in the recursive calls to ease the pain
495
/// caused by a lack of variadic functions.
496
struct hash_combine_recursive_helper {
497
  char buffer[64];
498
  hash_state state;
499
  const size_t seed;
500
501
public:
502
  /// Construct a recursive hash combining helper.
503
  ///
504
  /// This sets up the state for a recursive hash combine, including getting
505
  /// the seed and buffer setup.
506
  hash_combine_recursive_helper()
507
448M
    : seed(get_execution_seed()) {}
508
509
  /// Combine one chunk of data into the current in-flight hash.
510
  ///
511
  /// This merges one chunk of data into the hash. First it tries to buffer
512
  /// the data. If the buffer is full, it hashes the buffer into its
513
  /// hash_state, empties it, and then merges the new chunk in. This also
514
  /// handles cases where the data straddles the end of the buffer.
515
  template <typename T>
516
978M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
978M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
6
      // Check for skew which prevents the buffer from being packed, and do
519
6
      // a partial store into the buffer to fill it. This is only a concern
520
6
      // with the variadic combine because that formation can have varying
521
6
      // argument types.
522
6
      size_t partial_store_size = buffer_end - buffer_ptr;
523
6
      memcpy(buffer_ptr, &data, partial_store_size);
524
6
525
6
      // If the store fails, our buffer is full and ready to hash. We have to
526
6
      // either initialize the hash state (on the first full buffer) or mix
527
6
      // this buffer into the existing hash state. Length tracks the *hashed*
528
6
      // length, not the buffered length.
529
6
      if (length == 0) {
530
6
        state = state.create(buffer, seed);
531
6
        length = 64;
532
6
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
6
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
6
      // data.
539
6
      buffer_ptr = buffer;
540
6
541
6
      // Try again to store into the buffer -- this cannot fail as we only
542
6
      // store types smaller than the buffer.
543
6
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
6
                             partial_store_size))
545
0
        abort();
546
978M
    }
547
978M
    return buffer_ptr;
548
978M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int>(unsigned long&, char*, char*, unsigned int)
Line
Count
Source
516
266M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
266M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
266M
    }
547
266M
    return buffer_ptr;
548
266M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long>(unsigned long&, char*, char*, unsigned long)
Line
Count
Source
516
98.9M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
98.9M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
98.9M
    }
547
98.9M
    return buffer_ptr;
548
98.9M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::coverage::CounterExpression::ExprKind>(unsigned long&, char*, char*, llvm::coverage::CounterExpression::ExprKind)
Line
Count
Source
516
1.74k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
1.74k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
1.74k
    }
547
1.74k
    return buffer_ptr;
548
1.74k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::coverage::Counter::CounterKind>(unsigned long&, char*, char*, llvm::coverage::Counter::CounterKind)
Line
Count
Source
516
3.48k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
3.48k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
3.48k
    }
547
3.48k
    return buffer_ptr;
548
3.48k
  }
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
516
262
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
262
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
262
    }
547
262
    return buffer_ptr;
548
262
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<bool>(unsigned long&, char*, char*, bool)
Line
Count
Source
516
52.9M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
52.9M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
52.9M
    }
547
52.9M
    return buffer_ptr;
548
52.9M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<int>(unsigned long&, char*, char*, int)
Line
Count
Source
516
1.04M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
1.04M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
4
      // Check for skew which prevents the buffer from being packed, and do
519
4
      // a partial store into the buffer to fill it. This is only a concern
520
4
      // with the variadic combine because that formation can have varying
521
4
      // argument types.
522
4
      size_t partial_store_size = buffer_end - buffer_ptr;
523
4
      memcpy(buffer_ptr, &data, partial_store_size);
524
4
525
4
      // If the store fails, our buffer is full and ready to hash. We have to
526
4
      // either initialize the hash state (on the first full buffer) or mix
527
4
      // this buffer into the existing hash state. Length tracks the *hashed*
528
4
      // length, not the buffered length.
529
4
      if (length == 0) {
530
4
        state = state.create(buffer, seed);
531
4
        length = 64;
532
4
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
4
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
4
      // data.
539
4
      buffer_ptr = buffer;
540
4
541
4
      // Try again to store into the buffer -- this cannot fail as we only
542
4
      // store types smaller than the buffer.
543
4
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
4
                             partial_store_size))
545
0
        abort();
546
1.04M
    }
547
1.04M
    return buffer_ptr;
548
1.04M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<char const*>(unsigned long&, char*, char*, char const*)
Line
Count
Source
516
5.93k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
5.93k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
5.93k
    }
547
5.93k
    return buffer_ptr;
548
5.93k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::GlobalValue const*>(unsigned long&, char*, char*, llvm::GlobalValue const*)
Line
Count
Source
516
3.87M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
3.87M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
3.87M
    }
547
3.87M
    return buffer_ptr;
548
3.87M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BlockAddress const*>(unsigned long&, char*, char*, llvm::BlockAddress const*)
Line
Count
Source
516
382
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
382
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
382
    }
547
382
    return buffer_ptr;
548
382
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol*>(unsigned long&, char*, char*, llvm::MCSymbol*)
Line
Count
Source
516
160
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
160
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
160
    }
547
160
    return buffer_ptr;
548
160
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineBasicBlock*>(unsigned long&, char*, char*, llvm::MachineBasicBlock*)
Line
Count
Source
516
1.66M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
1.66M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
1.66M
    }
547
1.66M
    return buffer_ptr;
548
1.66M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineOperand::MachineOperandType>(unsigned long&, char*, char*, llvm::MachineOperand::MachineOperandType)
Line
Count
Source
516
72.0M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
72.0M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
72.0M
    }
547
72.0M
    return buffer_ptr;
548
72.0M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long long>(unsigned long&, char*, char*, long long)
Line
Count
Source
516
26.2M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
26.2M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
26.2M
    }
547
26.2M
    return buffer_ptr;
548
26.2M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantInt const*>(unsigned long&, char*, char*, llvm::ConstantInt const*)
Line
Count
Source
516
15
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
15
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
15
    }
547
15
    return buffer_ptr;
548
15
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantFP const*>(unsigned long&, char*, char*, llvm::ConstantFP const*)
Line
Count
Source
516
241
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
241
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
241
    }
547
241
    return buffer_ptr;
548
241
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int const*>(unsigned long&, char*, char*, unsigned int const*)
Line
Count
Source
516
12
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
12
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
12
    }
547
12
    return buffer_ptr;
548
12
  }
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
516
24.5k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
24.5k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
24.5k
    }
547
24.5k
    return buffer_ptr;
548
24.5k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::FunctionType*>(unsigned long&, char*, char*, llvm::FunctionType*)
Line
Count
Source
516
24.5k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
24.5k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
24.5k
    }
547
24.5k
    return buffer_ptr;
548
24.5k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned char>(unsigned long&, char*, char*, unsigned char)
Line
Count
Source
516
36.3M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
36.3M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
36.3M
    }
547
36.3M
    return buffer_ptr;
548
36.3M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned short>(unsigned long&, char*, char*, unsigned short)
Line
Count
Source
516
16.9M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
16.9M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
16.9M
    }
547
16.9M
    return buffer_ptr;
548
16.9M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type const*>(unsigned long&, char*, char*, llvm::Type const*)
Line
Count
Source
516
7.12M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
7.12M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
7.12M
    }
547
7.12M
    return buffer_ptr;
548
7.12M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Metadata*>(unsigned long&, char*, char*, llvm::Metadata*)
Line
Count
Source
516
32.1M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
32.1M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
32.1M
    }
547
32.1M
    return buffer_ptr;
548
32.1M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDString*>(unsigned long&, char*, char*, llvm::MDString*)
Line
Count
Source
516
202k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
202k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
202k
    }
547
202k
    return buffer_ptr;
548
202k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long long>(unsigned long&, char*, char*, unsigned long long)
Line
Count
Source
516
224M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
224M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
2
      // Check for skew which prevents the buffer from being packed, and do
519
2
      // a partial store into the buffer to fill it. This is only a concern
520
2
      // with the variadic combine because that formation can have varying
521
2
      // argument types.
522
2
      size_t partial_store_size = buffer_end - buffer_ptr;
523
2
      memcpy(buffer_ptr, &data, partial_store_size);
524
2
525
2
      // If the store fails, our buffer is full and ready to hash. We have to
526
2
      // either initialize the hash state (on the first full buffer) or mix
527
2
      // this buffer into the existing hash state. Length tracks the *hashed*
528
2
      // length, not the buffered length.
529
2
      if (length == 0) {
530
2
        state = state.create(buffer, seed);
531
2
        length = 64;
532
2
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
2
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
2
      // data.
539
2
      buffer_ptr = buffer;
540
2
541
2
      // Try again to store into the buffer -- this cannot fail as we only
542
2
      // store types smaller than the buffer.
543
2
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
2
                             partial_store_size))
545
0
        abort();
546
224M
    }
547
224M
    return buffer_ptr;
548
224M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ArrayType*>(unsigned long&, char*, char*, llvm::ArrayType*)
Line
Count
Source
516
59.0k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
59.0k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
59.0k
    }
547
59.0k
    return buffer_ptr;
548
59.0k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::StructType*>(unsigned long&, char*, char*, llvm::StructType*)
Line
Count
Source
516
189k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
189k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
189k
    }
547
189k
    return buffer_ptr;
548
189k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::VectorType*>(unsigned long&, char*, char*, llvm::VectorType*)
Line
Count
Source
516
210k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
210k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
210k
    }
547
210k
    return buffer_ptr;
548
210k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type*>(unsigned long&, char*, char*, llvm::Type*)
Line
Count
Source
516
47.0M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
47.0M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
47.0M
    }
547
47.0M
    return buffer_ptr;
548
47.0M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::PointerType*>(unsigned long&, char*, char*, llvm::PointerType*)
Line
Count
Source
516
24.5k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
24.5k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
24.5k
    }
547
24.5k
    return buffer_ptr;
548
24.5k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol const*>(unsigned long&, char*, char*, llvm::MCSymbol const*)
Line
Count
Source
516
31.8k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
31.8k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
31.8k
    }
547
31.8k
    return buffer_ptr;
548
31.8k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::BinaryOps>(unsigned long&, char*, char*, llvm::Instruction::BinaryOps)
Line
Count
Source
516
7.25M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
7.25M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
7.25M
    }
547
7.25M
    return buffer_ptr;
548
7.25M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Value*>(unsigned long&, char*, char*, llvm::Value*)
Line
Count
Source
516
48.3M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
48.3M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
48.3M
    }
547
48.3M
    return buffer_ptr;
548
48.3M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::CmpInst::Predicate>(unsigned long&, char*, char*, llvm::CmpInst::Predicate)
Line
Count
Source
516
12.4M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
12.4M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
12.4M
    }
547
12.4M
    return buffer_ptr;
548
12.4M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::SelectPatternFlavor>(unsigned long&, char*, char*, llvm::SelectPatternFlavor)
Line
Count
Source
516
224k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
224k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
224k
    }
547
224k
    return buffer_ptr;
548
224k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::CastOps>(unsigned long&, char*, char*, llvm::Instruction::CastOps)
Line
Count
Source
516
7.90M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
7.90M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
7.90M
    }
547
7.90M
    return buffer_ptr;
548
7.90M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MemoryAccess const*>(unsigned long&, char*, char*, llvm::MemoryAccess const*)
Line
Count
Source
516
1.08k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
1.08k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
1.08k
    }
547
1.08k
    return buffer_ptr;
548
1.08k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Constant*>(unsigned long&, char*, char*, llvm::Constant*)
Line
Count
Source
516
461
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
461
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
461
    }
547
461
    return buffer_ptr;
548
461
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction*>(unsigned long&, char*, char*, llvm::Instruction*)
Line
Count
Source
516
264
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
264
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
264
    }
547
264
    return buffer_ptr;
548
264
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<short>(unsigned long&, char*, char*, short)
Line
Count
Source
516
991k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
991k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
991k
    }
547
991k
    return buffer_ptr;
548
991k
  }
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
516
33.9k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
33.9k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
33.9k
    }
547
33.9k
    return buffer_ptr;
548
33.9k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<clang::NestedNameSpecifier*>(unsigned long&, char*, char*, clang::NestedNameSpecifier*)
Line
Count
Source
516
782
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
782
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
782
    }
547
782
    return buffer_ptr;
548
782
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::RegisterBankInfo::ValueMapping const*>(unsigned long&, char*, char*, llvm::RegisterBankInfo::ValueMapping const*)
Line
Count
Source
516
14.1M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
14.1M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
14.1M
    }
547
14.1M
    return buffer_ptr;
548
14.1M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long>(unsigned long&, char*, char*, long)
Line
Count
Source
516
61.7k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
61.7k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
61.7k
    }
547
61.7k
    return buffer_ptr;
548
61.7k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<lld::DefinedAtom::ContentType>(unsigned long&, char*, char*, lld::DefinedAtom::ContentType)
Line
Count
Source
516
54
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
517
54
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
518
0
      // Check for skew which prevents the buffer from being packed, and do
519
0
      // a partial store into the buffer to fill it. This is only a concern
520
0
      // with the variadic combine because that formation can have varying
521
0
      // argument types.
522
0
      size_t partial_store_size = buffer_end - buffer_ptr;
523
0
      memcpy(buffer_ptr, &data, partial_store_size);
524
0
525
0
      // If the store fails, our buffer is full and ready to hash. We have to
526
0
      // either initialize the hash state (on the first full buffer) or mix
527
0
      // this buffer into the existing hash state. Length tracks the *hashed*
528
0
      // length, not the buffered length.
529
0
      if (length == 0) {
530
0
        state = state.create(buffer, seed);
531
0
        length = 64;
532
0
      } else {
533
0
        // Mix this chunk into the current state and bump length up by 64.
534
0
        state.mix(buffer);
535
0
        length += 64;
536
0
      }
537
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
538
0
      // data.
539
0
      buffer_ptr = buffer;
540
0
541
0
      // Try again to store into the buffer -- this cannot fail as we only
542
0
      // store types smaller than the buffer.
543
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
544
0
                             partial_store_size))
545
0
        abort();
546
54
    }
547
54
    return buffer_ptr;
548
54
  }
549
550
  /// Recursive, variadic combining method.
551
  ///
552
  /// This function recurses through each argument, combining that argument
553
  /// into a single hash.
554
  template <typename T, typename ...Ts>
555
  hash_code combine(size_t length, char *buffer_ptr, char *buffer_end,
556
978M
                    const T &arg, const Ts &...args) {
557
978M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
978M
559
978M
    // Recurse to the next argument.
560
978M
    return combine(length, buffer_ptr, buffer_end, args...);
561
978M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::hash_code const&)
Line
Count
Source
556
206
                    const T &arg, const Ts &...args) {
557
206
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
206
559
206
    // Recurse to the next argument.
560
206
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
17.2M
                    const T &arg, const Ts &...args) {
557
17.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
17.2M
559
17.2M
    // Recurse to the next argument.
560
17.2M
    return combine(length, buffer_ptr, buffer_end, args...);
561
17.2M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&)
Line
Count
Source
556
65.8M
                    const T &arg, const Ts &...args) {
557
65.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
65.8M
559
65.8M
    // Recurse to the next argument.
560
65.8M
    return combine(length, buffer_ptr, buffer_end, args...);
561
65.8M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&)
Line
Count
Source
556
761k
                    const T &arg, const Ts &...args) {
557
761k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
761k
559
761k
    // Recurse to the next argument.
560
761k
    return combine(length, buffer_ptr, buffer_end, args...);
561
761k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int>(unsigned long, char*, char*, unsigned int const&)
Line
Count
Source
556
34.9M
                    const T &arg, const Ts &...args) {
557
34.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
34.9M
559
34.9M
    // Recurse to the next argument.
560
34.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
34.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::CounterExpression::ExprKind, llvm::coverage::Counter::CounterKind, unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::CounterExpression::ExprKind const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&)
Line
Count
Source
556
1.74k
                    const T &arg, const Ts &...args) {
557
1.74k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.74k
559
1.74k
    // Recurse to the next argument.
560
1.74k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.74k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::Counter::CounterKind, unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::Counter::CounterKind const&, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&)
Line
Count
Source
556
1.74k
                    const T &arg, const Ts &...args) {
557
1.74k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.74k
559
1.74k
    // Recurse to the next argument.
560
1.74k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.74k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::coverage::Counter::CounterKind const&, unsigned int const&)
Line
Count
Source
556
1.74k
                    const T &arg, const Ts &...args) {
557
1.74k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.74k
559
1.74k
    // Recurse to the next argument.
560
1.74k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.74k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::coverage::Counter::CounterKind, unsigned int>(unsigned long, char*, char*, llvm::coverage::Counter::CounterKind const&, unsigned int const&)
Line
Count
Source
556
1.74k
                    const T &arg, const Ts &...args) {
557
1.74k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.74k
559
1.74k
    // Recurse to the next argument.
560
1.74k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.74k
  }
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
556
262
                    const T &arg, const Ts &...args) {
557
262
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
262
559
262
    // Recurse to the next argument.
560
262
    return combine(length, buffer_ptr, buffer_end, args...);
561
262
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, bool>(unsigned long, char*, char*, llvm::hash_code const&, bool const&)
Line
Count
Source
556
7.27M
                    const T &arg, const Ts &...args) {
557
7.27M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
7.27M
559
7.27M
    // Recurse to the next argument.
560
7.27M
    return combine(length, buffer_ptr, buffer_end, args...);
561
7.27M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool>(unsigned long, char*, char*, bool const&)
Line
Count
Source
556
50.8M
                    const T &arg, const Ts &...args) {
557
50.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
50.8M
559
50.8M
    // Recurse to the next argument.
560
50.8M
    return combine(length, buffer_ptr, buffer_end, args...);
561
50.8M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
556
96.4k
                    const T &arg, const Ts &...args) {
557
96.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
96.4k
559
96.4k
    // Recurse to the next argument.
560
96.4k
    return combine(length, buffer_ptr, buffer_end, args...);
561
96.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
556
96.4k
                    const T &arg, const Ts &...args) {
557
96.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
96.4k
559
96.4k
    // Recurse to the next argument.
560
96.4k
    return combine(length, buffer_ptr, buffer_end, args...);
561
96.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
556
96.4k
                    const T &arg, const Ts &...args) {
557
96.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
96.4k
559
96.4k
    // Recurse to the next argument.
560
96.4k
    return combine(length, buffer_ptr, buffer_end, args...);
561
96.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&)
Line
Count
Source
556
96.4k
                    const T &arg, const Ts &...args) {
557
96.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
96.4k
559
96.4k
    // Recurse to the next argument.
560
96.4k
    return combine(length, buffer_ptr, buffer_end, args...);
561
96.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, int>(unsigned long, char*, char*, llvm::hash_code const&, int const&)
Line
Count
Source
556
176
                    const T &arg, const Ts &...args) {
557
176
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
176
559
176
    // Recurse to the next argument.
560
176
    return combine(length, buffer_ptr, buffer_end, args...);
561
176
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int>(unsigned long, char*, char*, int const&)
Line
Count
Source
556
602k
                    const T &arg, const Ts &...args) {
557
602k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
602k
559
602k
    // Recurse to the next argument.
560
602k
    return combine(length, buffer_ptr, buffer_end, args...);
561
602k
  }
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, char const*>(unsigned long, char*, char*, llvm::hash_code const&, char const* const&)
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<char const*>(unsigned long, char*, char*, char const* const&)
Line
Count
Source
556
5.93k
                    const T &arg, const Ts &...args) {
557
5.93k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.93k
559
5.93k
    // Recurse to the next argument.
560
5.93k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.93k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::GlobalValue const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::GlobalValue const* const&)
Line
Count
Source
556
52.6k
                    const T &arg, const Ts &...args) {
557
52.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
52.6k
559
52.6k
    // Recurse to the next argument.
560
52.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
52.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::GlobalValue const*>(unsigned long, char*, char*, llvm::GlobalValue const* const&)
Line
Count
Source
556
52.6k
                    const T &arg, const Ts &...args) {
557
52.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
52.6k
559
52.6k
    // Recurse to the next argument.
560
52.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
52.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::BlockAddress const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::BlockAddress const* const&)
Line
Count
Source
556
12
                    const T &arg, const Ts &...args) {
557
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12
559
12
    // Recurse to the next argument.
560
12
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
12
                    const T &arg, const Ts &...args) {
557
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12
559
12
    // Recurse to the next argument.
560
12
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
3
                    const T &arg, const Ts &...args) {
557
3
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3
559
3
    // Recurse to the next argument.
560
3
    return combine(length, buffer_ptr, buffer_end, args...);
561
3
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MCSymbol* const&)
Line
Count
Source
556
160
                    const T &arg, const Ts &...args) {
557
160
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
160
559
160
    // Recurse to the next argument.
560
160
    return combine(length, buffer_ptr, buffer_end, args...);
561
160
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::MachineBasicBlock* const&)
Line
Count
Source
556
8
                    const T &arg, const Ts &...args) {
557
8
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
8
559
8
    // Recurse to the next argument.
560
8
    return combine(length, buffer_ptr, buffer_end, args...);
561
8
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineBasicBlock* const&)
Line
Count
Source
556
1.66M
                    const T &arg, const Ts &...args) {
557
1.66M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.66M
559
1.66M
    // Recurse to the next argument.
560
1.66M
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.66M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, unsigned int>(unsigned long, char*, char*, bool const&, unsigned int const&)
Line
Count
Source
556
1.97M
                    const T &arg, const Ts &...args) {
557
1.97M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.97M
559
1.97M
    // Recurse to the next argument.
560
1.97M
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.97M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, unsigned int>(unsigned long, char*, char*, llvm::hash_code const&, unsigned int const&)
Line
Count
Source
556
349k
                    const T &arg, const Ts &...args) {
557
349k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
349k
559
349k
    // Recurse to the next argument.
560
349k
    return combine(length, buffer_ptr, buffer_end, args...);
561
349k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int, bool>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const&, bool const&)
Line
Count
Source
556
43.5M
                    const T &arg, const Ts &...args) {
557
43.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
43.5M
559
43.5M
    // Recurse to the next argument.
560
43.5M
    return combine(length, buffer_ptr, buffer_end, args...);
561
43.5M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, bool const&)
Line
Count
Source
556
43.5M
                    const T &arg, const Ts &...args) {
557
43.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
43.5M
559
43.5M
    // Recurse to the next argument.
560
43.5M
    return combine(length, buffer_ptr, buffer_end, args...);
561
43.5M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, bool const&)
Line
Count
Source
556
43.5M
                    const T &arg, const Ts &...args) {
557
43.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
43.5M
559
43.5M
    // Recurse to the next argument.
560
43.5M
    return combine(length, buffer_ptr, buffer_end, args...);
561
43.5M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&)
Line
Count
Source
556
21.9M
                    const T &arg, const Ts &...args) {
557
21.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
21.9M
559
21.9M
    // Recurse to the next argument.
560
21.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
21.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, long long>(unsigned long, char*, char*, unsigned int const&, long long const&)
Line
Count
Source
556
21.9M
                    const T &arg, const Ts &...args) {
557
21.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
21.9M
559
21.9M
    // Recurse to the next argument.
560
21.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
21.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long>(unsigned long, char*, char*, long long const&)
Line
Count
Source
556
26.1M
                    const T &arg, const Ts &...args) {
557
26.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
26.1M
559
26.1M
    // Recurse to the next argument.
560
26.1M
    return combine(length, buffer_ptr, buffer_end, args...);
561
26.1M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::ConstantInt const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::ConstantInt const* const&)
Line
Count
Source
556
15
                    const T &arg, const Ts &...args) {
557
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15
559
15
    // Recurse to the next argument.
560
15
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
15
                    const T &arg, const Ts &...args) {
557
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15
559
15
    // Recurse to the next argument.
560
15
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
15
                    const T &arg, const Ts &...args) {
557
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15
559
15
    // Recurse to the next argument.
560
15
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
241
                    const T &arg, const Ts &...args) {
557
241
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
241
559
241
    // Recurse to the next argument.
560
241
    return combine(length, buffer_ptr, buffer_end, args...);
561
241
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::ConstantFP const*>(unsigned long, char*, char*, unsigned int const&, llvm::ConstantFP const* const&)
Line
Count
Source
556
241
                    const T &arg, const Ts &...args) {
557
241
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
241
559
241
    // Recurse to the next argument.
560
241
    return combine(length, buffer_ptr, buffer_end, args...);
561
241
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ConstantFP const*>(unsigned long, char*, char*, llvm::ConstantFP const* const&)
Line
Count
Source
556
241
                    const T &arg, const Ts &...args) {
557
241
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
241
559
241
    // Recurse to the next argument.
560
241
    return combine(length, buffer_ptr, buffer_end, args...);
561
241
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MachineBasicBlock* const&)
Line
Count
Source
556
1.66M
                    const T &arg, const Ts &...args) {
557
1.66M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.66M
559
1.66M
    // Recurse to the next argument.
560
1.66M
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.66M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MachineBasicBlock*>(unsigned long, char*, char*, unsigned int const&, llvm::MachineBasicBlock* const&)
Line
Count
Source
556
1.66M
                    const T &arg, const Ts &...args) {
557
1.66M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.66M
559
1.66M
    // Recurse to the next argument.
560
1.66M
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.66M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, int>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&)
Line
Count
Source
556
602k
                    const T &arg, const Ts &...args) {
557
602k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
602k
559
602k
    // Recurse to the next argument.
560
602k
    return combine(length, buffer_ptr, buffer_end, args...);
561
602k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, int>(unsigned long, char*, char*, unsigned int const&, int const&)
Line
Count
Source
556
602k
                    const T &arg, const Ts &...args) {
557
602k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
602k
559
602k
    // Recurse to the next argument.
560
602k
    return combine(length, buffer_ptr, buffer_end, args...);
561
602k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, int, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, int const&, long long const&)
Line
Count
Source
556
414k
                    const T &arg, const Ts &...args) {
557
414k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
414k
559
414k
    // Recurse to the next argument.
560
414k
    return combine(length, buffer_ptr, buffer_end, args...);
561
414k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, int, long long>(unsigned long, char*, char*, unsigned int const&, int const&, long long const&)
Line
Count
Source
556
414k
                    const T &arg, const Ts &...args) {
557
414k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
414k
559
414k
    // Recurse to the next argument.
560
414k
    return combine(length, buffer_ptr, buffer_end, args...);
561
414k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int, long long>(unsigned long, char*, char*, int const&, long long const&)
Line
Count
Source
556
414k
                    const T &arg, const Ts &...args) {
557
414k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
414k
559
414k
    // Recurse to the next argument.
560
414k
    return combine(length, buffer_ptr, buffer_end, args...);
561
414k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, long long, char const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, long long const&, char const* const&)
Line
Count
Source
556
5.93k
                    const T &arg, const Ts &...args) {
557
5.93k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.93k
559
5.93k
    // Recurse to the next argument.
560
5.93k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.93k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, long long, char const*>(unsigned long, char*, char*, unsigned int const&, long long const&, char const* const&)
Line
Count
Source
556
5.93k
                    const T &arg, const Ts &...args) {
557
5.93k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.93k
559
5.93k
    // Recurse to the next argument.
560
5.93k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.93k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, char const*>(unsigned long, char*, char*, long long const&, char const* const&)
Line
Count
Source
556
5.93k
                    const T &arg, const Ts &...args) {
557
5.93k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.93k
559
5.93k
    // Recurse to the next argument.
560
5.93k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.93k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::GlobalValue const*, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::GlobalValue const* const&, long long const&)
Line
Count
Source
556
3.82M
                    const T &arg, const Ts &...args) {
557
3.82M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.82M
559
3.82M
    // Recurse to the next argument.
560
3.82M
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.82M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::GlobalValue const*, long long>(unsigned long, char*, char*, unsigned int const&, llvm::GlobalValue const* const&, long long const&)
Line
Count
Source
556
3.82M
                    const T &arg, const Ts &...args) {
557
3.82M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.82M
559
3.82M
    // Recurse to the next argument.
560
3.82M
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.82M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::GlobalValue const*, long long>(unsigned long, char*, char*, llvm::GlobalValue const* const&, long long const&)
Line
Count
Source
556
3.82M
                    const T &arg, const Ts &...args) {
557
3.82M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.82M
559
3.82M
    // Recurse to the next argument.
560
3.82M
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.82M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::BlockAddress const*, long long>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::BlockAddress const* const&, long long const&)
Line
Count
Source
556
370
                    const T &arg, const Ts &...args) {
557
370
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
370
559
370
    // Recurse to the next argument.
560
370
    return combine(length, buffer_ptr, buffer_end, args...);
561
370
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::BlockAddress const*, long long>(unsigned long, char*, char*, unsigned int const&, llvm::BlockAddress const* const&, long long const&)
Line
Count
Source
556
370
                    const T &arg, const Ts &...args) {
557
370
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
370
559
370
    // Recurse to the next argument.
560
370
    return combine(length, buffer_ptr, buffer_end, args...);
561
370
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BlockAddress const*, long long>(unsigned long, char*, char*, llvm::BlockAddress const* const&, long long const&)
Line
Count
Source
556
370
                    const T &arg, const Ts &...args) {
557
370
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
370
559
370
    // Recurse to the next argument.
560
370
    return combine(length, buffer_ptr, buffer_end, args...);
561
370
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const* const&)
Line
Count
Source
556
12
                    const T &arg, const Ts &...args) {
557
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12
559
12
    // Recurse to the next argument.
560
12
    return combine(length, buffer_ptr, buffer_end, args...);
561
12
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int const*>(unsigned long, char*, char*, unsigned int const&, unsigned int const* const&)
Line
Count
Source
556
12
                    const T &arg, const Ts &...args) {
557
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12
559
12
    // Recurse to the next argument.
560
12
    return combine(length, buffer_ptr, buffer_end, args...);
561
12
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int const*>(unsigned long, char*, char*, unsigned int const* const&)
Line
Count
Source
556
12
                    const T &arg, const Ts &...args) {
557
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12
559
12
    // Recurse to the next argument.
560
12
    return combine(length, buffer_ptr, buffer_end, args...);
561
12
  }
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
556
157
                    const T &arg, const Ts &...args) {
557
157
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
157
559
157
    // Recurse to the next argument.
560
157
    return combine(length, buffer_ptr, buffer_end, args...);
561
157
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MCSymbol*>(unsigned long, char*, char*, unsigned int const&, llvm::MCSymbol* const&)
Line
Count
Source
556
157
                    const T &arg, const Ts &...args) {
557
157
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
157
559
157
    // Recurse to the next argument.
560
157
    return combine(length, buffer_ptr, buffer_end, args...);
561
157
  }
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
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StringRef, bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, llvm::StringRef const&, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, bool const&, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::FunctionType*>(unsigned long, char*, char*, llvm::FunctionType* const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned char, unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned char const&, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&)
Line
Count
Source
556
16.9M
                    const T &arg, const Ts &...args) {
557
16.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
16.9M
559
16.9M
    // Recurse to the next argument.
560
16.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
16.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned char const&, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&)
Line
Count
Source
556
16.9M
                    const T &arg, const Ts &...args) {
557
16.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
16.9M
559
16.9M
    // Recurse to the next argument.
560
16.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
16.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned short, llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, unsigned short const&, llvm::hash_code const&, llvm::hash_code const&)
Line
Count
Source
556
16.9M
                    const T &arg, const Ts &...args) {
557
16.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
16.9M
559
16.9M
    // Recurse to the next argument.
560
16.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
16.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&, llvm::hash_code const&)
Line
Count
Source
556
24.9M
                    const T &arg, const Ts &...args) {
557
24.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.9M
559
24.9M
    // Recurse to the next argument.
560
24.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type const*, llvm::hash_code, bool>(unsigned long, char*, char*, llvm::Type const* const&, llvm::hash_code const&, bool const&)
Line
Count
Source
556
7.12M
                    const T &arg, const Ts &...args) {
557
7.12M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
7.12M
559
7.12M
    // Recurse to the next argument.
560
7.12M
    return combine(length, buffer_ptr, buffer_end, args...);
561
7.12M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
15.9M
                    const T &arg, const Ts &...args) {
557
15.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15.9M
559
15.9M
    // Recurse to the next argument.
560
15.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
15.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
15.9M
                    const T &arg, const Ts &...args) {
557
15.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15.9M
559
15.9M
    // Recurse to the next argument.
560
15.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
15.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
15.9M
                    const T &arg, const Ts &...args) {
557
15.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
15.9M
559
15.9M
    // Recurse to the next argument.
560
15.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
15.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&)
Line
Count
Source
556
16.0M
                    const T &arg, const Ts &...args) {
557
16.0M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
16.0M
559
16.0M
    // Recurse to the next argument.
560
16.0M
    return combine(length, buffer_ptr, buffer_end, args...);
561
16.0M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::MDString* const&)
Line
Count
Source
556
114
                    const T &arg, const Ts &...args) {
557
114
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
114
559
114
    // Recurse to the next argument.
560
114
    return combine(length, buffer_ptr, buffer_end, args...);
561
114
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&)
Line
Count
Source
556
1.92k
                    const T &arg, const Ts &...args) {
557
1.92k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.92k
559
1.92k
    // Recurse to the next argument.
560
1.92k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.92k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&)
Line
Count
Source
556
52.8k
                    const T &arg, const Ts &...args) {
557
52.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
52.8k
559
52.8k
    // Recurse to the next argument.
560
52.8k
    return combine(length, buffer_ptr, buffer_end, args...);
561
52.8k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long, long long>(unsigned long, char*, char*, long long const&, long long const&)
Line
Count
Source
556
757
                    const T &arg, const Ts &...args) {
557
757
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
757
559
757
    // Recurse to the next argument.
560
757
    return combine(length, buffer_ptr, buffer_end, args...);
561
757
  }
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
556
83
                    const T &arg, const Ts &...args) {
557
83
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
83
559
83
    // Recurse to the next argument.
560
83
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
18.9k
                    const T &arg, const Ts &...args) {
557
18.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
18.9k
559
18.9k
    // Recurse to the next argument.
560
18.9k
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
3.61k
                    const T &arg, const Ts &...args) {
557
3.61k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.61k
559
3.61k
    // Recurse to the next argument.
560
3.61k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.61k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, unsigned long long, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, unsigned long long const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
3.62k
                    const T &arg, const Ts &...args) {
557
3.62k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.62k
559
3.62k
    // Recurse to the next argument.
560
3.62k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.62k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned long long, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned long long const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
3.62k
                    const T &arg, const Ts &...args) {
557
3.62k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.62k
559
3.62k
    // Recurse to the next argument.
560
3.62k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.62k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&)
Line
Count
Source
556
4.54k
                    const T &arg, const Ts &...args) {
557
4.54k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
4.54k
559
4.54k
    // Recurse to the next argument.
560
4.54k
    return combine(length, buffer_ptr, buffer_end, args...);
561
4.54k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
17.0k
                    const T &arg, const Ts &...args) {
557
17.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
17.0k
559
17.0k
    // Recurse to the next argument.
560
17.0k
    return combine(length, buffer_ptr, buffer_end, args...);
561
17.0k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
17.0k
                    const T &arg, const Ts &...args) {
557
17.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
17.0k
559
17.0k
    // Recurse to the next argument.
560
17.0k
    return combine(length, buffer_ptr, buffer_end, args...);
561
17.0k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
17.0k
                    const T &arg, const Ts &...args) {
557
17.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
17.0k
559
17.0k
    // Recurse to the next argument.
560
17.0k
    return combine(length, buffer_ptr, buffer_end, args...);
561
17.0k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
17.0k
                    const T &arg, const Ts &...args) {
557
17.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
17.0k
559
17.0k
    // Recurse to the next argument.
560
17.0k
    return combine(length, buffer_ptr, buffer_end, args...);
561
17.0k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
22.5k
                    const T &arg, const Ts &...args) {
557
22.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
22.5k
559
22.5k
    // Recurse to the next argument.
560
22.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
22.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
22.5k
                    const T &arg, const Ts &...args) {
557
22.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
22.5k
559
22.5k
    // Recurse to the next argument.
560
22.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
22.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
5.36k
                    const T &arg, const Ts &...args) {
557
5.36k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.36k
559
5.36k
    // Recurse to the next argument.
560
5.36k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.36k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
5.36k
                    const T &arg, const Ts &...args) {
557
5.36k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.36k
559
5.36k
    // Recurse to the next argument.
560
5.36k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.36k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
5.36k
                    const T &arg, const Ts &...args) {
557
5.36k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.36k
559
5.36k
    // Recurse to the next argument.
560
5.36k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.36k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
5.36k
                    const T &arg, const Ts &...args) {
557
5.36k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.36k
559
5.36k
    // Recurse to the next argument.
560
5.36k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.36k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
556
5.36k
                    const T &arg, const Ts &...args) {
557
5.36k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
5.36k
559
5.36k
    // Recurse to the next argument.
560
5.36k
    return combine(length, buffer_ptr, buffer_end, args...);
561
5.36k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned char, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, unsigned char const&, llvm::Metadata* const&)
Line
Count
Source
556
120k
                    const T &arg, const Ts &...args) {
557
120k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
120k
559
120k
    // Recurse to the next argument.
560
120k
    return combine(length, buffer_ptr, buffer_end, args...);
561
120k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned char, llvm::Metadata*>(unsigned long, char*, char*, unsigned char const&, llvm::Metadata* const&)
Line
Count
Source
556
120k
                    const T &arg, const Ts &...args) {
557
120k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
120k
559
120k
    // Recurse to the next argument.
560
120k
    return combine(length, buffer_ptr, buffer_end, args...);
561
120k
  }
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
556
28.1k
                    const T &arg, const Ts &...args) {
557
28.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
28.1k
559
28.1k
    // Recurse to the next argument.
560
28.1k
    return combine(length, buffer_ptr, buffer_end, args...);
561
28.1k
  }
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
556
28.1k
                    const T &arg, const Ts &...args) {
557
28.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
28.1k
559
28.1k
    // Recurse to the next argument.
560
28.1k
    return combine(length, buffer_ptr, buffer_end, args...);
561
28.1k
  }
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
556
28.1k
                    const T &arg, const Ts &...args) {
557
28.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
28.1k
559
28.1k
    // Recurse to the next argument.
560
28.1k
    return combine(length, buffer_ptr, buffer_end, args...);
561
28.1k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
556
31.4k
                    const T &arg, const Ts &...args) {
557
31.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
31.4k
559
31.4k
    // Recurse to the next argument.
560
31.4k
    return combine(length, buffer_ptr, buffer_end, args...);
561
31.4k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
3.17k
                    const T &arg, const Ts &...args) {
557
3.17k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.17k
559
3.17k
    // Recurse to the next argument.
560
3.17k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.17k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&)
Line
Count
Source
556
3.17k
                    const T &arg, const Ts &...args) {
557
3.17k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.17k
559
3.17k
    // Recurse to the next argument.
560
3.17k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.17k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
61
                    const T &arg, const Ts &...args) {
557
61
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
61
559
61
    // Recurse to the next argument.
560
61
    return combine(length, buffer_ptr, buffer_end, args...);
561
61
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
20.6k
                    const T &arg, const Ts &...args) {
557
20.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
20.6k
559
20.6k
    // Recurse to the next argument.
560
20.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
20.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&)
Line
Count
Source
556
500
                    const T &arg, const Ts &...args) {
557
500
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
500
559
500
    // Recurse to the next argument.
560
500
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
133
                    const T &arg, const Ts &...args) {
557
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
133
559
133
    // Recurse to the next argument.
560
133
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
133
                    const T &arg, const Ts &...args) {
557
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
133
559
133
    // Recurse to the next argument.
560
133
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
133
                    const T &arg, const Ts &...args) {
557
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
133
559
133
    // Recurse to the next argument.
560
133
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
1.21k
                    const T &arg, const Ts &...args) {
557
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.21k
559
1.21k
    // Recurse to the next argument.
560
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
1.21k
                    const T &arg, const Ts &...args) {
557
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.21k
559
1.21k
    // Recurse to the next argument.
560
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, llvm::Metadata* const&)
Line
Count
Source
556
2.80k
                    const T &arg, const Ts &...args) {
557
2.80k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.80k
559
2.80k
    // Recurse to the next argument.
560
2.80k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.80k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
20.6k
                    const T &arg, const Ts &...args) {
557
20.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
20.6k
559
20.6k
    // Recurse to the next argument.
560
20.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
20.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
20.6k
                    const T &arg, const Ts &...args) {
557
20.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
20.6k
559
20.6k
    // Recurse to the next argument.
560
20.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
20.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
20.6k
                    const T &arg, const Ts &...args) {
557
20.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
20.6k
559
20.6k
    // Recurse to the next argument.
560
20.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
20.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
556
20.6k
                    const T &arg, const Ts &...args) {
557
20.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
20.6k
559
20.6k
    // Recurse to the next argument.
560
20.6k
    return combine(length, buffer_ptr, buffer_end, args...);
561
20.6k
  }
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
556
43
                    const T &arg, const Ts &...args) {
557
43
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
43
559
43
    // Recurse to the next argument.
560
43
    return combine(length, buffer_ptr, buffer_end, args...);
561
43
  }
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
556
43
                    const T &arg, const Ts &...args) {
557
43
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
43
559
43
    // Recurse to the next argument.
560
43
    return combine(length, buffer_ptr, buffer_end, args...);
561
43
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::MDString*, llvm::MDString*, unsigned int, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&, unsigned int const&, llvm::Metadata* const&)
Line
Count
Source
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
167
                    const T &arg, const Ts &...args) {
557
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
167
559
167
    // Recurse to the next argument.
560
167
    return combine(length, buffer_ptr, buffer_end, args...);
561
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
556
1.81k
                    const T &arg, const Ts &...args) {
557
1.81k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.81k
559
1.81k
    // Recurse to the next argument.
560
1.81k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.81k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&)
Line
Count
Source
556
1.81k
                    const T &arg, const Ts &...args) {
557
1.81k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.81k
559
1.81k
    // Recurse to the next argument.
560
1.81k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.81k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&)
Line
Count
Source
556
1.81k
                    const T &arg, const Ts &...args) {
557
1.81k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.81k
559
1.81k
    // Recurse to the next argument.
560
1.81k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.81k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::MDString*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::MDString* const&)
Line
Count
Source
556
1.81k
                    const T &arg, const Ts &...args) {
557
1.81k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.81k
559
1.81k
    // Recurse to the next argument.
560
1.81k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.81k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
556
3.18k
                    const T &arg, const Ts &...args) {
557
3.18k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.18k
559
3.18k
    // Recurse to the next argument.
560
3.18k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.18k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
556
3.18k
                    const T &arg, const Ts &...args) {
557
3.18k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
3.18k
559
3.18k
    // Recurse to the next argument.
560
3.18k
    return combine(length, buffer_ptr, buffer_end, args...);
561
3.18k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ArrayType*, unsigned int>(unsigned long, char*, char*, llvm::ArrayType* const&, unsigned int const&)
Line
Count
Source
556
59.0k
                    const T &arg, const Ts &...args) {
557
59.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
59.0k
559
59.0k
    // Recurse to the next argument.
560
59.0k
    return combine(length, buffer_ptr, buffer_end, args...);
561
59.0k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::StructType*, unsigned int>(unsigned long, char*, char*, llvm::StructType* const&, unsigned int const&)
Line
Count
Source
556
189k
                    const T &arg, const Ts &...args) {
557
189k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
189k
559
189k
    // Recurse to the next argument.
560
189k
    return combine(length, buffer_ptr, buffer_end, args...);
561
189k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::VectorType*, unsigned int>(unsigned long, char*, char*, llvm::VectorType* const&, unsigned int const&)
Line
Count
Source
556
210k
                    const T &arg, const Ts &...args) {
557
210k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
210k
559
210k
    // Recurse to the next argument.
560
210k
    return combine(length, buffer_ptr, buffer_end, args...);
561
210k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, unsigned int>(unsigned long, char*, char*, llvm::Type* const&, unsigned int const&)
Line
Count
Source
556
16.9M
                    const T &arg, const Ts &...args) {
557
16.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
16.9M
559
16.9M
    // Recurse to the next argument.
560
16.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
16.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::PointerType*, unsigned int>(unsigned long, char*, char*, llvm::PointerType* const&, unsigned int const&)
Line
Count
Source
556
24.5k
                    const T &arg, const Ts &...args) {
557
24.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
24.5k
559
24.5k
    // Recurse to the next argument.
560
24.5k
    return combine(length, buffer_ptr, buffer_end, args...);
561
24.5k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol const*, unsigned int, unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, llvm::MCSymbol const* const&, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&)
Line
Count
Source
556
31.8k
                    const T &arg, const Ts &...args) {
557
31.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
31.8k
559
31.8k
    // Recurse to the next argument.
560
31.8k
    return combine(length, buffer_ptr, buffer_end, args...);
561
31.8k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&)
Line
Count
Source
556
31.8k
                    const T &arg, const Ts &...args) {
557
31.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
31.8k
559
31.8k
    // Recurse to the next argument.
560
31.8k
    return combine(length, buffer_ptr, buffer_end, args...);
561
31.8k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, bool, bool, unsigned int>(unsigned long, char*, char*, unsigned int const&, bool const&, bool const&, unsigned int const&)
Line
Count
Source
556
31.8k
                    const T &arg, const Ts &...args) {
557
31.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
31.8k
559
31.8k
    // Recurse to the next argument.
560
31.8k
    return combine(length, buffer_ptr, buffer_end, args...);
561
31.8k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, unsigned int>(unsigned long, char*, char*, bool const&, bool const&, unsigned int const&)
Line
Count
Source
556
31.8k
                    const T &arg, const Ts &...args) {
557
31.8k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
31.8k
559
31.8k
    // Recurse to the next argument.
560
31.8k
    return combine(length, buffer_ptr, buffer_end, args...);
561
31.8k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::Instruction::BinaryOps const&, llvm::Value* const&, llvm::Value* const&)
Line
Count
Source
556
7.25M
                    const T &arg, const Ts &...args) {
557
7.25M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
7.25M
559
7.25M
    // Recurse to the next argument.
560
7.25M
    return combine(length, buffer_ptr, buffer_end, args...);
561
7.25M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&, llvm::Value* const&)
Line
Count
Source
556
19.9M
                    const T &arg, const Ts &...args) {
557
19.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
19.9M
559
19.9M
    // Recurse to the next argument.
560
19.9M
    return combine(length, buffer_ptr, buffer_end, args...);
561
19.9M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&)
Line
Count
Source
556
27.8M
                    const T &arg, const Ts &...args) {
557
27.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
27.8M
559
27.8M
    // Recurse to the next argument.
560
27.8M
    return combine(length, buffer_ptr, buffer_end, args...);
561
27.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
556
12.4M
                    const T &arg, const Ts &...args) {
557
12.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12.4M
559
12.4M
    // Recurse to the next argument.
560
12.4M
    return combine(length, buffer_ptr, buffer_end, args...);
561
12.4M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::CmpInst::Predicate, llvm::Value*, llvm::Value*>(unsigned long, char*, char*, llvm::CmpInst::Predicate const&, llvm::Value* const&, llvm::Value* const&)
Line
Count
Source
556
12.4M
                    const T &arg, const Ts &...args) {
557
12.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
12.4M
559
12.4M
    // Recurse to the next argument.
560
12.4M
    return combine(length, buffer_ptr, buffer_end, args...);
561
12.4M
  }
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
556
224k
                    const T &arg, const Ts &...args) {
557
224k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
224k
559
224k
    // Recurse to the next argument.
560
224k
    return combine(length, buffer_ptr, buffer_end, args...);
561
224k
  }
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
556
224k
                    const T &arg, const Ts &...args) {
557
224k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
224k
559
224k
    // Recurse to the next argument.
560
224k
    return combine(length, buffer_ptr, buffer_end, args...);
561
224k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction::CastOps, llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::Instruction::CastOps const&, llvm::Type* const&, llvm::Value* const&)
Line
Count
Source
556
7.90M
                    const T &arg, const Ts &...args) {
557
7.90M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
7.90M
559
7.90M
    // Recurse to the next argument.
560
7.90M
    return combine(length, buffer_ptr, buffer_end, args...);
561
7.90M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::Type* const&, llvm::Value* const&)
Line
Count
Source
556
7.90M
                    const T &arg, const Ts &...args) {
557
7.90M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
7.90M
559
7.90M
    // Recurse to the next argument.
560
7.90M
    return combine(length, buffer_ptr, buffer_end, args...);
561
7.90M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Value* const&, llvm::hash_code const&)
Line
Count
Source
556
327k
                    const T &arg, const Ts &...args) {
557
327k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
327k
559
327k
    // Recurse to the next argument.
560
327k
    return combine(length, buffer_ptr, buffer_end, args...);
561
327k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, llvm::Value* const&, llvm::hash_code const&)
Line
Count
Source
556
435k
                    const T &arg, const Ts &...args) {
557
435k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
435k
559
435k
    // Recurse to the next argument.
560
435k
    return combine(length, buffer_ptr, buffer_end, args...);
561
435k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Value*, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Value* const&, llvm::Value* const&, llvm::hash_code const&)
Line
Count
Source
556
107k
                    const T &arg, const Ts &...args) {
557
107k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
107k
559
107k
    // Recurse to the next argument.
560
107k
    return combine(length, buffer_ptr, buffer_end, args...);
561
107k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*, llvm::Value*, llvm::hash_code>(unsigned long, char*, char*, llvm::Value* const&, llvm::Value* const&, llvm::hash_code const&)
Line
Count
Source
556
107k
                    const T &arg, const Ts &...args) {
557
107k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
107k
559
107k
    // Recurse to the next argument.
560
107k
    return combine(length, buffer_ptr, buffer_end, args...);
561
107k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::hash_code const&)
Line
Count
Source
556
2.27k
                    const T &arg, const Ts &...args) {
557
2.27k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
2.27k
559
2.27k
    // Recurse to the next argument.
560
2.27k
    return combine(length, buffer_ptr, buffer_end, args...);
561
2.27k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, llvm::Type* const&, llvm::hash_code const&)
Line
Count
Source
556
22.1M
                    const T &arg, const Ts &...args) {
557
22.1M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
22.1M
559
22.1M
    // Recurse to the next argument.
560
22.1M
    return combine(length, buffer_ptr, buffer_end, args...);
561
22.1M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::MemoryAccess const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::MemoryAccess const* const&)
Line
Count
Source
556
1.08k
                    const T &arg, const Ts &...args) {
557
1.08k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.08k
559
1.08k
    // Recurse to the next argument.
560
1.08k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.08k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MemoryAccess const*>(unsigned long, char*, char*, llvm::MemoryAccess const* const&)
Line
Count
Source
556
1.08k
                    const T &arg, const Ts &...args) {
557
1.08k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
1.08k
559
1.08k
    // Recurse to the next argument.
560
1.08k
    return combine(length, buffer_ptr, buffer_end, args...);
561
1.08k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::BasicBlock*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::BasicBlock* const&)
Line
Count
Source
556
262
                    const T &arg, const Ts &...args) {
557
262
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
262
559
262
    // Recurse to the next argument.
560
262
    return combine(length, buffer_ptr, buffer_end, args...);
561
262
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::Value*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::Value* const&)
Line
Count
Source
556
54
                    const T &arg, const Ts &...args) {
557
54
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
54
559
54
    // Recurse to the next argument.
560
54
    return combine(length, buffer_ptr, buffer_end, args...);
561
54
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Type*, llvm::Constant*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Type* const&, llvm::Constant* const&)
Line
Count
Source
556
461
                    const T &arg, const Ts &...args) {
557
461
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
461
559
461
    // Recurse to the next argument.
560
461
    return combine(length, buffer_ptr, buffer_end, args...);
561
461
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Type*, llvm::Constant*>(unsigned long, char*, char*, llvm::Type* const&, llvm::Constant* const&)
Line
Count
Source
556
461
                    const T &arg, const Ts &...args) {
557
461
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
461
559
461
    // Recurse to the next argument.
560
461
    return combine(length, buffer_ptr, buffer_end, args...);
561
461
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Constant*>(unsigned long, char*, char*, llvm::Constant* const&)
Line
Count
Source
556
461
                    const T &arg, const Ts &...args) {
557
461
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
461
559
461
    // Recurse to the next argument.
560
461
    return combine(length, buffer_ptr, buffer_end, args...);
561
461
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::Instruction*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::Instruction* const&)
Line
Count
Source
556
264
                    const T &arg, const Ts &...args) {
557
264
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
264
559
264
    // Recurse to the next argument.
560
264
    return combine(length, buffer_ptr, buffer_end, args...);
561
264
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Instruction*>(unsigned long, char*, char*, llvm::Instruction* const&)
Line
Count
Source
556
264
                    const T &arg, const Ts &...args) {
557
264
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
558
264
559
264
    // Recurse to the next argument.
560
264
    return combine(length, buffer_ptr, buffer_end, args...);
561
264
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Type*, llvm::hash_code>(unsigned long, char*, char*, unsigned int const&, llvm::Type* const&, llvm::hash_code const&)
Line
Count
Source
556
22.1M
                    const T &arg, const Ts &...args) {
557
22