Coverage Report

Created: 2019-01-21 03:01

/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
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file implements the newly proposed standard C++ interfaces for hashing
10
// arbitrary data and building hash functions for user-defined types. This
11
// interface was originally proposed in N3333[1] and is currently under review
12
// for inclusion in a future TR and/or standard.
13
//
14
// The primary interfaces provide are comprised of one type and three functions:
15
//
16
//  -- 'hash_code' class is an opaque type representing the hash code for some
17
//     data. It is the intended product of hashing, and can be used to implement
18
//     hash tables, checksumming, and other common uses of hashes. It is not an
19
//     integer type (although it can be converted to one) because it is risky
20
//     to assume much about the internals of a hash_code. In particular, each
21
//     execution of the program has a high probability of producing a different
22
//     hash_code for a given input. Thus their values are not stable to save or
23
//     persist, and should only be used during the execution for the
24
//     construction of hashing datastructures.
25
//
26
//  -- 'hash_value' is a function designed to be overloaded for each
27
//     user-defined type which wishes to be used within a hashing context. It
28
//     should be overloaded within the user-defined type's namespace and found
29
//     via ADL. Overloads for primitive types are provided by this library.
30
//
31
//  -- 'hash_combine' and 'hash_combine_range' are functions designed to aid
32
//      programmers in easily and intuitively combining a set of data into
33
//      a single hash_code for their object. They should only logically be used
34
//      within the implementation of a 'hash_value' routine or similar context.
35
//
36
// Note that 'hash_combine_range' contains very special logic for hashing
37
// a contiguous array of integers or pointers. This logic is *extremely* fast,
38
// on a modern Intel "Gainestown" Xeon (Nehalem uarch) @2.2 GHz, these were
39
// benchmarked at over 6.5 GiB/s for large keys, and <20 cycles/hash for keys
40
// under 32-bytes.
41
//
42
//===----------------------------------------------------------------------===//
43
44
#ifndef LLVM_ADT_HASHING_H
45
#define LLVM_ADT_HASHING_H
46
47
#include "llvm/Support/DataTypes.h"
48
#include "llvm/Support/Host.h"
49
#include "llvm/Support/SwapByteOrder.h"
50
#include "llvm/Support/type_traits.h"
51
#include <algorithm>
52
#include <cassert>
53
#include <cstring>
54
#include <string>
55
#include <utility>
56
57
namespace llvm {
58
59
/// An opaque object representing a hash code.
60
///
61
/// This object represents the result of hashing some entity. It is intended to
62
/// be used to implement hashtables or other hashing-based data structures.
63
/// While it wraps and exposes a numeric value, this value should not be
64
/// trusted to be stable or predictable across processes or executions.
65
///
66
/// In order to obtain the hash_code for an object 'x':
67
/// \code
68
///   using llvm::hash_value;
69
///   llvm::hash_code code = hash_value(x);
70
/// \endcode
71
0
class hash_code {
72
  size_t value;
73
74
public:
75
  /// Default construct a hash_code.
76
  /// Note that this leaves the value uninitialized.
77
  hash_code() = default;
78
79
  /// Form a hash code directly from a numerical value.
80
1.20G
  hash_code(size_t value) : value(value) {}
81
82
  /// Convert the hash code to its numerical value for use.
83
1.10G
  /*explicit*/ operator size_t() const { return value; }
84
85
  friend bool operator==(const hash_code &lhs, const hash_code &rhs) {
86
    return lhs.value == rhs.value;
87
  }
88
76.6k
  friend bool operator!=(const hash_code &lhs, const hash_code &rhs) {
89
76.6k
    return lhs.value != rhs.value;
90
76.6k
  }
91
92
  /// Allow a hash_code to be directly run through hash_value.
93
99.9M
  friend size_t hash_value(const hash_code &code) { return code.value; }
94
};
95
96
/// Compute a hash_code for any integer value.
97
///
98
/// Note that this function is intended to compute the same hash_code for
99
/// a particular value without regard to the pre-promotion type. This is in
100
/// contrast to hash_combine which may produce different hash_codes for
101
/// differing argument types even if they would implicit promote to a common
102
/// type without changing the value.
103
template <typename T>
104
typename std::enable_if<is_integral_or_enum<T>::value, hash_code>::type
105
hash_value(T value);
106
107
/// Compute a hash_code for a pointer's address.
108
///
109
/// N.B.: This hashes the *address*. Not the value and not the type.
110
template <typename T> hash_code hash_value(const T *ptr);
111
112
/// Compute a hash_code for a pair of objects.
113
template <typename T, typename U>
114
hash_code hash_value(const std::pair<T, U> &arg);
115
116
/// Compute a hash_code for a standard string.
117
template <typename T>
118
hash_code hash_value(const std::basic_string<T> &arg);
119
120
121
/// Override the execution seed with a fixed value.
122
///
123
/// This hashing library uses a per-execution seed designed to change on each
124
/// run with high probability in order to ensure that the hash codes are not
125
/// attackable and to ensure that output which is intended to be stable does
126
/// not rely on the particulars of the hash codes produced.
127
///
128
/// That said, there are use cases where it is important to be able to
129
/// reproduce *exactly* a specific behavior. To that end, we provide a function
130
/// which will forcibly set the seed to a fixed value. This must be done at the
131
/// start of the program, before any hashes are computed. Also, it cannot be
132
/// undone. This makes it thread-hostile and very hard to use outside of
133
/// immediately on start of a simple program designed for reproducible
134
/// behavior.
135
void set_fixed_execution_hash_seed(uint64_t fixed_value);
136
137
138
// All of the implementation details of actually computing the various hash
139
// code values are held within this namespace. These routines are included in
140
// the header file mainly to allow inlining and constant propagation.
141
namespace hashing {
142
namespace detail {
143
144
4.32G
inline uint64_t fetch64(const char *p) {
145
4.32G
  uint64_t result;
146
4.32G
  memcpy(&result, p, sizeof(result));
147
4.32G
  if (sys::IsBigEndianHost)
148
0
    sys::swapByteOrder(result);
149
4.32G
  return result;
150
4.32G
}
151
152
653M
inline uint32_t fetch32(const char *p) {
153
653M
  uint32_t result;
154
653M
  memcpy(&result, p, sizeof(result));
155
653M
  if (sys::IsBigEndianHost)
156
0
    sys::swapByteOrder(result);
157
653M
  return result;
158
653M
}
159
160
/// Some primes between 2^63 and 2^64 for various uses.
161
static const uint64_t k0 = 0xc3a5c85c97cb3127ULL;
162
static const uint64_t k1 = 0xb492b66fbe98f273ULL;
163
static const uint64_t k2 = 0x9ae16a3b2f90404fULL;
164
static const uint64_t k3 = 0xc949d7c7509e6557ULL;
165
166
/// Bitwise right rotate.
167
/// Normally this will compile to a single instruction, especially if the
168
/// shift is a manifest constant.
169
2.98G
inline uint64_t rotate(uint64_t val, size_t shift) {
170
2.98G
  // Avoid shifting by 64: doing so yields an undefined result.
171
2.98G
  return shift == 0 ? 
val0
: ((val >> shift) | (val << (64 - shift)));
172
2.98G
}
173
174
302M
inline uint64_t shift_mix(uint64_t val) {
175
302M
  return val ^ (val >> 47);
176
302M
}
177
178
1.18G
inline uint64_t hash_16_bytes(uint64_t low, uint64_t high) {
179
1.18G
  // Murmur-inspired hashing.
180
1.18G
  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
181
1.18G
  uint64_t a = (low ^ high) * kMul;
182
1.18G
  a ^= (a >> 47);
183
1.18G
  uint64_t b = (high ^ a) * kMul;
184
1.18G
  b ^= (b >> 47);
185
1.18G
  b *= kMul;
186
1.18G
  return b;
187
1.18G
}
188
189
1.52M
inline uint64_t hash_1to3_bytes(const char *s, size_t len, uint64_t seed) {
190
1.52M
  uint8_t a = s[0];
191
1.52M
  uint8_t b = s[len >> 1];
192
1.52M
  uint8_t c = s[len - 1];
193
1.52M
  uint32_t y = static_cast<uint32_t>(a) + (static_cast<uint32_t>(b) << 8);
194
1.52M
  uint32_t z = len + (static_cast<uint32_t>(c) << 2);
195
1.52M
  return shift_mix(y * k2 ^ z * k3 ^ seed) * k2;
196
1.52M
}
197
198
326M
inline uint64_t hash_4to8_bytes(const char *s, size_t len, uint64_t seed) {
199
326M
  uint64_t a = fetch32(s);
200
326M
  return hash_16_bytes(len + (a << 3), seed ^ fetch32(s + len - 4));
201
326M
}
202
203
339M
inline uint64_t hash_9to16_bytes(const char *s, size_t len, uint64_t seed) {
204
339M
  uint64_t a = fetch64(s);
205
339M
  uint64_t b = fetch64(s + len - 8);
206
339M
  return hash_16_bytes(seed ^ a, rotate(b + len, len)) ^ b;
207
339M
}
208
209
384M
inline uint64_t hash_17to32_bytes(const char *s, size_t len, uint64_t seed) {
210
384M
  uint64_t a = fetch64(s) * k1;
211
384M
  uint64_t b = fetch64(s + 8);
212
384M
  uint64_t c = fetch64(s + len - 8) * k2;
213
384M
  uint64_t d = fetch64(s + len - 16) * k0;
214
384M
  return hash_16_bytes(rotate(a - b, 43) + rotate(c ^ seed, 30) + d,
215
384M
                       a + rotate(b ^ k3, 20) - c + len + seed);
216
384M
}
217
218
110M
inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) {
219
110M
  uint64_t z = fetch64(s + 24);
220
110M
  uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0;
221
110M
  uint64_t b = rotate(a + z, 52);
222
110M
  uint64_t c = rotate(a, 37);
223
110M
  a += fetch64(s + 8);
224
110M
  c += rotate(a, 7);
225
110M
  a += fetch64(s + 16);
226
110M
  uint64_t vf = a + z;
227
110M
  uint64_t vs = b + rotate(a, 31) + c;
228
110M
  a = fetch64(s + 16) + fetch64(s + len - 32);
229
110M
  z = fetch64(s + len - 8);
230
110M
  b = rotate(a + z, 52);
231
110M
  c = rotate(a, 37);
232
110M
  a += fetch64(s + len - 24);
233
110M
  c += rotate(a, 7);
234
110M
  a += fetch64(s + len - 16);
235
110M
  uint64_t wf = a + z;
236
110M
  uint64_t ws = b + rotate(a, 31) + c;
237
110M
  uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0);
238
110M
  return shift_mix((seed ^ (r * k0)) + vs) * k2;
239
110M
}
240
241
1.18G
inline uint64_t hash_short(const char *s, size_t length, uint64_t seed) {
242
1.18G
  if (length >= 4 && 
length <= 81.16G
)
243
326M
    return hash_4to8_bytes(s, length, seed);
244
855M
  if (length > 8 && 
length <= 16834M
)
245
339M
    return hash_9to16_bytes(s, length, seed);
246
515M
  if (length > 16 && 
length <= 32494M
)
247
384M
    return hash_17to32_bytes(s, length, seed);
248
131M
  if (length > 32)
249
110M
    return hash_33to64_bytes(s, length, seed);
250
20.8M
  if (length != 0)
251
1.52M
    return hash_1to3_bytes(s, length, seed);
252
19.2M
253
19.2M
  return k2 ^ seed;
254
19.2M
}
255
256
/// The intermediate state used during hashing.
257
/// Currently, the algorithm for computing hash codes is based on CityHash and
258
/// keeps 56 bytes of arbitrary state.
259
0
struct hash_state {
260
  uint64_t h0, h1, h2, h3, h4, h5, h6;
261
262
  /// Create a new hash_state structure and initialize it based on the
263
  /// seed and the first 64-byte chunk.
264
  /// This effectively performs the initial mix.
265
26.7M
  static hash_state create(const char *s, uint64_t seed) {
266
26.7M
    hash_state state = {
267
26.7M
      0, seed, hash_16_bytes(seed, k1), rotate(seed ^ k1, 49),
268
26.7M
      seed * k1, shift_mix(seed), 0 };
269
26.7M
    state.h6 = hash_16_bytes(state.h4, state.h5);
270
26.7M
    state.mix(s);
271
26.7M
    return state;
272
26.7M
  }
273
274
  /// Mix 32-bytes from the input sequence into the 16-bytes of 'a'
275
  /// and 'b', including whatever is already in 'a' and 'b'.
276
166M
  static void mix_32_bytes(const char *s, uint64_t &a, uint64_t &b) {
277
166M
    a += fetch64(s);
278
166M
    uint64_t c = fetch64(s + 24);
279
166M
    b = rotate(b + a + c, 21);
280
166M
    uint64_t d = a;
281
166M
    a += fetch64(s + 8) + fetch64(s + 16);
282
166M
    b += rotate(a, 44) + d;
283
166M
    a += c;
284
166M
  }
285
286
  /// Mix in a 64-byte buffer of data.
287
  /// We mix all 64 bytes even when the chunk length is smaller, but we
288
  /// record the actual length.
289
83.2M
  void mix(const char *s) {
290
83.2M
    h0 = rotate(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
291
83.2M
    h1 = rotate(h1 + h4 + fetch64(s + 48), 42) * k1;
292
83.2M
    h0 ^= h6;
293
83.2M
    h1 += h3 + fetch64(s + 40);
294
83.2M
    h2 = rotate(h2 + h5, 33) * k1;
295
83.2M
    h3 = h4 * k1;
296
83.2M
    h4 = h0 + h5;
297
83.2M
    mix_32_bytes(s, h3, h4);
298
83.2M
    h5 = h2 + h6;
299
83.2M
    h6 = h1 + fetch64(s + 16);
300
83.2M
    mix_32_bytes(s + 32, h5, h6);
301
83.2M
    std::swap(h2, h0);
302
83.2M
  }
303
304
  /// Compute the final 64-bit hash code value based on the current
305
  /// state and the length of bytes hashed.
306
26.7M
  uint64_t finalize(size_t length) {
307
26.7M
    return hash_16_bytes(hash_16_bytes(h3, h5) + shift_mix(h1) * k1 + h2,
308
26.7M
                         hash_16_bytes(h4, h6) + shift_mix(length) * k1 + h0);
309
26.7M
  }
310
};
311
312
313
/// A global, fixed seed-override variable.
314
///
315
/// This variable can be set using the \see llvm::set_fixed_execution_seed
316
/// function. See that function for details. Do not, under any circumstances,
317
/// set or read this variable.
318
extern uint64_t fixed_seed_override;
319
320
1.20G
inline uint64_t get_execution_seed() {
321
1.20G
  // FIXME: This needs to be a per-execution seed. This is just a placeholder
322
1.20G
  // implementation. Switching to a per-execution seed is likely to flush out
323
1.20G
  // instability bugs and so will happen as its own commit.
324
1.20G
  //
325
1.20G
  // However, if there is a fixed seed override set the first time this is
326
1.20G
  // called, return that instead of the per-execution seed.
327
1.20G
  const uint64_t seed_prime = 0xff51afd7ed558ccdULL;
328
1.20G
  static uint64_t seed = fixed_seed_override ? 
fixed_seed_override0
: seed_prime;
329
1.20G
  return seed;
330
1.20G
}
331
332
333
/// Trait to indicate whether a type's bits can be hashed directly.
334
///
335
/// A type trait which is true if we want to combine values for hashing by
336
/// reading the underlying data. It is false if values of this type must
337
/// first be passed to hash_value, and the resulting hash_codes combined.
338
//
339
// FIXME: We want to replace is_integral_or_enum and is_pointer here with
340
// a predicate which asserts that comparing the underlying storage of two
341
// values of the type for equality is equivalent to comparing the two values
342
// for equality. For all the platforms we care about, this holds for integers
343
// and pointers, but there are platforms where it doesn't and we would like to
344
// support user-defined types which happen to satisfy this property.
345
template <typename T> struct is_hashable_data
346
  : std::integral_constant<bool, ((is_integral_or_enum<T>::value ||
347
                                   std::is_pointer<T>::value) &&
348
                                  64 % sizeof(T) == 0)> {};
349
350
// Special case std::pair to detect when both types are viable and when there
351
// is no alignment-derived padding in the pair. This is a bit of a lie because
352
// std::pair isn't truly POD, but it's close enough in all reasonable
353
// implementations for our use case of hashing the underlying data.
354
template <typename T, typename U> struct is_hashable_data<std::pair<T, U> >
355
  : std::integral_constant<bool, (is_hashable_data<T>::value &&
356
                                  is_hashable_data<U>::value &&
357
                                  (sizeof(T) + sizeof(U)) ==
358
                                   sizeof(std::pair<T, U>))> {};
359
360
/// Helper to get the hashable data representation for a type.
361
/// This variant is enabled when the type itself can be used.
362
template <typename T>
363
typename std::enable_if<is_hashable_data<T>::value, T>::type
364
998M
get_hashable_data(const T &value) {
365
998M
  return value;
366
998M
}
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
364
269M
get_hashable_data(const T &value) {
365
269M
  return value;
366
269M
}
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
364
1.76k
get_hashable_data(const T &value) {
365
1.76k
  return value;
366
1.76k
}
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
364
3.52k
get_hashable_data(const T &value) {
365
3.52k
  return value;
366
3.52k
}
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
364
273
get_hashable_data(const T &value) {
365
273
  return value;
366
273
}
std::__1::enable_if<is_hashable_data<bool>::value, bool>::type llvm::hashing::detail::get_hashable_data<bool>(bool const&)
Line
Count
Source
364
71.2M
get_hashable_data(const T &value) {
365
71.2M
  return value;
366
71.2M
}
std::__1::enable_if<is_hashable_data<int>::value, int>::type llvm::hashing::detail::get_hashable_data<int>(int const&)
Line
Count
Source
364
1.08M
get_hashable_data(const T &value) {
365
1.08M
  return value;
366
1.08M
}
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
364
6.03k
get_hashable_data(const T &value) {
365
6.03k
  return value;
366
6.03k
}
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
364
3.83M
get_hashable_data(const T &value) {
365
3.83M
  return value;
366
3.83M
}
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
364
394
get_hashable_data(const T &value) {
365
394
  return value;
366
394
}
std::__1::enable_if<is_hashable_data<llvm::MCSymbol*>::value, llvm::MCSymbol*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol*>(llvm::MCSymbol* const&)
Line
Count
Source
364
247
get_hashable_data(const T &value) {
365
247
  return value;
366
247
}
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
364
1.71M
get_hashable_data(const T &value) {
365
1.71M
  return value;
366
1.71M
}
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
364
73.7M
get_hashable_data(const T &value) {
365
73.7M
  return value;
366
73.7M
}
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
364
26.6M
get_hashable_data(const T &value) {
365
26.6M
  return value;
366
26.6M
}
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
364
15
get_hashable_data(const T &value) {
365
15
  return value;
366
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
364
774
get_hashable_data(const T &value) {
365
774
  return value;
366
774
}
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
364
18
get_hashable_data(const T &value) {
365
18
  return value;
366
18
}
Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::MDNode const*>::value, llvm::MDNode const*>::type llvm::hashing::detail::get_hashable_data<llvm::MDNode const*>(llvm::MDNode const* const&)
Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::Intrinsic::ID>::value, llvm::Intrinsic::ID>::type llvm::hashing::detail::get_hashable_data<llvm::Intrinsic::ID>(llvm::Intrinsic::ID const&)
std::__1::enable_if<is_hashable_data<llvm::InlineAsm::AsmDialect>::value, llvm::InlineAsm::AsmDialect>::type llvm::hashing::detail::get_hashable_data<llvm::InlineAsm::AsmDialect>(llvm::InlineAsm::AsmDialect const&)
Line
Count
Source
364
25.3k
get_hashable_data(const T &value) {
365
25.3k
  return value;
366
25.3k
}
std::__1::enable_if<is_hashable_data<llvm::FunctionType*>::value, llvm::FunctionType*>::type llvm::hashing::detail::get_hashable_data<llvm::FunctionType*>(llvm::FunctionType* const&)
Line
Count
Source
364
25.3k
get_hashable_data(const T &value) {
365
25.3k
  return value;
366
25.3k
}
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
364
37.4M
get_hashable_data(const T &value) {
365
37.4M
  return value;
366
37.4M
}
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
364
17.5M
get_hashable_data(const T &value) {
365
17.5M
  return value;
366
17.5M
}
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
364
7.07M
get_hashable_data(const T &value) {
365
7.07M
  return value;
366
7.07M
}
std::__1::enable_if<is_hashable_data<llvm::Metadata*>::value, llvm::Metadata*>::type llvm::hashing::detail::get_hashable_data<llvm::Metadata*>(llvm::Metadata* const&)
Line
Count
Source
364
31.0M
get_hashable_data(const T &value) {
365
31.0M
  return value;
366
31.0M
}
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
364
206k
get_hashable_data(const T &value) {
365
206k
  return value;
366
206k
}
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
364
233M
get_hashable_data(const T &value) {
365
233M
  return value;
366
233M
}
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
364
60.1k
get_hashable_data(const T &value) {
365
60.1k
  return value;
366
60.1k
}
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
364
197k
get_hashable_data(const T &value) {
365
197k
  return value;
366
197k
}
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
364
220k
get_hashable_data(const T &value) {
365
220k
  return value;
366
220k
}
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
364
47.1M
get_hashable_data(const T &value) {
365
47.1M
  return value;
366
47.1M
}
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
364
25.3k
get_hashable_data(const T &value) {
365
25.3k
  return value;
366
25.3k
}
std::__1::enable_if<is_hashable_data<char>::value, char>::type llvm::hashing::detail::get_hashable_data<char>(char const&)
Line
Count
Source
364
496k
get_hashable_data(const T &value) {
365
496k
  return value;
366
496k
}
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
364
1.14k
get_hashable_data(const T &value) {
365
1.14k
  return value;
366
1.14k
}
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
364
130M
get_hashable_data(const T &value) {
365
130M
  return value;
366
130M
}
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
364
466
get_hashable_data(const T &value) {
365
466
  return value;
366
466
}
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
364
277
get_hashable_data(const T &value) {
365
277
  return value;
366
277
}
std::__1::enable_if<is_hashable_data<llvm::MCSymbol const*>::value, llvm::MCSymbol const*>::type llvm::hashing::detail::get_hashable_data<llvm::MCSymbol const*>(llvm::MCSymbol const* const&)
Line
Count
Source
364
29.7k
get_hashable_data(const T &value) {
365
29.7k
  return value;
366
29.7k
}
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
364
7.41M
get_hashable_data(const T &value) {
365
7.41M
  return value;
366
7.41M
}
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
364
12.6M
get_hashable_data(const T &value) {
365
12.6M
  return value;
366
12.6M
}
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
364
230k
get_hashable_data(const T &value) {
365
230k
  return value;
366
230k
}
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
364
8.26M
get_hashable_data(const T &value) {
365
8.26M
  return value;
366
8.26M
}
std::__1::enable_if<is_hashable_data<short>::value, short>::type llvm::hashing::detail::get_hashable_data<short>(short const&)
Line
Count
Source
364
1.00M
get_hashable_data(const T &value) {
365
1.00M
  return value;
366
1.00M
}
Unexecuted instantiation: std::__1::enable_if<is_hashable_data<llvm::fltSemantics const*>::value, llvm::fltSemantics const*>::type llvm::hashing::detail::get_hashable_data<llvm::fltSemantics const*>(llvm::fltSemantics const* const&)
std::__1::enable_if<is_hashable_data<llvm::Value const*>::value, llvm::Value const*>::type llvm::hashing::detail::get_hashable_data<llvm::Value const*>(llvm::Value const* const&)
Line
Count
Source
364
693k
get_hashable_data(const T &value) {
365
693k
  return value;
366
693k
}
std::__1::enable_if<is_hashable_data<void*>::value, void*>::type llvm::hashing::detail::get_hashable_data<void*>(void* const&)
Line
Count
Source
364
44.9k
get_hashable_data(const T &value) {
365
44.9k
  return value;
366
44.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
364
909
get_hashable_data(const T &value) {
365
909
  return value;
366
909
}
std::__1::enable_if<is_hashable_data<long>::value, long>::type llvm::hashing::detail::get_hashable_data<long>(long const&)
Line
Count
Source
364
61.8k
get_hashable_data(const T &value) {
365
61.8k
  return value;
366
61.8k
}
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
364
14.0M
get_hashable_data(const T &value) {
365
14.0M
  return value;
366
14.0M
}
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
364
1
get_hashable_data(const T &value) {
365
1
  return value;
366
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
364
659
get_hashable_data(const T &value) {
365
659
  return value;
366
659
}
std::__1::enable_if<is_hashable_data<llvm::wasm::ValType>::value, llvm::wasm::ValType>::type llvm::hashing::detail::get_hashable_data<llvm::wasm::ValType>(llvm::wasm::ValType const&)
Line
Count
Source
364
634
get_hashable_data(const T &value) {
365
634
  return value;
366
634
}
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
364
54
get_hashable_data(const T &value) {
365
54
  return value;
366
54
}
367
/// Helper to get the hashable data representation for a type.
368
/// This variant is enabled when we must first call hash_value and use the
369
/// result as our data.
370
template <typename T>
371
typename std::enable_if<!is_hashable_data<T>::value, size_t>::type
372
100M
get_hashable_data(const T &value) {
373
100M
  using ::llvm::hash_value;
374
100M
  return hash_value(value);
375
100M
}
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
372
99.9M
get_hashable_data(const T &value) {
373
99.9M
  using ::llvm::hash_value;
374
99.9M
  return hash_value(value);
375
99.9M
}
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
372
346k
get_hashable_data(const T &value) {
373
346k
  using ::llvm::hash_value;
374
346k
  return hash_value(value);
375
346k
}
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
372
51.4k
get_hashable_data(const T &value) {
373
51.4k
  using ::llvm::hash_value;
374
51.4k
  return hash_value(value);
375
51.4k
}
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
372
18.5k
get_hashable_data(const T &value) {
373
18.5k
  using ::llvm::hash_value;
374
18.5k
  return hash_value(value);
375
18.5k
}
376
377
/// Helper to store data from a value into a buffer and advance the
378
/// pointer into that buffer.
379
///
380
/// This routine first checks whether there is enough space in the provided
381
/// buffer, and if not immediately returns false. If there is space, it
382
/// copies the underlying bytes of value into the buffer, advances the
383
/// buffer_ptr past the copied bytes, and returns true.
384
template <typename T>
385
bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value,
386
1.13G
                       size_t offset = 0) {
387
1.13G
  size_t store_size = sizeof(value) - offset;
388
1.13G
  if (buffer_ptr + store_size > buffer_end)
389
4.62M
    return false;
390
1.13G
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.13G
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.13G
  buffer_ptr += store_size;
393
1.13G
  return true;
394
1.13G
}
bool llvm::hashing::detail::store_and_advance<unsigned int>(char*&, char*, unsigned int const&, unsigned long)
Line
Count
Source
386
269M
                       size_t offset = 0) {
387
269M
  size_t store_size = sizeof(value) - offset;
388
269M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
269M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
269M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
269M
  buffer_ptr += store_size;
393
269M
  return true;
394
269M
}
bool llvm::hashing::detail::store_and_advance<unsigned long>(char*&, char*, unsigned long const&, unsigned long)
Line
Count
Source
386
100M
                       size_t offset = 0) {
387
100M
  size_t store_size = sizeof(value) - offset;
388
100M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
100M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
100M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
100M
  buffer_ptr += store_size;
393
100M
  return true;
394
100M
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::CounterExpression::ExprKind>(char*&, char*, llvm::coverage::CounterExpression::ExprKind const&, unsigned long)
Line
Count
Source
386
1.76k
                       size_t offset = 0) {
387
1.76k
  size_t store_size = sizeof(value) - offset;
388
1.76k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
1.76k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.76k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.76k
  buffer_ptr += store_size;
393
1.76k
  return true;
394
1.76k
}
bool llvm::hashing::detail::store_and_advance<llvm::coverage::Counter::CounterKind>(char*&, char*, llvm::coverage::Counter::CounterKind const&, unsigned long)
Line
Count
Source
386
3.52k
                       size_t offset = 0) {
387
3.52k
  size_t store_size = sizeof(value) - offset;
388
3.52k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
3.52k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
3.52k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
3.52k
  buffer_ptr += store_size;
393
3.52k
  return true;
394
3.52k
}
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
386
273
                       size_t offset = 0) {
387
273
  size_t store_size = sizeof(value) - offset;
388
273
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
273
  const char *value_data = reinterpret_cast<const char *>(&value);
391
273
  memcpy(buffer_ptr, value_data + offset, store_size);
392
273
  buffer_ptr += store_size;
393
273
  return true;
394
273
}
bool llvm::hashing::detail::store_and_advance<bool>(char*&, char*, bool const&, unsigned long)
Line
Count
Source
386
71.2M
                       size_t offset = 0) {
387
71.2M
  size_t store_size = sizeof(value) - offset;
388
71.2M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
71.2M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
71.2M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
71.2M
  buffer_ptr += store_size;
393
71.2M
  return true;
394
71.2M
}
bool llvm::hashing::detail::store_and_advance<int>(char*&, char*, int const&, unsigned long)
Line
Count
Source
386
1.08M
                       size_t offset = 0) {
387
1.08M
  size_t store_size = sizeof(value) - offset;
388
1.08M
  if (buffer_ptr + store_size > buffer_end)
389
4
    return false;
390
1.08M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.08M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.08M
  buffer_ptr += store_size;
393
1.08M
  return true;
394
1.08M
}
bool llvm::hashing::detail::store_and_advance<char const*>(char*&, char*, char const* const&, unsigned long)
Line
Count
Source
386
6.03k
                       size_t offset = 0) {
387
6.03k
  size_t store_size = sizeof(value) - offset;
388
6.03k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
6.03k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
6.03k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
6.03k
  buffer_ptr += store_size;
393
6.03k
  return true;
394
6.03k
}
bool llvm::hashing::detail::store_and_advance<llvm::GlobalValue const*>(char*&, char*, llvm::GlobalValue const* const&, unsigned long)
Line
Count
Source
386
3.83M
                       size_t offset = 0) {
387
3.83M
  size_t store_size = sizeof(value) - offset;
388
3.83M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
3.83M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
3.83M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
3.83M
  buffer_ptr += store_size;
393
3.83M
  return true;
394
3.83M
}
bool llvm::hashing::detail::store_and_advance<llvm::BlockAddress const*>(char*&, char*, llvm::BlockAddress const* const&, unsigned long)
Line
Count
Source
386
394
                       size_t offset = 0) {
387
394
  size_t store_size = sizeof(value) - offset;
388
394
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
394
  const char *value_data = reinterpret_cast<const char *>(&value);
391
394
  memcpy(buffer_ptr, value_data + offset, store_size);
392
394
  buffer_ptr += store_size;
393
394
  return true;
394
394
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol*>(char*&, char*, llvm::MCSymbol* const&, unsigned long)
Line
Count
Source
386
247
                       size_t offset = 0) {
387
247
  size_t store_size = sizeof(value) - offset;
388
247
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
247
  const char *value_data = reinterpret_cast<const char *>(&value);
391
247
  memcpy(buffer_ptr, value_data + offset, store_size);
392
247
  buffer_ptr += store_size;
393
247
  return true;
394
247
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineBasicBlock*>(char*&, char*, llvm::MachineBasicBlock* const&, unsigned long)
Line
Count
Source
386
1.71M
                       size_t offset = 0) {
387
1.71M
  size_t store_size = sizeof(value) - offset;
388
1.71M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
1.71M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.71M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.71M
  buffer_ptr += store_size;
393
1.71M
  return true;
394
1.71M
}
bool llvm::hashing::detail::store_and_advance<llvm::MachineOperand::MachineOperandType>(char*&, char*, llvm::MachineOperand::MachineOperandType const&, unsigned long)
Line
Count
Source
386
73.7M
                       size_t offset = 0) {
387
73.7M
  size_t store_size = sizeof(value) - offset;
388
73.7M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
73.7M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
73.7M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
73.7M
  buffer_ptr += store_size;
393
73.7M
  return true;
394
73.7M
}
bool llvm::hashing::detail::store_and_advance<long long>(char*&, char*, long long const&, unsigned long)
Line
Count
Source
386
26.6M
                       size_t offset = 0) {
387
26.6M
  size_t store_size = sizeof(value) - offset;
388
26.6M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
26.6M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
26.6M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
26.6M
  buffer_ptr += store_size;
393
26.6M
  return true;
394
26.6M
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantInt const*>(char*&, char*, llvm::ConstantInt const* const&, unsigned long)
Line
Count
Source
386
15
                       size_t offset = 0) {
387
15
  size_t store_size = sizeof(value) - offset;
388
15
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
15
  const char *value_data = reinterpret_cast<const char *>(&value);
391
15
  memcpy(buffer_ptr, value_data + offset, store_size);
392
15
  buffer_ptr += store_size;
393
15
  return true;
394
15
}
bool llvm::hashing::detail::store_and_advance<llvm::ConstantFP const*>(char*&, char*, llvm::ConstantFP const* const&, unsigned long)
Line
Count
Source
386
774
                       size_t offset = 0) {
387
774
  size_t store_size = sizeof(value) - offset;
388
774
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
774
  const char *value_data = reinterpret_cast<const char *>(&value);
391
774
  memcpy(buffer_ptr, value_data + offset, store_size);
392
774
  buffer_ptr += store_size;
393
774
  return true;
394
774
}
bool llvm::hashing::detail::store_and_advance<unsigned int const*>(char*&, char*, unsigned int const* const&, unsigned long)
Line
Count
Source
386
18
                       size_t offset = 0) {
387
18
  size_t store_size = sizeof(value) - offset;
388
18
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
18
  const char *value_data = reinterpret_cast<const char *>(&value);
391
18
  memcpy(buffer_ptr, value_data + offset, store_size);
392
18
  buffer_ptr += store_size;
393
18
  return true;
394
18
}
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::MDNode const*>(char*&, char*, llvm::MDNode const* const&, unsigned long)
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::Intrinsic::ID>(char*&, char*, llvm::Intrinsic::ID const&, unsigned long)
bool llvm::hashing::detail::store_and_advance<llvm::InlineAsm::AsmDialect>(char*&, char*, llvm::InlineAsm::AsmDialect const&, unsigned long)
Line
Count
Source
386
25.3k
                       size_t offset = 0) {
387
25.3k
  size_t store_size = sizeof(value) - offset;
388
25.3k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
25.3k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
25.3k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
25.3k
  buffer_ptr += store_size;
393
25.3k
  return true;
394
25.3k
}
bool llvm::hashing::detail::store_and_advance<llvm::FunctionType*>(char*&, char*, llvm::FunctionType* const&, unsigned long)
Line
Count
Source
386
25.3k
                       size_t offset = 0) {
387
25.3k
  size_t store_size = sizeof(value) - offset;
388
25.3k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
25.3k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
25.3k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
25.3k
  buffer_ptr += store_size;
393
25.3k
  return true;
394
25.3k
}
bool llvm::hashing::detail::store_and_advance<unsigned char>(char*&, char*, unsigned char const&, unsigned long)
Line
Count
Source
386
37.4M
                       size_t offset = 0) {
387
37.4M
  size_t store_size = sizeof(value) - offset;
388
37.4M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
37.4M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
37.4M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
37.4M
  buffer_ptr += store_size;
393
37.4M
  return true;
394
37.4M
}
bool llvm::hashing::detail::store_and_advance<unsigned short>(char*&, char*, unsigned short const&, unsigned long)
Line
Count
Source
386
17.5M
                       size_t offset = 0) {
387
17.5M
  size_t store_size = sizeof(value) - offset;
388
17.5M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
17.5M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
17.5M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
17.5M
  buffer_ptr += store_size;
393
17.5M
  return true;
394
17.5M
}
bool llvm::hashing::detail::store_and_advance<llvm::Type const*>(char*&, char*, llvm::Type const* const&, unsigned long)
Line
Count
Source
386
7.07M
                       size_t offset = 0) {
387
7.07M
  size_t store_size = sizeof(value) - offset;
388
7.07M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
7.07M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
7.07M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
7.07M
  buffer_ptr += store_size;
393
7.07M
  return true;
394
7.07M
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata*>(char*&, char*, llvm::Metadata* const&, unsigned long)
Line
Count
Source
386
31.0M
                       size_t offset = 0) {
387
31.0M
  size_t store_size = sizeof(value) - offset;
388
31.0M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
31.0M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
31.0M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
31.0M
  buffer_ptr += store_size;
393
31.0M
  return true;
394
31.0M
}
bool llvm::hashing::detail::store_and_advance<llvm::MDString*>(char*&, char*, llvm::MDString* const&, unsigned long)
Line
Count
Source
386
206k
                       size_t offset = 0) {
387
206k
  size_t store_size = sizeof(value) - offset;
388
206k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
206k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
206k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
206k
  buffer_ptr += store_size;
393
206k
  return true;
394
206k
}
bool llvm::hashing::detail::store_and_advance<unsigned long long>(char*&, char*, unsigned long long const&, unsigned long)
Line
Count
Source
386
233M
                       size_t offset = 0) {
387
233M
  size_t store_size = sizeof(value) - offset;
388
233M
  if (buffer_ptr + store_size > buffer_end)
389
2
    return false;
390
233M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
233M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
233M
  buffer_ptr += store_size;
393
233M
  return true;
394
233M
}
bool llvm::hashing::detail::store_and_advance<llvm::ArrayType*>(char*&, char*, llvm::ArrayType* const&, unsigned long)
Line
Count
Source
386
60.1k
                       size_t offset = 0) {
387
60.1k
  size_t store_size = sizeof(value) - offset;
388
60.1k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
60.1k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
60.1k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
60.1k
  buffer_ptr += store_size;
393
60.1k
  return true;
394
60.1k
}
bool llvm::hashing::detail::store_and_advance<llvm::StructType*>(char*&, char*, llvm::StructType* const&, unsigned long)
Line
Count
Source
386
197k
                       size_t offset = 0) {
387
197k
  size_t store_size = sizeof(value) - offset;
388
197k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
197k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
197k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
197k
  buffer_ptr += store_size;
393
197k
  return true;
394
197k
}
bool llvm::hashing::detail::store_and_advance<llvm::VectorType*>(char*&, char*, llvm::VectorType* const&, unsigned long)
Line
Count
Source
386
220k
                       size_t offset = 0) {
387
220k
  size_t store_size = sizeof(value) - offset;
388
220k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
220k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
220k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
220k
  buffer_ptr += store_size;
393
220k
  return true;
394
220k
}
bool llvm::hashing::detail::store_and_advance<llvm::Type*>(char*&, char*, llvm::Type* const&, unsigned long)
Line
Count
Source
386
47.1M
                       size_t offset = 0) {
387
47.1M
  size_t store_size = sizeof(value) - offset;
388
47.1M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
47.1M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
47.1M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
47.1M
  buffer_ptr += store_size;
393
47.1M
  return true;
394
47.1M
}
bool llvm::hashing::detail::store_and_advance<llvm::PointerType*>(char*&, char*, llvm::PointerType* const&, unsigned long)
Line
Count
Source
386
25.3k
                       size_t offset = 0) {
387
25.3k
  size_t store_size = sizeof(value) - offset;
388
25.3k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
25.3k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
25.3k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
25.3k
  buffer_ptr += store_size;
393
25.3k
  return true;
394
25.3k
}
bool llvm::hashing::detail::store_and_advance<llvm::Metadata const*>(char*&, char*, llvm::Metadata const* const&, unsigned long)
Line
Count
Source
386
37.0M
                       size_t offset = 0) {
387
37.0M
  size_t store_size = sizeof(value) - offset;
388
37.0M
  if (buffer_ptr + store_size > buffer_end)
389
4.09M
    return false;
390
32.9M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
32.9M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
32.9M
  buffer_ptr += store_size;
393
32.9M
  return true;
394
32.9M
}
bool llvm::hashing::detail::store_and_advance<char>(char*&, char*, char const&, unsigned long)
Line
Count
Source
386
496k
                       size_t offset = 0) {
387
496k
  size_t store_size = sizeof(value) - offset;
388
496k
  if (buffer_ptr + store_size > buffer_end)
389
3.90k
    return false;
390
492k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
492k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
492k
  buffer_ptr += store_size;
393
492k
  return true;
394
492k
}
bool llvm::hashing::detail::store_and_advance<llvm::MemoryAccess const*>(char*&, char*, llvm::MemoryAccess const* const&, unsigned long)
Line
Count
Source
386
1.14k
                       size_t offset = 0) {
387
1.14k
  size_t store_size = sizeof(value) - offset;
388
1.14k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
1.14k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.14k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.14k
  buffer_ptr += store_size;
393
1.14k
  return true;
394
1.14k
}
bool llvm::hashing::detail::store_and_advance<llvm::Value*>(char*&, char*, llvm::Value* const&, unsigned long)
Line
Count
Source
386
130M
                       size_t offset = 0) {
387
130M
  size_t store_size = sizeof(value) - offset;
388
130M
  if (buffer_ptr + store_size > buffer_end)
389
521k
    return false;
390
129M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
129M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
129M
  buffer_ptr += store_size;
393
129M
  return true;
394
129M
}
bool llvm::hashing::detail::store_and_advance<llvm::Constant*>(char*&, char*, llvm::Constant* const&, unsigned long)
Line
Count
Source
386
466
                       size_t offset = 0) {
387
466
  size_t store_size = sizeof(value) - offset;
388
466
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
466
  const char *value_data = reinterpret_cast<const char *>(&value);
391
466
  memcpy(buffer_ptr, value_data + offset, store_size);
392
466
  buffer_ptr += store_size;
393
466
  return true;
394
466
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction*>(char*&, char*, llvm::Instruction* const&, unsigned long)
Line
Count
Source
386
277
                       size_t offset = 0) {
387
277
  size_t store_size = sizeof(value) - offset;
388
277
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
277
  const char *value_data = reinterpret_cast<const char *>(&value);
391
277
  memcpy(buffer_ptr, value_data + offset, store_size);
392
277
  buffer_ptr += store_size;
393
277
  return true;
394
277
}
bool llvm::hashing::detail::store_and_advance<llvm::MCSymbol const*>(char*&, char*, llvm::MCSymbol const* const&, unsigned long)
Line
Count
Source
386
29.7k
                       size_t offset = 0) {
387
29.7k
  size_t store_size = sizeof(value) - offset;
388
29.7k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
29.7k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
29.7k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
29.7k
  buffer_ptr += store_size;
393
29.7k
  return true;
394
29.7k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::BinaryOps>(char*&, char*, llvm::Instruction::BinaryOps const&, unsigned long)
Line
Count
Source
386
7.41M
                       size_t offset = 0) {
387
7.41M
  size_t store_size = sizeof(value) - offset;
388
7.41M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
7.41M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
7.41M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
7.41M
  buffer_ptr += store_size;
393
7.41M
  return true;
394
7.41M
}
bool llvm::hashing::detail::store_and_advance<llvm::CmpInst::Predicate>(char*&, char*, llvm::CmpInst::Predicate const&, unsigned long)
Line
Count
Source
386
12.6M
                       size_t offset = 0) {
387
12.6M
  size_t store_size = sizeof(value) - offset;
388
12.6M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
12.6M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
12.6M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
12.6M
  buffer_ptr += store_size;
393
12.6M
  return true;
394
12.6M
}
bool llvm::hashing::detail::store_and_advance<llvm::SelectPatternFlavor>(char*&, char*, llvm::SelectPatternFlavor const&, unsigned long)
Line
Count
Source
386
230k
                       size_t offset = 0) {
387
230k
  size_t store_size = sizeof(value) - offset;
388
230k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
230k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
230k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
230k
  buffer_ptr += store_size;
393
230k
  return true;
394
230k
}
bool llvm::hashing::detail::store_and_advance<llvm::Instruction::CastOps>(char*&, char*, llvm::Instruction::CastOps const&, unsigned long)
Line
Count
Source
386
8.26M
                       size_t offset = 0) {
387
8.26M
  size_t store_size = sizeof(value) - offset;
388
8.26M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
8.26M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
8.26M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
8.26M
  buffer_ptr += store_size;
393
8.26M
  return true;
394
8.26M
}
bool llvm::hashing::detail::store_and_advance<short>(char*&, char*, short const&, unsigned long)
Line
Count
Source
386
1.00M
                       size_t offset = 0) {
387
1.00M
  size_t store_size = sizeof(value) - offset;
388
1.00M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
1.00M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1.00M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1.00M
  buffer_ptr += store_size;
393
1.00M
  return true;
394
1.00M
}
Unexecuted instantiation: bool llvm::hashing::detail::store_and_advance<llvm::fltSemantics const*>(char*&, char*, llvm::fltSemantics const* const&, unsigned long)
bool llvm::hashing::detail::store_and_advance<llvm::Value const*>(char*&, char*, llvm::Value const* const&, unsigned long)
Line
Count
Source
386
693k
                       size_t offset = 0) {
387
693k
  size_t store_size = sizeof(value) - offset;
388
693k
  if (buffer_ptr + store_size > buffer_end)
389
762
    return false;
390
692k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
692k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
692k
  buffer_ptr += store_size;
393
692k
  return true;
394
692k
}
bool llvm::hashing::detail::store_and_advance<void*>(char*&, char*, void* const&, unsigned long)
Line
Count
Source
386
44.9k
                       size_t offset = 0) {
387
44.9k
  size_t store_size = sizeof(value) - offset;
388
44.9k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
44.9k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
44.9k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
44.9k
  buffer_ptr += store_size;
393
44.9k
  return true;
394
44.9k
}
bool llvm::hashing::detail::store_and_advance<clang::NestedNameSpecifier*>(char*&, char*, clang::NestedNameSpecifier* const&, unsigned long)
Line
Count
Source
386
909
                       size_t offset = 0) {
387
909
  size_t store_size = sizeof(value) - offset;
388
909
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
909
  const char *value_data = reinterpret_cast<const char *>(&value);
391
909
  memcpy(buffer_ptr, value_data + offset, store_size);
392
909
  buffer_ptr += store_size;
393
909
  return true;
394
909
}
bool llvm::hashing::detail::store_and_advance<long>(char*&, char*, long const&, unsigned long)
Line
Count
Source
386
61.8k
                       size_t offset = 0) {
387
61.8k
  size_t store_size = sizeof(value) - offset;
388
61.8k
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
61.8k
  const char *value_data = reinterpret_cast<const char *>(&value);
391
61.8k
  memcpy(buffer_ptr, value_data + offset, store_size);
392
61.8k
  buffer_ptr += store_size;
393
61.8k
  return true;
394
61.8k
}
bool llvm::hashing::detail::store_and_advance<llvm::RegisterBankInfo::ValueMapping const*>(char*&, char*, llvm::RegisterBankInfo::ValueMapping const* const&, unsigned long)
Line
Count
Source
386
14.0M
                       size_t offset = 0) {
387
14.0M
  size_t store_size = sizeof(value) - offset;
388
14.0M
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
14.0M
  const char *value_data = reinterpret_cast<const char *>(&value);
391
14.0M
  memcpy(buffer_ptr, value_data + offset, store_size);
392
14.0M
  buffer_ptr += store_size;
393
14.0M
  return true;
394
14.0M
}
bool llvm::hashing::detail::store_and_advance<clang::IdentifierInfo const*>(char*&, char*, clang::IdentifierInfo const* const&, unsigned long)
Line
Count
Source
386
1
                       size_t offset = 0) {
387
1
  size_t store_size = sizeof(value) - offset;
388
1
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
1
  const char *value_data = reinterpret_cast<const char *>(&value);
391
1
  memcpy(buffer_ptr, value_data + offset, store_size);
392
1
  buffer_ptr += store_size;
393
1
  return true;
394
1
}
bool llvm::hashing::detail::store_and_advance<llvm::wasm::ValType>(char*&, char*, llvm::wasm::ValType const&, unsigned long)
Line
Count
Source
386
634
                       size_t offset = 0) {
387
634
  size_t store_size = sizeof(value) - offset;
388
634
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
634
  const char *value_data = reinterpret_cast<const char *>(&value);
391
634
  memcpy(buffer_ptr, value_data + offset, store_size);
392
634
  buffer_ptr += store_size;
393
634
  return true;
394
634
}
bool llvm::hashing::detail::store_and_advance<lld::DefinedAtom::ContentType>(char*&, char*, lld::DefinedAtom::ContentType const&, unsigned long)
Line
Count
Source
386
54
                       size_t offset = 0) {
387
54
  size_t store_size = sizeof(value) - offset;
388
54
  if (buffer_ptr + store_size > buffer_end)
389
0
    return false;
390
54
  const char *value_data = reinterpret_cast<const char *>(&value);
391
54
  memcpy(buffer_ptr, value_data + offset, store_size);
392
54
  buffer_ptr += store_size;
393
54
  return true;
394
54
}
395
396
/// Implement the combining of integral values into a hash_code.
397
///
398
/// This overload is selected when the value type of the iterator is
399
/// integral. Rather than computing a hash_code for each object and then
400
/// combining them, this (as an optimization) directly combines the integers.
401
template <typename InputIteratorT>
402
26.1M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
26.1M
  const uint64_t seed = get_execution_seed();
404
26.1M
  char buffer[64], *buffer_ptr = buffer;
405
26.1M
  char *const buffer_end = std::end(buffer);
406
105M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
79.7M
                                            get_hashable_data(*first)))
408
79.3M
    ++first;
409
26.1M
  if (first == last)
410
25.8M
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
383k
  assert(buffer_ptr == buffer_end);
412
383k
413
383k
  hash_state state = state.create(buffer, seed);
414
383k
  size_t length = 64;
415
5.00M
  while (first != last) {
416
4.62M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
4.62M
    // when only a partial 64-byte chunk is left.
418
4.62M
    buffer_ptr = buffer;
419
39.9M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
39.6M
                                              get_hashable_data(*first)))
421
35.3M
      ++first;
422
4.62M
423
4.62M
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
4.62M
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
4.62M
    // have a contiguous byte sequence, and we want to emulate that here.
426
4.62M
    std::rotate(buffer, buffer_ptr, buffer_end);
427
4.62M
428
4.62M
    // Mix this chunk into the current state.
429
4.62M
    state.mix(buffer);
430
4.62M
    length += buffer_ptr - buffer;
431
4.62M
  };
432
383k
433
383k
  return state.finalize(length);
434
383k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
402
42.9k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
42.9k
  const uint64_t seed = get_execution_seed();
404
42.9k
  char buffer[64], *buffer_ptr = buffer;
405
42.9k
  char *const buffer_end = std::end(buffer);
406
286k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
260k
                                            get_hashable_data(*first)))
408
243k
    ++first;
409
42.9k
  if (first == last)
410
26.3k
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
16.5k
  assert(buffer_ptr == buffer_end);
412
16.5k
413
16.5k
  hash_state state = state.create(buffer, seed);
414
16.5k
  size_t length = 64;
415
4.11M
  while (first != last) {
416
4.09M
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
4.09M
    // when only a partial 64-byte chunk is left.
418
4.09M
    buffer_ptr = buffer;
419
36.8M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
36.7M
                                              get_hashable_data(*first)))
421
32.7M
      ++first;
422
4.09M
423
4.09M
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
4.09M
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
4.09M
    // have a contiguous byte sequence, and we want to emulate that here.
426
4.09M
    std::rotate(buffer, buffer_ptr, buffer_end);
427
4.09M
428
4.09M
    // Mix this chunk into the current state.
429
4.09M
    state.mix(buffer);
430
4.09M
    length += buffer_ptr - buffer;
431
4.09M
  };
432
16.5k
433
16.5k
  return state.finalize(length);
434
16.5k
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>)
Line
Count
Source
402
20.6k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
20.6k
  const uint64_t seed = get_execution_seed();
404
20.6k
  char buffer[64], *buffer_ptr = buffer;
405
20.6k
  char *const buffer_end = std::end(buffer);
406
375k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
358k
                                            get_hashable_data(*first)))
408
354k
    ++first;
409
20.6k
  if (first == last)
410
16.8k
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
3.74k
  assert(buffer_ptr == buffer_end);
412
3.74k
413
3.74k
  hash_state state = state.create(buffer, seed);
414
3.74k
  size_t length = 64;
415
7.65k
  while (first != last) {
416
3.90k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
3.90k
    // when only a partial 64-byte chunk is left.
418
3.90k
    buffer_ptr = buffer;
419
141k
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
137k
                                              get_hashable_data(*first)))
421
137k
      ++first;
422
3.90k
423
3.90k
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
3.90k
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
3.90k
    // have a contiguous byte sequence, and we want to emulate that here.
426
3.90k
    std::rotate(buffer, buffer_ptr, buffer_end);
427
3.90k
428
3.90k
    // Mix this chunk into the current state.
429
3.90k
    state.mix(buffer);
430
3.90k
    length += buffer_ptr - buffer;
431
3.90k
  };
432
3.74k
433
3.74k
  return state.finalize(length);
434
3.74k
}
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
402
25.8M
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
25.8M
  const uint64_t seed = get_execution_seed();
404
25.8M
  char buffer[64], *buffer_ptr = buffer;
405
25.8M
  char *const buffer_end = std::end(buffer);
406
103M
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
78.4M
                                            get_hashable_data(*first)))
408
78.0M
    ++first;
409
25.8M
  if (first == last)
410
25.5M
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
361k
  assert(buffer_ptr == buffer_end);
412
361k
413
361k
  hash_state state = state.create(buffer, seed);
414
361k
  size_t length = 64;
415
883k
  while (first != last) {
416
521k
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
521k
    // when only a partial 64-byte chunk is left.
418
521k
    buffer_ptr = buffer;
419
3.03M
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
2.67M
                                              get_hashable_data(*first)))
421
2.51M
      ++first;
422
521k
423
521k
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
521k
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
521k
    // have a contiguous byte sequence, and we want to emulate that here.
426
521k
    std::rotate(buffer, buffer_ptr, buffer_end);
427
521k
428
521k
    // Mix this chunk into the current state.
429
521k
    state.mix(buffer);
430
521k
    length += buffer_ptr - buffer;
431
521k
  };
432
361k
433
361k
  return state.finalize(length);
434
361k
}
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
402
269k
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
269k
  const uint64_t seed = get_execution_seed();
404
269k
  char buffer[64], *buffer_ptr = buffer;
405
269k
  char *const buffer_end = std::end(buffer);
406
960k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
691k
                                            get_hashable_data(*first)))
408
691k
    ++first;
409
269k
  if (first == last)
410
268k
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
762
  assert(buffer_ptr == buffer_end);
412
762
413
762
  hash_state state = state.create(buffer, seed);
414
762
  size_t length = 64;
415
1.52k
  while (first != last) {
416
762
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
762
    // when only a partial 64-byte chunk is left.
418
762
    buffer_ptr = buffer;
419
2.19k
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
1.43k
                                              get_hashable_data(*first)))
421
1.43k
      ++first;
422
762
423
762
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
762
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
762
    // have a contiguous byte sequence, and we want to emulate that here.
426
762
    std::rotate(buffer, buffer_ptr, buffer_end);
427
762
428
762
    // Mix this chunk into the current state.
429
762
    state.mix(buffer);
430
762
    length += buffer_ptr - buffer;
431
762
  };
432
762
433
762
  return state.finalize(length);
434
762
}
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
402
496
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
496
  const uint64_t seed = get_execution_seed();
404
496
  char buffer[64], *buffer_ptr = buffer;
405
496
  char *const buffer_end = std::end(buffer);
406
1.05k
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
560
                                            get_hashable_data(*first)))
408
560
    ++first;
409
496
  if (first == last)
410
496
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
0
  assert(buffer_ptr == buffer_end);
412
0
413
0
  hash_state state = state.create(buffer, seed);
414
0
  size_t length = 64;
415
0
  while (first != last) {
416
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
0
    // when only a partial 64-byte chunk is left.
418
0
    buffer_ptr = buffer;
419
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
0
                                              get_hashable_data(*first)))
421
0
      ++first;
422
0
423
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
0
    // have a contiguous byte sequence, and we want to emulate that here.
426
0
    std::rotate(buffer, buffer_ptr, buffer_end);
427
0
428
0
    // Mix this chunk into the current state.
429
0
    state.mix(buffer);
430
0
    length += buffer_ptr - buffer;
431
0
  };
432
0
433
0
  return state.finalize(length);
434
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
402
1
hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
403
1
  const uint64_t seed = get_execution_seed();
404
1
  char buffer[64], *buffer_ptr = buffer;
405
1
  char *const buffer_end = std::end(buffer);
406
2
  while (first != last && store_and_advance(buffer_ptr, buffer_end,
407
1
                                            get_hashable_data(*first)))
408
1
    ++first;
409
1
  if (first == last)
410
1
    return hash_short(buffer, buffer_ptr - buffer, seed);
411
0
  assert(buffer_ptr == buffer_end);
412
0
413
0
  hash_state state = state.create(buffer, seed);
414
0
  size_t length = 64;
415
0
  while (first != last) {
416
0
    // Fill up the buffer. We don't clear it, which re-mixes the last round
417
0
    // when only a partial 64-byte chunk is left.
418
0
    buffer_ptr = buffer;
419
0
    while (first != last && store_and_advance(buffer_ptr, buffer_end,
420
0
                                              get_hashable_data(*first)))
421
0
      ++first;
422
0
423
0
    // Rotate the buffer if we did a partial fill in order to simulate doing
424
0
    // a mix of the last 64-bytes. That is how the algorithm works when we
425
0
    // have a contiguous byte sequence, and we want to emulate that here.
426
0
    std::rotate(buffer, buffer_ptr, buffer_end);
427
0
428
0
    // Mix this chunk into the current state.
429
0
    state.mix(buffer);
430
0
    length += buffer_ptr - buffer;
431
0
  };
432
0
433
0
  return state.finalize(length);
434
0
}
435
436
/// Implement the combining of integral values into a hash_code.
437
///
438
/// This overload is selected when the value type of the iterator is integral
439
/// and when the input iterator is actually a pointer. Rather than computing
440
/// a hash_code for each object and then combining them, this (as an
441
/// optimization) directly combines the integers. Also, because the integers
442
/// are stored in contiguous memory, this routine avoids copying each value
443
/// and directly reads from the underlying memory.
444
template <typename ValueT>
445
typename std::enable_if<is_hashable_data<ValueT>::value, hash_code>::type
446
720M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
720M
  const uint64_t seed = get_execution_seed();
448
720M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
720M
  const char *s_end = reinterpret_cast<const char *>(last);
450
720M
  const size_t length = std::distance(s_begin, s_end);
451
720M
  if (length <= 64)
452
693M
    return hash_short(s_begin, length, seed);
453
26.3M
454
26.3M
  const char *s_aligned_end = s_begin + (length & ~63);
455
26.3M
  hash_state state = state.create(s_begin, seed);
456
26.3M
  s_begin += 64;
457
52.6M
  while (s_begin != s_aligned_end) {
458
26.2M
    state.mix(s_begin);
459
26.2M
    s_begin += 64;
460
26.2M
  }
461
26.3M
  if (length & 63)
462
25.6M
    state.mix(s_end - 64);
463
26.3M
464
26.3M
  return state.finalize(length);
465
26.3M
}
std::__1::enable_if<is_hashable_data<unsigned int>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<unsigned int>(unsigned int*, unsigned int*)
Line
Count
Source
446
2.02k
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
2.02k
  const uint64_t seed = get_execution_seed();
448
2.02k
  const char *s_begin = reinterpret_cast<const char *>(first);
449
2.02k
  const char *s_end = reinterpret_cast<const char *>(last);
450
2.02k
  const size_t length = std::distance(s_begin, s_end);
451
2.02k
  if (length <= 64)
452
192
    return hash_short(s_begin, length, seed);
453
1.83k
454
1.83k
  const char *s_aligned_end = s_begin + (length & ~63);
455
1.83k
  hash_state state = state.create(s_begin, seed);
456
1.83k
  s_begin += 64;
457
29.0k
  while (s_begin != s_aligned_end) {
458
27.2k
    state.mix(s_begin);
459
27.2k
    s_begin += 64;
460
27.2k
  }
461
1.83k
  if (length & 63)
462
1.51k
    state.mix(s_end - 64);
463
1.83k
464
1.83k
  return state.finalize(length);
465
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
446
24.3M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
24.3M
  const uint64_t seed = get_execution_seed();
448
24.3M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
24.3M
  const char *s_end = reinterpret_cast<const char *>(last);
450
24.3M
  const size_t length = std::distance(s_begin, s_end);
451
24.3M
  if (length <= 64)
452
23.5M
    return hash_short(s_begin, length, seed);
453
793k
454
793k
  const char *s_aligned_end = s_begin + (length & ~63);
455
793k
  hash_state state = state.create(s_begin, seed);
456
793k
  s_begin += 64;
457
960k
  while (s_begin != s_aligned_end) {
458
167k
    state.mix(s_begin);
459
167k
    s_begin += 64;
460
167k
  }
461
793k
  if (length & 63)
462
793k
    state.mix(s_end - 64);
463
793k
464
793k
  return state.finalize(length);
465
793k
}
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
446
17.9M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
17.9M
  const uint64_t seed = get_execution_seed();
448
17.9M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
17.9M
  const char *s_end = reinterpret_cast<const char *>(last);
450
17.9M
  const size_t length = std::distance(s_begin, s_end);
451
17.9M
  if (length <= 64)
452
17.9M
    return hash_short(s_begin, length, seed);
453
52.0k
454
52.0k
  const char *s_aligned_end = s_begin + (length & ~63);
455
52.0k
  hash_state state = state.create(s_begin, seed);
456
52.0k
  s_begin += 64;
457
135k
  while (s_begin != s_aligned_end) {
458
83.3k
    state.mix(s_begin);
459
83.3k
    s_begin += 64;
460
83.3k
  }
461
52.0k
  if (length & 63)
462
22.9k
    state.mix(s_end - 64);
463
52.0k
464
52.0k
  return state.finalize(length);
465
52.0k
}
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
446
621M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
621M
  const uint64_t seed = get_execution_seed();
448
621M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
621M
  const char *s_end = reinterpret_cast<const char *>(last);
450
621M
  const size_t length = std::distance(s_begin, s_end);
451
621M
  if (length <= 64)
452
596M
    return hash_short(s_begin, length, seed);
453
25.1M
454
25.1M
  const char *s_aligned_end = s_begin + (length & ~63);
455
25.1M
  hash_state state = state.create(s_begin, seed);
456
25.1M
  s_begin += 64;
457
50.0M
  while (s_begin != s_aligned_end) {
458
24.9M
    state.mix(s_begin);
459
24.9M
    s_begin += 64;
460
24.9M
  }
461
25.1M
  if (length & 63)
462
24.4M
    state.mix(s_end - 64);
463
25.1M
464
25.1M
  return state.finalize(length);
465
25.1M
}
std::__1::enable_if<is_hashable_data<llvm::Type* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Type* const>(llvm::Type* const*, llvm::Type* const*)
Line
Count
Source
446
7.21M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
7.21M
  const uint64_t seed = get_execution_seed();
448
7.21M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
7.21M
  const char *s_end = reinterpret_cast<const char *>(last);
450
7.21M
  const size_t length = std::distance(s_begin, s_end);
451
7.21M
  if (length <= 64)
452
7.18M
    return hash_short(s_begin, length, seed);
453
31.8k
454
31.8k
  const char *s_aligned_end = s_begin + (length & ~63);
455
31.8k
  hash_state state = state.create(s_begin, seed);
456
31.8k
  s_begin += 64;
457
42.7k
  while (s_begin != s_aligned_end) {
458
10.9k
    state.mix(s_begin);
459
10.9k
    s_begin += 64;
460
10.9k
  }
461
31.8k
  if (length & 63)
462
31.3k
    state.mix(s_end - 64);
463
31.8k
464
31.8k
  return state.finalize(length);
465
31.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
446
1.01M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
1.01M
  const uint64_t seed = get_execution_seed();
448
1.01M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
1.01M
  const char *s_end = reinterpret_cast<const char *>(last);
450
1.01M
  const size_t length = std::distance(s_begin, s_end);
451
1.01M
  if (length <= 64)
452
1.01M
    return hash_short(s_begin, length, seed);
453
41
454
41
  const char *s_aligned_end = s_begin + (length & ~63);
455
41
  hash_state state = state.create(s_begin, seed);
456
41
  s_begin += 64;
457
47
  while (s_begin != s_aligned_end) {
458
6
    state.mix(s_begin);
459
6
    s_begin += 64;
460
6
  }
461
41
  if (length & 63)
462
40
    state.mix(s_end - 64);
463
41
464
41
  return state.finalize(length);
465
41
}
std::__1::enable_if<is_hashable_data<llvm::Metadata* const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<llvm::Metadata* const>(llvm::Metadata* const*, llvm::Metadata* const*)
Line
Count
Source
446
1.51M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
1.51M
  const uint64_t seed = get_execution_seed();
448
1.51M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
1.51M
  const char *s_end = reinterpret_cast<const char *>(last);
450
1.51M
  const size_t length = std::distance(s_begin, s_end);
451
1.51M
  if (length <= 64)
452
1.47M
    return hash_short(s_begin, length, seed);
453
39.9k
454
39.9k
  const char *s_aligned_end = s_begin + (length & ~63);
455
39.9k
  hash_state state = state.create(s_begin, seed);
456
39.9k
  s_begin += 64;
457
106k
  while (s_begin != s_aligned_end) {
458
66.8k
    state.mix(s_begin);
459
66.8k
    s_begin += 64;
460
66.8k
  }
461
39.9k
  if (length & 63)
462
39.4k
    state.mix(s_end - 64);
463
39.9k
464
39.9k
  return state.finalize(length);
465
39.9k
}
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
446
2.64k
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
2.64k
  const uint64_t seed = get_execution_seed();
448
2.64k
  const char *s_begin = reinterpret_cast<const char *>(first);
449
2.64k
  const char *s_end = reinterpret_cast<const char *>(last);
450
2.64k
  const size_t length = std::distance(s_begin, s_end);
451
2.64k
  if (length <= 64)
452
2.64k
    return hash_short(s_begin, length, seed);
453
0
454
0
  const char *s_aligned_end = s_begin + (length & ~63);
455
0
  hash_state state = state.create(s_begin, seed);
456
0
  s_begin += 64;
457
0
  while (s_begin != s_aligned_end) {
458
0
    state.mix(s_begin);
459
0
    s_begin += 64;
460
0
  }
461
0
  if (length & 63)
462
0
    state.mix(s_end - 64);
463
0
464
0
  return state.finalize(length);
465
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
446
19.1M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
19.1M
  const uint64_t seed = get_execution_seed();
448
19.1M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
19.1M
  const char *s_end = reinterpret_cast<const char *>(last);
450
19.1M
  const size_t length = std::distance(s_begin, s_end);
451
19.1M
  if (length <= 64)
452
19.1M
    return hash_short(s_begin, length, seed);
453
0
454
0
  const char *s_aligned_end = s_begin + (length & ~63);
455
0
  hash_state state = state.create(s_begin, seed);
456
0
  s_begin += 64;
457
0
  while (s_begin != s_aligned_end) {
458
0
    state.mix(s_begin);
459
0
    s_begin += 64;
460
0
  }
461
0
  if (length & 63)
462
0
    state.mix(s_end - 64);
463
0
464
0
  return state.finalize(length);
465
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
446
4.04M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
4.04M
  const uint64_t seed = get_execution_seed();
448
4.04M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
4.04M
  const char *s_end = reinterpret_cast<const char *>(last);
450
4.04M
  const size_t length = std::distance(s_begin, s_end);
451
4.04M
  if (length <= 64)
452
4.04M
    return hash_short(s_begin, length, seed);
453
389
454
389
  const char *s_aligned_end = s_begin + (length & ~63);
455
389
  hash_state state = state.create(s_begin, seed);
456
389
  s_begin += 64;
457
72.6k
  while (s_begin != s_aligned_end) {
458
72.2k
    state.mix(s_begin);
459
72.2k
    s_begin += 64;
460
72.2k
  }
461
389
  if (length & 63)
462
103
    state.mix(s_end - 64);
463
389
464
389
  return state.finalize(length);
465
389
}
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
446
7.31M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
7.31M
  const uint64_t seed = get_execution_seed();
448
7.31M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
7.31M
  const char *s_end = reinterpret_cast<const char *>(last);
450
7.31M
  const size_t length = std::distance(s_begin, s_end);
451
7.31M
  if (length <= 64)
452
7.20M
    return hash_short(s_begin, length, seed);
453
106k
454
106k
  const char *s_aligned_end = s_begin + (length & ~63);
455
106k
  hash_state state = state.create(s_begin, seed);
456
106k
  s_begin += 64;
457
889k
  while (s_begin != s_aligned_end) {
458
783k
    state.mix(s_begin);
459
783k
    s_begin += 64;
460
783k
  }
461
106k
  if (length & 63)
462
105k
    state.mix(s_end - 64);
463
106k
464
106k
  return state.finalize(length);
465
106k
}
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
446
8.20M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
8.20M
  const uint64_t seed = get_execution_seed();
448
8.20M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
8.20M
  const char *s_end = reinterpret_cast<const char *>(last);
450
8.20M
  const size_t length = std::distance(s_begin, s_end);
451
8.20M
  if (length <= 64)
452
8.03M
    return hash_short(s_begin, length, seed);
453
170k
454
170k
  const char *s_aligned_end = s_begin + (length & ~63);
455
170k
  hash_state state = state.create(s_begin, seed);
456
170k
  s_begin += 64;
457
328k
  while (s_begin != s_aligned_end) {
458
158k
    state.mix(s_begin);
459
158k
    s_begin += 64;
460
158k
  }
461
170k
  if (length & 63)
462
166k
    state.mix(s_end - 64);
463
170k
464
170k
  return state.finalize(length);
465
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
446
7.60M
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
7.60M
  const uint64_t seed = get_execution_seed();
448
7.60M
  const char *s_begin = reinterpret_cast<const char *>(first);
449
7.60M
  const char *s_end = reinterpret_cast<const char *>(last);
450
7.60M
  const size_t length = std::distance(s_begin, s_end);
451
7.60M
  if (length <= 64)
452
7.60M
    return hash_short(s_begin, length, seed);
453
104
454
104
  const char *s_aligned_end = s_begin + (length & ~63);
455
104
  hash_state state = state.create(s_begin, seed);
456
104
  s_begin += 64;
457
104
  while (s_begin != s_aligned_end) {
458
0
    state.mix(s_begin);
459
0
    s_begin += 64;
460
0
  }
461
104
  if (length & 63)
462
104
    state.mix(s_end - 64);
463
104
464
104
  return state.finalize(length);
465
104
}
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
446
4.97k
hash_combine_range_impl(ValueT *first, ValueT *last) {
447
4.97k
  const uint64_t seed = get_execution_seed();
448
4.97k
  const char *s_begin = reinterpret_cast<const char *>(first);
449
4.97k
  const char *s_end = reinterpret_cast<const char *>(last);
450
4.97k
  const size_t length = std::distance(s_begin, s_end);
451
4.97k
  if (length <= 64)
452
3.61k
    return hash_short(s_begin, length, seed);
453
1.36k
454
1.36k
  const char *s_aligned_end = s_begin + (length & ~63);
455
1.36k
  hash_state state = state.create(s_begin, seed);
456
1.36k
  s_begin += 64;
457
1.95k
  while (s_begin != s_aligned_end) {
458
590
    state.mix(s_begin);
459
590
    s_begin += 64;
460
590
  }
461
1.36k
  if (length & 63)
462
1.28k
    state.mix(s_end - 64);
463
1.36k
464
1.36k
  return state.finalize(length);
465
1.36k
}
466
467
} // namespace detail
468
} // namespace hashing
469
470
471
/// Compute a hash_code for a sequence of values.
472
///
473
/// This hashes a sequence of values. It produces the same hash_code as
474
/// 'hash_combine(a, b, c, ...)', but can run over arbitrary sized sequences
475
/// and is significantly faster given pointers and types which can be hashed as
476
/// a sequence of bytes.
477
template <typename InputIteratorT>
478
746M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
746M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
746M
}
llvm::hash_code llvm::hash_combine_range<unsigned int*>(unsigned int*, unsigned int*)
Line
Count
Source
478
2.02k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
2.02k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
2.02k
}
llvm::hash_code llvm::hash_combine_range<unsigned long*>(unsigned long*, unsigned long*)
Line
Count
Source
478
24.3M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
24.3M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
24.3M
}
llvm::hash_code llvm::hash_combine_range<llvm::Constant* const*>(llvm::Constant* const*, llvm::Constant* const*)
Line
Count
Source
478
17.9M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
17.9M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
17.9M
}
llvm::hash_code llvm::hash_combine_range<unsigned int const*>(unsigned int const*, unsigned int const*)
Line
Count
Source
478
621M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
621M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
621M
}
llvm::hash_code llvm::hash_combine_range<llvm::Type* const*>(llvm::Type* const*, llvm::Type* const*)
Line
Count
Source
478
7.21M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
7.21M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
7.21M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long const*>(unsigned long long const*, unsigned long long const*)
Line
Count
Source
478
1.01M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
1.01M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
1.01M
}
llvm::hash_code llvm::hash_combine_range<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*)
Line
Count
Source
478
42.9k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
42.9k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
42.9k
}
llvm::hash_code llvm::hash_combine_range<llvm::Metadata* const*>(llvm::Metadata* const*, llvm::Metadata* const*)
Line
Count
Source
478
1.51M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
1.51M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
1.51M
}
llvm::hash_code llvm::hash_combine_range<std::__1::__wrap_iter<char const*> >(std::__1::__wrap_iter<char const*>, std::__1::__wrap_iter<char const*>)
Line
Count
Source
478
20.6k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
20.6k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
20.6k
}
llvm::hash_code llvm::hash_combine_range<llvm::Value* const*>(llvm::Value* const*, llvm::Value* const*)
Line
Count
Source
478
2.64k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
2.64k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
2.64k
}
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
478
25.8M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
25.8M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
25.8M
}
llvm::hash_code llvm::hash_combine_range<llvm::SCEV const* const*>(llvm::SCEV const* const*, llvm::SCEV const* const*)
Line
Count
Source
478
19.1M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
19.1M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
19.1M
}
llvm::hash_code llvm::hash_combine_range<unsigned long long*>(unsigned long long*, unsigned long long*)
Line
Count
Source
478
4.04M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
4.04M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
4.04M
}
llvm::hash_code llvm::hash_combine_range<char const*>(char const*, char const*)
Line
Count
Source
478
7.31M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
7.31M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
7.31M
}
llvm::hash_code llvm::hash_combine_range<llvm::BasicBlock**>(llvm::BasicBlock**, llvm::BasicBlock**)
Line
Count
Source
478
8.20M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
8.20M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
8.20M
}
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
478
269k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
269k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
269k
}
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
478
7.60M
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
7.60M
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
7.60M
}
llvm::hash_code llvm::hash_combine_range<llvm::StringRef const*>(llvm::StringRef const*, llvm::StringRef const*)
Line
Count
Source
478
496
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
496
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
496
}
ItaniumCXXABI.cpp:llvm::hash_code llvm::hash_combine_range<(anonymous namespace)::DecompositionDeclName::Iterator>((anonymous namespace)::DecompositionDeclName::Iterator, (anonymous namespace)::DecompositionDeclName::Iterator)
Line
Count
Source
478
1
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
1
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
1
}
llvm::hash_code llvm::hash_combine_range<unsigned char const*>(unsigned char const*, unsigned char const*)
Line
Count
Source
478
4.97k
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last) {
479
4.97k
  return ::llvm::hashing::detail::hash_combine_range_impl(first, last);
480
4.97k
}
481
482
483
// Implementation details for hash_combine.
484
namespace hashing {
485
namespace detail {
486
487
/// Helper class to manage the recursive combining of hash_combine
488
/// arguments.
489
///
490
/// This class exists to manage the state and various calls involved in the
491
/// recursive combining of arguments used in hash_combine. It is particularly
492
/// useful at minimizing the code in the recursive calls to ease the pain
493
/// caused by a lack of variadic functions.
494
struct hash_combine_recursive_helper {
495
  char buffer[64];
496
  hash_state state;
497
  const uint64_t seed;
498
499
public:
500
  /// Construct a recursive hash combining helper.
501
  ///
502
  /// This sets up the state for a recursive hash combine, including getting
503
  /// the seed and buffer setup.
504
  hash_combine_recursive_helper()
505
462M
    : seed(get_execution_seed()) {}
506
507
  /// Combine one chunk of data into the current in-flight hash.
508
  ///
509
  /// This merges one chunk of data into the hash. First it tries to buffer
510
  /// the data. If the buffer is full, it hashes the buffer into its
511
  /// hash_state, empties it, and then merges the new chunk in. This also
512
  /// handles cases where the data straddles the end of the buffer.
513
  template <typename T>
514
1.01G
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.01G
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
6
      // Check for skew which prevents the buffer from being packed, and do
517
6
      // a partial store into the buffer to fill it. This is only a concern
518
6
      // with the variadic combine because that formation can have varying
519
6
      // argument types.
520
6
      size_t partial_store_size = buffer_end - buffer_ptr;
521
6
      memcpy(buffer_ptr, &data, partial_store_size);
522
6
523
6
      // If the store fails, our buffer is full and ready to hash. We have to
524
6
      // either initialize the hash state (on the first full buffer) or mix
525
6
      // this buffer into the existing hash state. Length tracks the *hashed*
526
6
      // length, not the buffered length.
527
6
      if (length == 0) {
528
6
        state = state.create(buffer, seed);
529
6
        length = 64;
530
6
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
6
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
6
      // data.
537
6
      buffer_ptr = buffer;
538
6
539
6
      // Try again to store into the buffer -- this cannot fail as we only
540
6
      // store types smaller than the buffer.
541
6
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
6
                             partial_store_size))
543
0
        abort();
544
1.01G
    }
545
1.01G
    return buffer_ptr;
546
1.01G
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int>(unsigned long&, char*, char*, unsigned int)
Line
Count
Source
514
269M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
269M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
269M
    }
545
269M
    return buffer_ptr;
546
269M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long>(unsigned long&, char*, char*, unsigned long)
Line
Count
Source
514
100M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
100M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
100M
    }
545
100M
    return buffer_ptr;
546
100M
  }
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
514
1.76k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.76k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
1.76k
    }
545
1.76k
    return buffer_ptr;
546
1.76k
  }
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
514
3.52k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
3.52k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
3.52k
    }
545
3.52k
    return buffer_ptr;
546
3.52k
  }
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
514
273
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
273
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
273
    }
545
273
    return buffer_ptr;
546
273
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<bool>(unsigned long&, char*, char*, bool)
Line
Count
Source
514
71.2M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
71.2M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
71.2M
    }
545
71.2M
    return buffer_ptr;
546
71.2M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<int>(unsigned long&, char*, char*, int)
Line
Count
Source
514
1.08M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.08M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
4
      // Check for skew which prevents the buffer from being packed, and do
517
4
      // a partial store into the buffer to fill it. This is only a concern
518
4
      // with the variadic combine because that formation can have varying
519
4
      // argument types.
520
4
      size_t partial_store_size = buffer_end - buffer_ptr;
521
4
      memcpy(buffer_ptr, &data, partial_store_size);
522
4
523
4
      // If the store fails, our buffer is full and ready to hash. We have to
524
4
      // either initialize the hash state (on the first full buffer) or mix
525
4
      // this buffer into the existing hash state. Length tracks the *hashed*
526
4
      // length, not the buffered length.
527
4
      if (length == 0) {
528
4
        state = state.create(buffer, seed);
529
4
        length = 64;
530
4
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
4
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
4
      // data.
537
4
      buffer_ptr = buffer;
538
4
539
4
      // Try again to store into the buffer -- this cannot fail as we only
540
4
      // store types smaller than the buffer.
541
4
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
4
                             partial_store_size))
543
0
        abort();
544
1.08M
    }
545
1.08M
    return buffer_ptr;
546
1.08M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<char const*>(unsigned long&, char*, char*, char const*)
Line
Count
Source
514
6.03k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
6.03k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
6.03k
    }
545
6.03k
    return buffer_ptr;
546
6.03k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::GlobalValue const*>(unsigned long&, char*, char*, llvm::GlobalValue const*)
Line
Count
Source
514
3.83M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
3.83M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
3.83M
    }
545
3.83M
    return buffer_ptr;
546
3.83M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::BlockAddress const*>(unsigned long&, char*, char*, llvm::BlockAddress const*)
Line
Count
Source
514
394
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
394
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
394
    }
545
394
    return buffer_ptr;
546
394
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol*>(unsigned long&, char*, char*, llvm::MCSymbol*)
Line
Count
Source
514
247
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
247
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
247
    }
545
247
    return buffer_ptr;
546
247
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineBasicBlock*>(unsigned long&, char*, char*, llvm::MachineBasicBlock*)
Line
Count
Source
514
1.71M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.71M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
1.71M
    }
545
1.71M
    return buffer_ptr;
546
1.71M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MachineOperand::MachineOperandType>(unsigned long&, char*, char*, llvm::MachineOperand::MachineOperandType)
Line
Count
Source
514
73.7M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
73.7M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
73.7M
    }
545
73.7M
    return buffer_ptr;
546
73.7M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long long>(unsigned long&, char*, char*, long long)
Line
Count
Source
514
26.6M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
26.6M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
26.6M
    }
545
26.6M
    return buffer_ptr;
546
26.6M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantInt const*>(unsigned long&, char*, char*, llvm::ConstantInt const*)
Line
Count
Source
514
15
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
15
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
15
    }
545
15
    return buffer_ptr;
546
15
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ConstantFP const*>(unsigned long&, char*, char*, llvm::ConstantFP const*)
Line
Count
Source
514
774
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
774
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
774
    }
545
774
    return buffer_ptr;
546
774
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned int const*>(unsigned long&, char*, char*, unsigned int const*)
Line
Count
Source
514
18
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
18
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
18
    }
545
18
    return buffer_ptr;
546
18
  }
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDNode const*>(unsigned long&, char*, char*, llvm::MDNode const*)
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Intrinsic::ID>(unsigned long&, char*, char*, llvm::Intrinsic::ID)
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::InlineAsm::AsmDialect>(unsigned long&, char*, char*, llvm::InlineAsm::AsmDialect)
Line
Count
Source
514
25.3k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
25.3k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
25.3k
    }
545
25.3k
    return buffer_ptr;
546
25.3k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::FunctionType*>(unsigned long&, char*, char*, llvm::FunctionType*)
Line
Count
Source
514
25.3k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
25.3k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
25.3k
    }
545
25.3k
    return buffer_ptr;
546
25.3k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned char>(unsigned long&, char*, char*, unsigned char)
Line
Count
Source
514
37.4M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
37.4M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
37.4M
    }
545
37.4M
    return buffer_ptr;
546
37.4M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned short>(unsigned long&, char*, char*, unsigned short)
Line
Count
Source
514
17.5M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
17.5M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
17.5M
    }
545
17.5M
    return buffer_ptr;
546
17.5M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type const*>(unsigned long&, char*, char*, llvm::Type const*)
Line
Count
Source
514
7.07M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
7.07M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
7.07M
    }
545
7.07M
    return buffer_ptr;
546
7.07M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Metadata*>(unsigned long&, char*, char*, llvm::Metadata*)
Line
Count
Source
514
31.0M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
31.0M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
31.0M
    }
545
31.0M
    return buffer_ptr;
546
31.0M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MDString*>(unsigned long&, char*, char*, llvm::MDString*)
Line
Count
Source
514
206k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
206k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
206k
    }
545
206k
    return buffer_ptr;
546
206k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long long>(unsigned long&, char*, char*, unsigned long long)
Line
Count
Source
514
233M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
233M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
2
      // Check for skew which prevents the buffer from being packed, and do
517
2
      // a partial store into the buffer to fill it. This is only a concern
518
2
      // with the variadic combine because that formation can have varying
519
2
      // argument types.
520
2
      size_t partial_store_size = buffer_end - buffer_ptr;
521
2
      memcpy(buffer_ptr, &data, partial_store_size);
522
2
523
2
      // If the store fails, our buffer is full and ready to hash. We have to
524
2
      // either initialize the hash state (on the first full buffer) or mix
525
2
      // this buffer into the existing hash state. Length tracks the *hashed*
526
2
      // length, not the buffered length.
527
2
      if (length == 0) {
528
2
        state = state.create(buffer, seed);
529
2
        length = 64;
530
2
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
2
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
2
      // data.
537
2
      buffer_ptr = buffer;
538
2
539
2
      // Try again to store into the buffer -- this cannot fail as we only
540
2
      // store types smaller than the buffer.
541
2
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
2
                             partial_store_size))
543
0
        abort();
544
233M
    }
545
233M
    return buffer_ptr;
546
233M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::ArrayType*>(unsigned long&, char*, char*, llvm::ArrayType*)
Line
Count
Source
514
60.1k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
60.1k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
60.1k
    }
545
60.1k
    return buffer_ptr;
546
60.1k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::StructType*>(unsigned long&, char*, char*, llvm::StructType*)
Line
Count
Source
514
197k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
197k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
197k
    }
545
197k
    return buffer_ptr;
546
197k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::VectorType*>(unsigned long&, char*, char*, llvm::VectorType*)
Line
Count
Source
514
220k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
220k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
220k
    }
545
220k
    return buffer_ptr;
546
220k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Type*>(unsigned long&, char*, char*, llvm::Type*)
Line
Count
Source
514
47.1M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
47.1M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
47.1M
    }
545
47.1M
    return buffer_ptr;
546
47.1M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::PointerType*>(unsigned long&, char*, char*, llvm::PointerType*)
Line
Count
Source
514
25.3k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
25.3k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
25.3k
    }
545
25.3k
    return buffer_ptr;
546
25.3k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MCSymbol const*>(unsigned long&, char*, char*, llvm::MCSymbol const*)
Line
Count
Source
514
29.7k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
29.7k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
29.7k
    }
545
29.7k
    return buffer_ptr;
546
29.7k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::BinaryOps>(unsigned long&, char*, char*, llvm::Instruction::BinaryOps)
Line
Count
Source
514
7.41M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
7.41M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
7.41M
    }
545
7.41M
    return buffer_ptr;
546
7.41M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Value*>(unsigned long&, char*, char*, llvm::Value*)
Line
Count
Source
514
49.4M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
49.4M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
49.4M
    }
545
49.4M
    return buffer_ptr;
546
49.4M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::CmpInst::Predicate>(unsigned long&, char*, char*, llvm::CmpInst::Predicate)
Line
Count
Source
514
12.6M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
12.6M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
12.6M
    }
545
12.6M
    return buffer_ptr;
546
12.6M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::SelectPatternFlavor>(unsigned long&, char*, char*, llvm::SelectPatternFlavor)
Line
Count
Source
514
230k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
230k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
230k
    }
545
230k
    return buffer_ptr;
546
230k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction::CastOps>(unsigned long&, char*, char*, llvm::Instruction::CastOps)
Line
Count
Source
514
8.26M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
8.26M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
8.26M
    }
545
8.26M
    return buffer_ptr;
546
8.26M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::MemoryAccess const*>(unsigned long&, char*, char*, llvm::MemoryAccess const*)
Line
Count
Source
514
1.14k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.14k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
1.14k
    }
545
1.14k
    return buffer_ptr;
546
1.14k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Constant*>(unsigned long&, char*, char*, llvm::Constant*)
Line
Count
Source
514
466
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
466
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
466
    }
545
466
    return buffer_ptr;
546
466
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::Instruction*>(unsigned long&, char*, char*, llvm::Instruction*)
Line
Count
Source
514
277
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
277
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
277
    }
545
277
    return buffer_ptr;
546
277
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<short>(unsigned long&, char*, char*, short)
Line
Count
Source
514
1.00M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
1.00M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
1.00M
    }
545
1.00M
    return buffer_ptr;
546
1.00M
  }
Unexecuted instantiation: char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::fltSemantics const*>(unsigned long&, char*, char*, llvm::fltSemantics const*)
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<void*>(unsigned long&, char*, char*, void*)
Line
Count
Source
514
44.9k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
44.9k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
44.9k
    }
545
44.9k
    return buffer_ptr;
546
44.9k
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<clang::NestedNameSpecifier*>(unsigned long&, char*, char*, clang::NestedNameSpecifier*)
Line
Count
Source
514
909
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
909
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
909
    }
545
909
    return buffer_ptr;
546
909
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<long>(unsigned long&, char*, char*, long)
Line
Count
Source
514
61.8k
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
61.8k
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
61.8k
    }
545
61.8k
    return buffer_ptr;
546
61.8k
  }
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
514
14.0M
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
14.0M
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
14.0M
    }
545
14.0M
    return buffer_ptr;
546
14.0M
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::wasm::ValType>(unsigned long&, char*, char*, llvm::wasm::ValType)
Line
Count
Source
514
634
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
634
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
634
    }
545
634
    return buffer_ptr;
546
634
  }
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<lld::DefinedAtom::ContentType>(unsigned long&, char*, char*, lld::DefinedAtom::ContentType)
Line
Count
Source
514
54
  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
515
54
    if (!store_and_advance(buffer_ptr, buffer_end, data)) {
516
0
      // Check for skew which prevents the buffer from being packed, and do
517
0
      // a partial store into the buffer to fill it. This is only a concern
518
0
      // with the variadic combine because that formation can have varying
519
0
      // argument types.
520
0
      size_t partial_store_size = buffer_end - buffer_ptr;
521
0
      memcpy(buffer_ptr, &data, partial_store_size);
522
0
523
0
      // If the store fails, our buffer is full and ready to hash. We have to
524
0
      // either initialize the hash state (on the first full buffer) or mix
525
0
      // this buffer into the existing hash state. Length tracks the *hashed*
526
0
      // length, not the buffered length.
527
0
      if (length == 0) {
528
0
        state = state.create(buffer, seed);
529
0
        length = 64;
530
0
      } else {
531
0
        // Mix this chunk into the current state and bump length up by 64.
532
0
        state.mix(buffer);
533
0
        length += 64;
534
0
      }
535
0
      // Reset the buffer_ptr to the head of the buffer for the next chunk of
536
0
      // data.
537
0
      buffer_ptr = buffer;
538
0
539
0
      // Try again to store into the buffer -- this cannot fail as we only
540
0
      // store types smaller than the buffer.
541
0
      if (!store_and_advance(buffer_ptr, buffer_end, data,
542
0
                             partial_store_size))
543
0
        abort();
544
54
    }
545
54
    return buffer_ptr;
546
54
  }
547
548
  /// Recursive, variadic combining method.
549
  ///
550
  /// This function recurses through each argument, combining that argument
551
  /// into a single hash.
552
  template <typename T, typename ...Ts>
553
  hash_code combine(size_t length, char *buffer_ptr, char *buffer_end,
554
1.01G
                    const T &arg, const Ts &...args) {
555
1.01G
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.01G
557
1.01G
    // Recurse to the next argument.
558
1.01G
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.01G
  }
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
554
206
                    const T &arg, const Ts &...args) {
555
206
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
206
557
206
    // Recurse to the next argument.
558
206
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
17.9M
                    const T &arg, const Ts &...args) {
555
17.9M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
17.9M
557
17.9M
    // Recurse to the next argument.
558
17.9M
    return combine(length, buffer_ptr, buffer_end, args...);
559
17.9M
  }
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
554
66.5M
                    const T &arg, const Ts &...args) {
555
66.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
66.5M
557
66.5M
    // Recurse to the next argument.
558
66.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
66.5M
  }
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
554
762k
                    const T &arg, const Ts &...args) {
555
762k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
762k
557
762k
    // Recurse to the next argument.
558
762k
    return combine(length, buffer_ptr, buffer_end, args...);
559
762k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int>(unsigned long, char*, char*, unsigned int const&)
Line
Count
Source
554
37.0M
                    const T &arg, const Ts &...args) {
555
37.0M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
37.0M
557
37.0M
    // Recurse to the next argument.
558
37.0M
    return combine(length, buffer_ptr, buffer_end, args...);
559
37.0M
  }
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
554
1.76k
                    const T &arg, const Ts &...args) {
555
1.76k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.76k
557
1.76k
    // Recurse to the next argument.
558
1.76k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.76k
  }
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
554
1.76k
                    const T &arg, const Ts &...args) {
555
1.76k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.76k
557
1.76k
    // Recurse to the next argument.
558
1.76k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.76k
  }
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
554
1.76k
                    const T &arg, const Ts &...args) {
555
1.76k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.76k
557
1.76k
    // Recurse to the next argument.
558
1.76k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.76k
  }
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
554
1.76k
                    const T &arg, const Ts &...args) {
555
1.76k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.76k
557
1.76k
    // Recurse to the next argument.
558
1.76k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.76k
  }
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
554
273
                    const T &arg, const Ts &...args) {
555
273
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
273
557
273
    // Recurse to the next argument.
558
273
    return combine(length, buffer_ptr, buffer_end, args...);
559
273
  }
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
554
7.21M
                    const T &arg, const Ts &...args) {
555
7.21M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
7.21M
557
7.21M
    // Recurse to the next argument.
558
7.21M
    return combine(length, buffer_ptr, buffer_end, args...);
559
7.21M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool>(unsigned long, char*, char*, bool const&)
Line
Count
Source
554
67.4M
                    const T &arg, const Ts &...args) {
555
67.4M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
67.4M
557
67.4M
    // Recurse to the next argument.
558
67.4M
    return combine(length, buffer_ptr, buffer_end, args...);
559
67.4M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
554
86.6k
                    const T &arg, const Ts &...args) {
555
86.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
86.6k
557
86.6k
    // Recurse to the next argument.
558
86.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
86.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
554
86.6k
                    const T &arg, const Ts &...args) {
555
86.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
86.6k
557
86.6k
    // Recurse to the next argument.
558
86.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
86.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand, llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&, llvm::MachineOperand const&)
Line
Count
Source
554
86.6k
                    const T &arg, const Ts &...args) {
555
86.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
86.6k
557
86.6k
    // Recurse to the next argument.
558
86.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
86.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand>(unsigned long, char*, char*, llvm::MachineOperand const&)
Line
Count
Source
554
86.6k
                    const T &arg, const Ts &...args) {
555
86.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
86.6k
557
86.6k
    // Recurse to the next argument.
558
86.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
86.6k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, int>(unsigned long, char*, char*, llvm::hash_code const&, int const&)
Line
Count
Source
554
185
                    const T &arg, const Ts &...args) {
555
185
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
185
557
185
    // Recurse to the next argument.
558
185
    return combine(length, buffer_ptr, buffer_end, args...);
559
185
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<int>(unsigned long, char*, char*, int const&)
Line
Count
Source
554
619k
                    const T &arg, const Ts &...args) {
555
619k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
619k
557
619k
    // Recurse to the next argument.
558
619k
    return combine(length, buffer_ptr, buffer_end, args...);
559
619k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, char const*>(unsigned long, char*, char*, llvm::hash_code const&, char const* const&)
Line
Count
Source
554
3
                    const T &arg, const Ts &...args) {
555
3
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3
557
3
    // Recurse to the next argument.
558
3
    return combine(length, buffer_ptr, buffer_end, args...);
559
3
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<char const*>(unsigned long, char*, char*, char const* const&)
Line
Count
Source
554
6.03k
                    const T &arg, const Ts &...args) {
555
6.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
6.03k
557
6.03k
    // Recurse to the next argument.
558
6.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
6.03k
  }
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
554
46.2k
                    const T &arg, const Ts &...args) {
555
46.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
46.2k
557
46.2k
    // Recurse to the next argument.
558
46.2k
    return combine(length, buffer_ptr, buffer_end, args...);
559
46.2k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::GlobalValue const*>(unsigned long, char*, char*, llvm::GlobalValue const* const&)
Line
Count
Source
554
46.2k
                    const T &arg, const Ts &...args) {
555
46.2k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
46.2k
557
46.2k
    // Recurse to the next argument.
558
46.2k
    return combine(length, buffer_ptr, buffer_end, args...);
559
46.2k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::hash_code, llvm::BlockAddress const*>(unsigned long, char*, char*, llvm::hash_code const&, llvm::BlockAddress const* const&)
Line
Count
Source
554
12
                    const T &arg, const Ts &...args) {
555
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
12
557
12
    // Recurse to the next argument.
558
12
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
12
                    const T &arg, const Ts &...args) {
555
12
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
12
557
12
    // Recurse to the next argument.
558
12
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
14
                    const T &arg, const Ts &...args) {
555
14
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
14
557
14
    // Recurse to the next argument.
558
14
    return combine(length, buffer_ptr, buffer_end, args...);
559
14
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MCSymbol* const&)
Line
Count
Source
554
247
                    const T &arg, const Ts &...args) {
555
247
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
247
557
247
    // Recurse to the next argument.
558
247
    return combine(length, buffer_ptr, buffer_end, args...);
559
247
  }
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
554
8
                    const T &arg, const Ts &...args) {
555
8
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
8
557
8
    // Recurse to the next argument.
558
8
    return combine(length, buffer_ptr, buffer_end, args...);
559
8
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineBasicBlock*>(unsigned long, char*, char*, llvm::MachineBasicBlock* const&)
Line
Count
Source
554
1.71M
                    const T &arg, const Ts &...args) {
555
1.71M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.71M
557
1.71M
    // Recurse to the next argument.
558
1.71M
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.71M
  }
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
554
3.69M
                    const T &arg, const Ts &...args) {
555
3.69M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.69M
557
3.69M
    // Recurse to the next argument.
558
3.69M
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.69M
  }
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
554
432k
                    const T &arg, const Ts &...args) {
555
432k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
432k
557
432k
    // Recurse to the next argument.
558
432k
    return combine(length, buffer_ptr, buffer_end, args...);
559
432k
  }
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
554
44.8M
                    const T &arg, const Ts &...args) {
555
44.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
44.8M
557
44.8M
    // Recurse to the next argument.
558
44.8M
    return combine(length, buffer_ptr, buffer_end, args...);
559
44.8M
  }
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
554
44.8M
                    const T &arg, const Ts &...args) {
555
44.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
44.8M
557
44.8M
    // Recurse to the next argument.
558
44.8M
    return combine(length, buffer_ptr, buffer_end, args...);
559
44.8M
  }
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
554
44.8M
                    const T &arg, const Ts &...args) {
555
44.8M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
44.8M
557
44.8M
    // Recurse to the next argument.
558
44.8M
    return combine(length, buffer_ptr, buffer_end, args...);
559
44.8M
  }
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
554
22.3M
                    const T &arg, const Ts &...args) {
555
22.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
22.3M
557
22.3M
    // Recurse to the next argument.
558
22.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
22.3M
  }
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
554
22.3M
                    const T &arg, const Ts &...args) {
555
22.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
22.3M
557
22.3M
    // Recurse to the next argument.
558
22.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
22.3M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<long long>(unsigned long, char*, char*, long long const&)
Line
Count
Source
554
26.5M
                    const T &arg, const Ts &...args) {
555
26.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
26.5M
557
26.5M
    // Recurse to the next argument.
558
26.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
26.5M
  }
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
554
15
                    const T &arg, const Ts &...args) {
555
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15
557
15
    // Recurse to the next argument.
558
15
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
15
                    const T &arg, const Ts &...args) {
555
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15
557
15
    // Recurse to the next argument.
558
15
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
15
                    const T &arg, const Ts &...args) {
555
15
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15
557
15
    // Recurse to the next argument.
558
15
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
774
                    const T &arg, const Ts &...args) {
555
774
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
774
557
774
    // Recurse to the next argument.
558
774
    return combine(length, buffer_ptr, buffer_end, args...);
559
774
  }
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
554
774
                    const T &arg, const Ts &...args) {
555
774
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
774
557
774
    // Recurse to the next argument.
558
774
    return combine(length, buffer_ptr, buffer_end, args...);
559
774
  }
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
554
774
                    const T &arg, const Ts &...args) {
555
774
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
774
557
774
    // Recurse to the next argument.
558
774
    return combine(length, buffer_ptr, buffer_end, args...);
559
774
  }
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
554
1.71M
                    const T &arg, const Ts &...args) {
555
1.71M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.71M
557
1.71M
    // Recurse to the next argument.
558
1.71M
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.71M
  }
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
554
1.71M
                    const T &arg, const Ts &...args) {
555
1.71M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.71M
557
1.71M
    // Recurse to the next argument.
558
1.71M
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.71M
  }
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
554
619k
                    const T &arg, const Ts &...args) {
555
619k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
619k
557
619k
    // Recurse to the next argument.
558
619k
    return combine(length, buffer_ptr, buffer_end, args...);
559
619k
  }
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
554
619k
                    const T &arg, const Ts &...args) {
555
619k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
619k
557
619k
    // Recurse to the next argument.
558
619k
    return combine(length, buffer_ptr, buffer_end, args...);
559
619k
  }
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
554
435k
                    const T &arg, const Ts &...args) {
555
435k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
435k
557
435k
    // Recurse to the next argument.
558
435k
    return combine(length, buffer_ptr, buffer_end, args...);
559
435k
  }
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
554
435k
                    const T &arg, const Ts &...args) {
555
435k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
435k
557
435k
    // Recurse to the next argument.
558
435k
    return combine(length, buffer_ptr, buffer_end, args...);
559
435k
  }
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
554
435k
                    const T &arg, const Ts &...args) {
555
435k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
435k
557
435k
    // Recurse to the next argument.
558
435k
    return combine(length, buffer_ptr, buffer_end, args...);
559
435k
  }
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
554
6.03k
                    const T &arg, const Ts &...args) {
555
6.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
6.03k
557
6.03k
    // Recurse to the next argument.
558
6.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
6.03k
  }
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
554
6.03k
                    const T &arg, const Ts &...args) {
555
6.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
6.03k
557
6.03k
    // Recurse to the next argument.
558
6.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
6.03k
  }
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
554
6.03k
                    const T &arg, const Ts &...args) {
555
6.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
6.03k
557
6.03k
    // Recurse to the next argument.
558
6.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
6.03k
  }
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
554
3.78M
                    const T &arg, const Ts &...args) {
555
3.78M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.78M
557
3.78M
    // Recurse to the next argument.
558
3.78M
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.78M
  }
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
554
3.78M
                    const T &arg, const Ts &...args) {
555
3.78M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.78M
557
3.78M
    // Recurse to the next argument.
558
3.78M
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.78M
  }
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
554
3.78M
                    const T &arg, const Ts &...args) {
555
3.78M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.78M
557
3.78M
    // Recurse to the next argument.
558
3.78M
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.78M
  }
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
554
382
                    const T &arg, const Ts &...args) {
555
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
382
557
382
    // Recurse to the next argument.
558
382
    return combine(length, buffer_ptr, buffer_end, args...);
559
382
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::BlockAddress const*, long long>(unsigned long, char*, char*, unsigned int const&, llvm::BlockAddress const* const&, long long const&)
Line
Count
Source
554
382
                    const T &arg, const Ts &...args) {
555
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
382
557
382
    // Recurse to the next argument.
558
382
    return combine(length, buffer_ptr, buffer_end, args...);
559
382
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::BlockAddress const*, long long>(unsigned long, char*, char*, llvm::BlockAddress const* const&, long long const&)
Line
Count
Source
554
382
                    const T &arg, const Ts &...args) {
555
382
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
382
557
382
    // Recurse to the next argument.
558
382
    return combine(length, buffer_ptr, buffer_end, args...);
559
382
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, unsigned int const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, unsigned int const* const&)
Line
Count
Source
554
18
                    const T &arg, const Ts &...args) {
555
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18
557
18
    // Recurse to the next argument.
558
18
    return combine(length, buffer_ptr, buffer_end, args...);
559
18
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int const*>(unsigned long, char*, char*, unsigned int const&, unsigned int const* const&)
Line
Count
Source
554
18
                    const T &arg, const Ts &...args) {
555
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18
557
18
    // Recurse to the next argument.
558
18
    return combine(length, buffer_ptr, buffer_end, args...);
559
18
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int const*>(unsigned long, char*, char*, unsigned int const* const&)
Line
Count
Source
554
18
                    const T &arg, const Ts &...args) {
555
18
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18
557
18
    // Recurse to the next argument.
558
18
    return combine(length, buffer_ptr, buffer_end, args...);
559
18
  }
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MDNode const*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MDNode const* const&)
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDNode const*>(unsigned long, char*, char*, unsigned int const&, llvm::MDNode const* const&)
Unexecuted instantiation: llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDNode const*>(unsigned long, char*, char*, llvm::MDNode const* const&)
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MachineOperand::MachineOperandType, unsigned int, llvm::MCSymbol*>(unsigned long, char*, char*, llvm::MachineOperand::MachineOperandType const&, unsigned int const&, llvm::MCSymbol* const&)
Line
Count
Source
554
233
                    const T &arg, const Ts &...args) {
555
233
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
233
557
233
    // Recurse to the next argument.
558
233
    return combine(length, buffer_ptr, buffer_end, args...);
559
233
  }
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
554
233
                    const T &arg, const Ts &...args) {
555
233
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
233
557
233
    // Recurse to the next argument.
558
233
    return combine(length, buffer_ptr, buffer_end, args...);
559
233
  }
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
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
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
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
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
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::InlineAsm::AsmDialect, llvm::FunctionType*>(unsigned long, char*, char*, bool const&, llvm::InlineAsm::AsmDialect const&, llvm::FunctionType* const&)
Line
Count
Source
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
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
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::FunctionType*>(unsigned long, char*, char*, llvm::FunctionType* const&)
Line
Count
Source
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
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
554
17.5M
                    const T &arg, const Ts &...args) {
555
17.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
17.5M
557
17.5M
    // Recurse to the next argument.
558
17.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
17.5M
  }
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
554
17.5M
                    const T &arg, const Ts &...args) {
555
17.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
17.5M
557
17.5M
    // Recurse to the next argument.
558
17.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
17.5M
  }
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
554
17.5M
                    const T &arg, const Ts &...args) {
555
17.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
17.5M
557
17.5M
    // Recurse to the next argument.
558
17.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
17.5M
  }
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
554
25.7M
                    const T &arg, const Ts &...args) {
555
25.7M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.7M
557
25.7M
    // Recurse to the next argument.
558
25.7M
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.7M
  }
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
554
7.07M
                    const T &arg, const Ts &...args) {
555
7.07M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
7.07M
557
7.07M
    // Recurse to the next argument.
558
7.07M
    return combine(length, buffer_ptr, buffer_end, args...);
559
7.07M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
554
15.3M
                    const T &arg, const Ts &...args) {
555
15.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15.3M
557
15.3M
    // Recurse to the next argument.
558
15.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
15.3M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
554
15.3M
                    const T &arg, const Ts &...args) {
555
15.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15.3M
557
15.3M
    // Recurse to the next argument.
558
15.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
15.3M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::Metadata*, bool>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::Metadata* const&, bool const&)
Line
Count
Source
554
15.3M
                    const T &arg, const Ts &...args) {
555
15.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15.3M
557
15.3M
    // Recurse to the next argument.
558
15.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
15.3M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, bool>(unsigned long, char*, char*, llvm::Metadata* const&, bool const&)
Line
Count
Source
554
15.3M
                    const T &arg, const Ts &...args) {
555
15.3M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
15.3M
557
15.3M
    // Recurse to the next argument.
558
15.3M
    return combine(length, buffer_ptr, buffer_end, args...);
559
15.3M
  }
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
554
114
                    const T &arg, const Ts &...args) {
555
114
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
114
557
114
    // Recurse to the next argument.
558
114
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
2.03k
                    const T &arg, const Ts &...args) {
555
2.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.03k
557
2.03k
    // Recurse to the next argument.
558
2.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.03k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*>(unsigned long, char*, char*, llvm::MDString* const&)
Line
Count
Source
554
53.5k
                    const T &arg, const Ts &...args) {
555
53.5k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
53.5k
557
53.5k
    // Recurse to the next argument.
558
53.5k
    return combine(length, buffer_ptr, buffer_end, args...);
559
53.5k
  }
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
554
784
                    const T &arg, const Ts &...args) {
555
784
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
784
557
784
    // Recurse to the next argument.
558
784
    return combine(length, buffer_ptr, buffer_end, args...);
559
784
  }
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
554
83
                    const T &arg, const Ts &...args) {
555
83
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
83
557
83
    // Recurse to the next argument.
558
83
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
18.9k
                    const T &arg, const Ts &...args) {
555
18.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18.9k
557
18.9k
    // Recurse to the next argument.
558
18.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
4.03k
                    const T &arg, const Ts &...args) {
555
4.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.03k
557
4.03k
    // Recurse to the next argument.
558
4.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.03k
  }
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
554
4.03k
                    const T &arg, const Ts &...args) {
555
4.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.03k
557
4.03k
    // Recurse to the next argument.
558
4.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.03k
  }
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
554
4.03k
                    const T &arg, const Ts &...args) {
555
4.03k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.03k
557
4.03k
    // Recurse to the next argument.
558
4.03k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.03k
  }
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
554
4.72k
                    const T &arg, const Ts &...args) {
555
4.72k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.72k
557
4.72k
    // Recurse to the next argument.
558
4.72k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.72k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&)
Line
Count
Source
554
138k
                    const T &arg, const Ts &...args) {
555
138k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
138k
557
138k
    // Recurse to the next argument.
558
138k
    return combine(length, buffer_ptr, buffer_end, args...);
559
138k
  }
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
554
18.1k
                    const T &arg, const Ts &...args) {
555
18.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18.1k
557
18.1k
    // Recurse to the next argument.
558
18.1k
    return combine(length, buffer_ptr, buffer_end, args...);
559
18.1k
  }
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
554
18.1k
                    const T &arg, const Ts &...args) {
555
18.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18.1k
557
18.1k
    // Recurse to the next argument.
558
18.1k
    return combine(length, buffer_ptr, buffer_end, args...);
559
18.1k
  }
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
554
18.1k
                    const T &arg, const Ts &...args) {
555
18.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18.1k
557
18.1k
    // Recurse to the next argument.
558
18.1k
    return combine(length, buffer_ptr, buffer_end, args...);
559
18.1k
  }
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
554
18.1k
                    const T &arg, const Ts &...args) {
555
18.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
18.1k
557
18.1k
    // Recurse to the next argument.
558
18.1k
    return combine(length, buffer_ptr, buffer_end, args...);
559
18.1k
  }
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
554
23.7k
                    const T &arg, const Ts &...args) {
555
23.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
23.7k
557
23.7k
    // Recurse to the next argument.
558
23.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
23.7k
  }
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
554
23.7k
                    const T &arg, const Ts &...args) {
555
23.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
23.7k
557
23.7k
    // Recurse to the next argument.
558
23.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
23.7k
  }
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
554
5.70k
                    const T &arg, const Ts &...args) {
555
5.70k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
5.70k
557
5.70k
    // Recurse to the next argument.
558
5.70k
    return combine(length, buffer_ptr, buffer_end, args...);
559
5.70k
  }
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
554
5.70k
                    const T &arg, const Ts &...args) {
555
5.70k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
5.70k
557
5.70k
    // Recurse to the next argument.
558
5.70k
    return combine(length, buffer_ptr, buffer_end, args...);
559
5.70k
  }
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
554
5.70k
                    const T &arg, const Ts &...args) {
555
5.70k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
5.70k
557
5.70k
    // Recurse to the next argument.
558
5.70k
    return combine(length, buffer_ptr, buffer_end, args...);
559
5.70k
  }
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
554
5.70k
                    const T &arg, const Ts &...args) {
555
5.70k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
5.70k
557
5.70k
    // Recurse to the next argument.
558
5.70k
    return combine(length, buffer_ptr, buffer_end, args...);
559
5.70k
  }
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
554
5.70k
                    const T &arg, const Ts &...args) {
555
5.70k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
5.70k
557
5.70k
    // Recurse to the next argument.
558
5.70k
    return combine(length, buffer_ptr, buffer_end, args...);
559
5.70k
  }
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
554
13.4k
                    const T &arg, const Ts &...args) {
555
13.4k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
13.4k
557
13.4k
    // Recurse to the next argument.
558
13.4k
    return combine(length, buffer_ptr, buffer_end, args...);
559
13.4k
  }
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
554
117k
                    const T &arg, const Ts &...args) {
555
117k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
117k
557
117k
    // Recurse to the next argument.
558
117k
    return combine(length, buffer_ptr, buffer_end, args...);
559
117k
  }
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
554
117k
                    const T &arg, const Ts &...args) {
555
117k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
117k
557
117k
    // Recurse to the next argument.
558
117k
    return combine(length, buffer_ptr, buffer_end, args...);
559
117k
  }
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
554
27.6k
                    const T &arg, const Ts &...args) {
555
27.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
27.6k
557
27.6k
    // Recurse to the next argument.
558
27.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
27.6k
  }
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
554
27.6k
                    const T &arg, const Ts &...args) {
555
27.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
27.6k
557
27.6k
    // Recurse to the next argument.
558
27.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
27.6k
  }
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
554
27.6k
                    const T &arg, const Ts &...args) {
555
27.6k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
27.6k
557
27.6k
    // Recurse to the next argument.
558
27.6k
    return combine(length, buffer_ptr, buffer_end, args...);
559
27.6k
  }
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
554
31.9k
                    const T &arg, const Ts &...args) {
555
31.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
31.9k
557
31.9k
    // Recurse to the next argument.
558
31.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
31.9k
  }
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
554
3.24k
                    const T &arg, const Ts &...args) {
555
3.24k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.24k
557
3.24k
    // Recurse to the next argument.
558
3.24k
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.24k
  }
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
554
3.24k
                    const T &arg, const Ts &...args) {
555
3.24k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
3.24k
557
3.24k
    // Recurse to the next argument.
558
3.24k
    return combine(length, buffer_ptr, buffer_end, args...);
559
3.24k
  }
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
554
65
                    const T &arg, const Ts &...args) {
555
65
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
65
557
65
    // Recurse to the next argument.
558
65
    return combine(length, buffer_ptr, buffer_end, args...);
559
65
  }
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
554
22.0k
                    const T &arg, const Ts &...args) {
555
22.0k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
22.0k
557
22.0k
    // Recurse to the next argument.
558
22.0k
    return combine(length, buffer_ptr, buffer_end, args...);
559
22.0k
  }
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
554
504
                    const T &arg, const Ts &...args) {
555
504
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
504
557
504
    // Recurse to the next argument.
558
504
    return combine(length, buffer_ptr, buffer_end, args...);
559
504
  }
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
554
133
                    const T &arg, const Ts &...args) {
555
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
133
557
133
    // Recurse to the next argument.
558
133
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
133
                    const T &arg, const Ts &...args) {
555
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
133
557
133
    // Recurse to the next argument.
558
133
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
133
                    const T &arg, const Ts &...args) {
555
133
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
133
557
133
    // Recurse to the next argument.
558
133
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
1.21k
                    const T &arg, const Ts &...args) {
555
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.21k
557
1.21k
    // Recurse to the next argument.
558
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
1.21k
                    const T &arg, const Ts &...args) {
555
1.21k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.21k
557
1.21k
    // Recurse to the next argument.
558
1.21k
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, bool, bool, llvm::Metadata*>(unsigned long, char*, char*, llvm::Metadata* const&, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, llvm::Metadata*>(unsigned long, char*, char*, bool const&, llvm::Metadata* const&)
Line
Count
Source
554
2.85k
                    const T &arg, const Ts &...args) {
555
2.85k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
2.85k
557
2.85k
    // Recurse to the next argument.
558
2.85k
    return combine(length, buffer_ptr, buffer_end, args...);
559
2.85k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, llvm::Metadata* const&, llvm::MDString* const&, llvm::Metadata* const&, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
554
21.9k
                    const T &arg, const Ts &...args) {
555
21.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
21.9k
557
21.9k
    // Recurse to the next argument.
558
21.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
21.9k
  }
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
554
21.9k
                    const T &arg, const Ts &...args) {
555
21.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
21.9k
557
21.9k
    // Recurse to the next argument.
558
21.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
21.9k
  }
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
554
21.9k
                    const T &arg, const Ts &...args) {
555
21.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
21.9k
557
21.9k
    // Recurse to the next argument.
558
21.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
21.9k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, unsigned int, unsigned int>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, unsigned int const&, unsigned int const&)
Line
Count
Source
554
21.9k
                    const T &arg, const Ts &...args) {
555
21.9k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
21.9k
557
21.9k
    // Recurse to the next argument.
558
21.9k
    return combine(length, buffer_ptr, buffer_end, args...);
559
21.9k
  }
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
554
56
                    const T &arg, const Ts &...args) {
555
56
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
56
557
56
    // Recurse to the next argument.
558
56
    return combine(length, buffer_ptr, buffer_end, args...);
559
56
  }
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
554
56
                    const T &arg, const Ts &...args) {
555
56
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
56
557
56
    // Recurse to the next argument.
558
56
    return combine(length, buffer_ptr, buffer_end, args...);
559
56
  }
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
167
                    const T &arg, const Ts &...args) {
555
167
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
167
557
167
    // Recurse to the next argument.
558
167
    return combine(length, buffer_ptr, buffer_end, args...);
559
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
554
1.92k
                    const T &arg, const Ts &...args) {
555
1.92k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.92k
557
1.92k
    // Recurse to the next argument.
558
1.92k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.92k
  }
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
554
1.92k
                    const T &arg, const Ts &...args) {
555
1.92k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.92k
557
1.92k
    // Recurse to the next argument.
558
1.92k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.92k
  }
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
554
1.92k
                    const T &arg, const Ts &...args) {
555
1.92k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.92k
557
1.92k
    // Recurse to the next argument.
558
1.92k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.92k
  }
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
554
1.92k
                    const T &arg, const Ts &...args) {
555
1.92k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
1.92k
557
1.92k
    // Recurse to the next argument.
558
1.92k
    return combine(length, buffer_ptr, buffer_end, args...);
559
1.92k
  }
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
554
4.23k
                    const T &arg, const Ts &...args) {
555
4.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.23k
557
4.23k
    // Recurse to the next argument.
558
4.23k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.23k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::MDString*, llvm::MDString*>(unsigned long, char*, char*, unsigned int const&, llvm::MDString* const&, llvm::MDString* const&)
Line
Count
Source
554
4.23k
                    const T &arg, const Ts &...args) {
555
4.23k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
4.23k
557
4.23k
    // Recurse to the next argument.
558
4.23k
    return combine(length, buffer_ptr, buffer_end, args...);
559
4.23k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
554
143
                    const T &arg, const Ts &...args) {
555
143
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
143
557
143
    // Recurse to the next argument.
558
143
    return combine(length, buffer_ptr, buffer_end, args...);
559
143
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, llvm::Metadata*, llvm::Metadata*>(unsigned long, char*, char*, unsigned int const&, llvm::Metadata* const&, llvm::Metadata* const&)
Line
Count
Source
554
143
                    const T &arg, const Ts &...args) {
555
143
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
143
557
143
    // Recurse to the next argument.
558
143
    return combine(length, buffer_ptr, buffer_end, args...);
559
143
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::ArrayType*, unsigned int>(unsigned long, char*, char*, llvm::ArrayType* const&, unsigned int const&)
Line
Count
Source
554
60.1k
                    const T &arg, const Ts &...args) {
555
60.1k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
60.1k
557
60.1k
    // Recurse to the next argument.
558
60.1k
    return combine(length, buffer_ptr, buffer_end, args...);
559
60.1k
  }
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
554
197k
                    const T &arg, const Ts &...args) {
555
197k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
197k
557
197k
    // Recurse to the next argument.
558
197k
    return combine(length, buffer_ptr, buffer_end, args...);
559
197k
  }
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
554
220k
                    const T &arg, const Ts &...args) {
555
220k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
220k
557
220k
    // Recurse to the next argument.
558
220k
    return combine(length, buffer_ptr, buffer_end, args...);
559
220k
  }
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
554
17.5M
                    const T &arg, const Ts &...args) {
555
17.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
17.5M
557
17.5M
    // Recurse to the next argument.
558
17.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
17.5M
  }
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
554
25.3k
                    const T &arg, const Ts &...args) {
555
25.3k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
25.3k
557
25.3k
    // Recurse to the next argument.
558
25.3k
    return combine(length, buffer_ptr, buffer_end, args...);
559
25.3k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::MCSymbol const*, unsigned int, unsigned int, bool, bool, unsigned int, bool>(unsigned long, char*, char*, llvm::MCSymbol const* const&, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&, bool const&)
Line
Count
Source
554
29.7k
                    const T &arg, const Ts &...args) {
555
29.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
29.7k
557
29.7k
    // Recurse to the next argument.
558
29.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
29.7k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, unsigned int, bool, bool, unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, unsigned int const&, bool const&, bool const&, unsigned int const&, bool const&)
Line
Count
Source
554
29.7k
                    const T &arg, const Ts &...args) {
555
29.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
29.7k
557
29.7k
    // Recurse to the next argument.
558
29.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
29.7k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<unsigned int, bool, bool, unsigned int, bool>(unsigned long, char*, char*, unsigned int const&, bool const&, bool const&, unsigned int const&, bool const&)
Line
Count
Source
554
29.7k
                    const T &arg, const Ts &...args) {
555
29.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
29.7k
557
29.7k
    // Recurse to the next argument.
558
29.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
29.7k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, bool, unsigned int, bool>(unsigned long, char*, char*, bool const&, bool const&, unsigned int const&, bool const&)
Line
Count
Source
554
29.7k
                    const T &arg, const Ts &...args) {
555
29.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
29.7k
557
29.7k
    // Recurse to the next argument.
558
29.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
29.7k
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<bool, unsigned int, bool>(unsigned long, char*, char*, bool const&, unsigned int const&, bool const&)
Line
Count
Source
554
29.7k
                    const T &arg, const Ts &...args) {
555
29.7k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
29.7k
557
29.7k
    // Recurse to the next argument.
558
29.7k
    return combine(length, buffer_ptr, buffer_end, args...);
559
29.7k
  }
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
554
7.41M
                    const T &arg, const Ts &...args) {
555
7.41M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
7.41M
557
7.41M
    // Recurse to the next argument.
558
7.41M
    return combine(length, buffer_ptr, buffer_end, args...);
559
7.41M
  }
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
554
20.2M
                    const T &arg, const Ts &...args) {
555
20.2M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
20.2M
557
20.2M
    // Recurse to the next argument.
558
20.2M
    return combine(length, buffer_ptr, buffer_end, args...);
559
20.2M
  }
llvm::hash_code llvm::hashing::detail::hash_combine_recursive_helper::combine<llvm::Value*>(unsigned long, char*, char*, llvm::Value* const&)
Line
Count
Source
554
28.5M
                    const T &arg, const Ts &...args) {
555
28.5M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
28.5M
557
28.5M
    // Recurse to the next argument.
558
28.5M
    return combine(length, buffer_ptr, buffer_end, args...);
559
28.5M
  }
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
554
12.6M
                    const T &arg, const Ts &...args) {
555
12.6M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
12.6M
557
12.6M
    // Recurse to the next argument.
558
12.6M
    return combine(length, buffer_ptr, buffer_end, args...);
559
12.6M
  }
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
554
12.6M
                    const T &arg, const Ts &...args) {
555
12.6M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
12.6M
557
12.6M
    // Recurse to the next argument.
558
12.6M
    return combine(length, buffer_ptr, buffer_end, args...);
559
12.6M
  }
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
554
230k
                    const T &arg, const Ts &...args) {
555
230k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
230k
557
230k
    // Recurse to the next argument.
558
230k
    return combine(length, buffer_ptr, buffer_end, args...);
559
230k
  }
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
554
230k
                    const T &arg, const Ts &...args) {
555
230k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
230k
557
230k
    // Recurse to the next argument.
558
230k
    return combine(length, buffer_ptr, buffer_end, args...);
559
230k
  }
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
554
8.26M
                    const T &arg, const Ts &...args) {
555
8.26M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
8.26M
557
8.26M
    // Recurse to the next argument.
558
8.26M
    return combine(length, buffer_ptr, buffer_end, args...);
559
8.26M
  }
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
554
8.26M
                    const T &arg, const Ts &...args) {
555
8.26M
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
8.26M
557
8.26M
    // Recurse to the next argument.
558
8.26M
    return combine(length, buffer_ptr, buffer_end, args...);
559
8.26M
  }
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
554
371k
                    const T &arg, const Ts &...args) {
555
371k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
371k
557
371k
    // Recurse to the next argument.
558
371k
    return combine(length, buffer_ptr, buffer_end, args...);
559
371k
  }
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
554
493k
                    const T &arg, const Ts &...args) {
555
493k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
493k
557
493k
    // Recurse to the next argument.
558
493k
    return combine(length, buffer_ptr, buffer_end, args...);
559
493k
  }
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
554
122k
                    const T &arg, const Ts &...args) {
555
122k
    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
556
122k
557
122k
    // Recurse to the next argument.
558
122k
    return combine(length, buffer_ptr, buffer_end, args...);
559
122k
  }
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
554
122k
                    const T &arg, const Ts &...args) {
555
122k
    buffer_ptr = combine_data(length, buffer_ptr,