Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/YAMLTraits.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/Support/YAMLTraits.h --------------------------------*- 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
#ifndef LLVM_SUPPORT_YAMLTRAITS_H
10
#define LLVM_SUPPORT_YAMLTRAITS_H
11
12
#include "llvm/ADT/Optional.h"
13
#include "llvm/ADT/SmallVector.h"
14
#include "llvm/ADT/StringExtras.h"
15
#include "llvm/ADT/StringMap.h"
16
#include "llvm/ADT/StringRef.h"
17
#include "llvm/ADT/Twine.h"
18
#include "llvm/Support/AlignOf.h"
19
#include "llvm/Support/Allocator.h"
20
#include "llvm/Support/Endian.h"
21
#include "llvm/Support/Regex.h"
22
#include "llvm/Support/SourceMgr.h"
23
#include "llvm/Support/YAMLParser.h"
24
#include "llvm/Support/raw_ostream.h"
25
#include <cassert>
26
#include <cctype>
27
#include <cstddef>
28
#include <cstdint>
29
#include <iterator>
30
#include <map>
31
#include <memory>
32
#include <new>
33
#include <string>
34
#include <system_error>
35
#include <type_traits>
36
#include <vector>
37
38
namespace llvm {
39
namespace yaml {
40
41
enum class NodeKind : uint8_t {
42
  Scalar,
43
  Map,
44
  Sequence,
45
};
46
47
struct EmptyContext {};
48
49
/// This class should be specialized by any type that needs to be converted
50
/// to/from a YAML mapping.  For example:
51
///
52
///     struct MappingTraits<MyStruct> {
53
///       static void mapping(IO &io, MyStruct &s) {
54
///         io.mapRequired("name", s.name);
55
///         io.mapRequired("size", s.size);
56
///         io.mapOptional("age",  s.age);
57
///       }
58
///     };
59
template<class T>
60
struct MappingTraits {
61
  // Must provide:
62
  // static void mapping(IO &io, T &fields);
63
  // Optionally may provide:
64
  // static StringRef validate(IO &io, T &fields);
65
  //
66
  // The optional flow flag will cause generated YAML to use a flow mapping
67
  // (e.g. { a: 0, b: 1 }):
68
  // static const bool flow = true;
69
};
70
71
/// This class is similar to MappingTraits<T> but allows you to pass in
72
/// additional context for each map operation.  For example:
73
///
74
///     struct MappingContextTraits<MyStruct, MyContext> {
75
///       static void mapping(IO &io, MyStruct &s, MyContext &c) {
76
///         io.mapRequired("name", s.name);
77
///         io.mapRequired("size", s.size);
78
///         io.mapOptional("age",  s.age);
79
///         ++c.TimesMapped;
80
///       }
81
///     };
82
template <class T, class Context> struct MappingContextTraits {
83
  // Must provide:
84
  // static void mapping(IO &io, T &fields, Context &Ctx);
85
  // Optionally may provide:
86
  // static StringRef validate(IO &io, T &fields, Context &Ctx);
87
  //
88
  // The optional flow flag will cause generated YAML to use a flow mapping
89
  // (e.g. { a: 0, b: 1 }):
90
  // static const bool flow = true;
91
};
92
93
/// This class should be specialized by any integral type that converts
94
/// to/from a YAML scalar where there is a one-to-one mapping between
95
/// in-memory values and a string in YAML.  For example:
96
///
97
///     struct ScalarEnumerationTraits<Colors> {
98
///         static void enumeration(IO &io, Colors &value) {
99
///           io.enumCase(value, "red",   cRed);
100
///           io.enumCase(value, "blue",  cBlue);
101
///           io.enumCase(value, "green", cGreen);
102
///         }
103
///       };
104
template <typename T, typename Enable = void> struct ScalarEnumerationTraits {
105
  // Must provide:
106
  // static void enumeration(IO &io, T &value);
107
};
108
109
/// This class should be specialized by any integer type that is a union
110
/// of bit values and the YAML representation is a flow sequence of
111
/// strings.  For example:
112
///
113
///      struct ScalarBitSetTraits<MyFlags> {
114
///        static void bitset(IO &io, MyFlags &value) {
115
///          io.bitSetCase(value, "big",   flagBig);
116
///          io.bitSetCase(value, "flat",  flagFlat);
117
///          io.bitSetCase(value, "round", flagRound);
118
///        }
119
///      };
120
template <typename T, typename Enable = void> struct ScalarBitSetTraits {
121
  // Must provide:
122
  // static void bitset(IO &io, T &value);
123
};
124
125
/// Describe which type of quotes should be used when quoting is necessary.
126
/// Some non-printable characters need to be double-quoted, while some others
127
/// are fine with simple-quoting, and some don't need any quoting.
128
enum class QuotingType { None, Single, Double };
129
130
/// This class should be specialized by type that requires custom conversion
131
/// to/from a yaml scalar.  For example:
132
///
133
///    template<>
134
///    struct ScalarTraits<MyType> {
135
///      static void output(const MyType &val, void*, llvm::raw_ostream &out) {
136
///        // stream out custom formatting
137
///        out << llvm::format("%x", val);
138
///      }
139
///      static StringRef input(StringRef scalar, void*, MyType &value) {
140
///        // parse scalar and set `value`
141
///        // return empty string on success, or error string
142
///        return StringRef();
143
///      }
144
///      static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
145
///    };
146
template <typename T, typename Enable = void> struct ScalarTraits {
147
  // Must provide:
148
  //
149
  // Function to write the value as a string:
150
  // static void output(const T &value, void *ctxt, llvm::raw_ostream &out);
151
  //
152
  // Function to convert a string to a value.  Returns the empty
153
  // StringRef on success or an error string if string is malformed:
154
  // static StringRef input(StringRef scalar, void *ctxt, T &value);
155
  //
156
  // Function to determine if the value should be quoted.
157
  // static QuotingType mustQuote(StringRef);
158
};
159
160
/// This class should be specialized by type that requires custom conversion
161
/// to/from a YAML literal block scalar. For example:
162
///
163
///    template <>
164
///    struct BlockScalarTraits<MyType> {
165
///      static void output(const MyType &Value, void*, llvm::raw_ostream &Out)
166
///      {
167
///        // stream out custom formatting
168
///        Out << Value;
169
///      }
170
///      static StringRef input(StringRef Scalar, void*, MyType &Value) {
171
///        // parse scalar and set `value`
172
///        // return empty string on success, or error string
173
///        return StringRef();
174
///      }
175
///    };
176
template <typename T>
177
struct BlockScalarTraits {
178
  // Must provide:
179
  //
180
  // Function to write the value as a string:
181
  // static void output(const T &Value, void *ctx, llvm::raw_ostream &Out);
182
  //
183
  // Function to convert a string to a value.  Returns the empty
184
  // StringRef on success or an error string if string is malformed:
185
  // static StringRef input(StringRef Scalar, void *ctxt, T &Value);
186
  //
187
  // Optional:
188
  // static StringRef inputTag(T &Val, std::string Tag)
189
  // static void outputTag(const T &Val, raw_ostream &Out)
190
};
191
192
/// This class should be specialized by type that requires custom conversion
193
/// to/from a YAML scalar with optional tags. For example:
194
///
195
///    template <>
196
///    struct TaggedScalarTraits<MyType> {
197
///      static void output(const MyType &Value, void*, llvm::raw_ostream
198
///      &ScalarOut, llvm::raw_ostream &TagOut)
199
///      {
200
///        // stream out custom formatting including optional Tag
201
///        Out << Value;
202
///      }
203
///      static StringRef input(StringRef Scalar, StringRef Tag, void*, MyType
204
///      &Value) {
205
///        // parse scalar and set `value`
206
///        // return empty string on success, or error string
207
///        return StringRef();
208
///      }
209
///      static QuotingType mustQuote(const MyType &Value, StringRef) {
210
///        return QuotingType::Single;
211
///      }
212
///    };
213
template <typename T> struct TaggedScalarTraits {
214
  // Must provide:
215
  //
216
  // Function to write the value and tag as strings:
217
  // static void output(const T &Value, void *ctx, llvm::raw_ostream &ScalarOut,
218
  // llvm::raw_ostream &TagOut);
219
  //
220
  // Function to convert a string to a value.  Returns the empty
221
  // StringRef on success or an error string if string is malformed:
222
  // static StringRef input(StringRef Scalar, StringRef Tag, void *ctxt, T
223
  // &Value);
224
  //
225
  // Function to determine if the value should be quoted.
226
  // static QuotingType mustQuote(const T &Value, StringRef Scalar);
227
};
228
229
/// This class should be specialized by any type that needs to be converted
230
/// to/from a YAML sequence.  For example:
231
///
232
///    template<>
233
///    struct SequenceTraits<MyContainer> {
234
///      static size_t size(IO &io, MyContainer &seq) {
235
///        return seq.size();
236
///      }
237
///      static MyType& element(IO &, MyContainer &seq, size_t index) {
238
///        if ( index >= seq.size() )
239
///          seq.resize(index+1);
240
///        return seq[index];
241
///      }
242
///    };
243
template<typename T, typename EnableIf = void>
244
struct SequenceTraits {
245
  // Must provide:
246
  // static size_t size(IO &io, T &seq);
247
  // static T::value_type& element(IO &io, T &seq, size_t index);
248
  //
249
  // The following is option and will cause generated YAML to use
250
  // a flow sequence (e.g. [a,b,c]).
251
  // static const bool flow = true;
252
};
253
254
/// This class should be specialized by any type for which vectors of that
255
/// type need to be converted to/from a YAML sequence.
256
template<typename T, typename EnableIf = void>
257
struct SequenceElementTraits {
258
  // Must provide:
259
  // static const bool flow;
260
};
261
262
/// This class should be specialized by any type that needs to be converted
263
/// to/from a list of YAML documents.
264
template<typename T>
265
struct DocumentListTraits {
266
  // Must provide:
267
  // static size_t size(IO &io, T &seq);
268
  // static T::value_type& element(IO &io, T &seq, size_t index);
269
};
270
271
/// This class should be specialized by any type that needs to be converted
272
/// to/from a YAML mapping in the case where the names of the keys are not known
273
/// in advance, e.g. a string map.
274
template <typename T>
275
struct CustomMappingTraits {
276
  // static void inputOne(IO &io, StringRef key, T &elem);
277
  // static void output(IO &io, T &elem);
278
};
279
280
/// This class should be specialized by any type that can be represented as
281
/// a scalar, map, or sequence, decided dynamically. For example:
282
///
283
///    typedef std::unique_ptr<MyBase> MyPoly;
284
///
285
///    template<>
286
///    struct PolymorphicTraits<MyPoly> {
287
///      static NodeKind getKind(const MyPoly &poly) {
288
///        return poly->getKind();
289
///      }
290
///      static MyScalar& getAsScalar(MyPoly &poly) {
291
///        if (!poly || !isa<MyScalar>(poly))
292
///          poly.reset(new MyScalar());
293
///        return *cast<MyScalar>(poly.get());
294
///      }
295
///      // ...
296
///    };
297
template <typename T> struct PolymorphicTraits {
298
  // Must provide:
299
  // static NodeKind getKind(const T &poly);
300
  // static scalar_type &getAsScalar(T &poly);
301
  // static map_type &getAsMap(T &poly);
302
  // static sequence_type &getAsSequence(T &poly);
303
};
304
305
// Only used for better diagnostics of missing traits
306
template <typename T>
307
struct MissingTrait;
308
309
// Test if ScalarEnumerationTraits<T> is defined on type T.
310
template <class T>
311
struct has_ScalarEnumerationTraits
312
{
313
  using Signature_enumeration = void (*)(class IO&, T&);
314
315
  template <typename U>
316
  static char test(SameType<Signature_enumeration, &U::enumeration>*);
317
318
  template <typename U>
319
  static double test(...);
320
321
  static bool const value =
322
    (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
323
};
324
325
// Test if ScalarBitSetTraits<T> is defined on type T.
326
template <class T>
327
struct has_ScalarBitSetTraits
328
{
329
  using Signature_bitset = void (*)(class IO&, T&);
330
331
  template <typename U>
332
  static char test(SameType<Signature_bitset, &U::bitset>*);
333
334
  template <typename U>
335
  static double test(...);
336
337
  static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
338
};
339
340
// Test if ScalarTraits<T> is defined on type T.
341
template <class T>
342
struct has_ScalarTraits
343
{
344
  using Signature_input = StringRef (*)(StringRef, void*, T&);
345
  using Signature_output = void (*)(const T&, void*, raw_ostream&);
346
  using Signature_mustQuote = QuotingType (*)(StringRef);
347
348
  template <typename U>
349
  static char test(SameType<Signature_input, &U::input> *,
350
                   SameType<Signature_output, &U::output> *,
351
                   SameType<Signature_mustQuote, &U::mustQuote> *);
352
353
  template <typename U>
354
  static double test(...);
355
356
  static bool const value =
357
      (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
358
};
359
360
// Test if BlockScalarTraits<T> is defined on type T.
361
template <class T>
362
struct has_BlockScalarTraits
363
{
364
  using Signature_input = StringRef (*)(StringRef, void *, T &);
365
  using Signature_output = void (*)(const T &, void *, raw_ostream &);
366
367
  template <typename U>
368
  static char test(SameType<Signature_input, &U::input> *,
369
                   SameType<Signature_output, &U::output> *);
370
371
  template <typename U>
372
  static double test(...);
373
374
  static bool const value =
375
      (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
376
};
377
378
// Test if TaggedScalarTraits<T> is defined on type T.
379
template <class T> struct has_TaggedScalarTraits {
380
  using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
381
  using Signature_output = void (*)(const T &, void *, raw_ostream &,
382
                                    raw_ostream &);
383
  using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
384
385
  template <typename U>
386
  static char test(SameType<Signature_input, &U::input> *,
387
                   SameType<Signature_output, &U::output> *,
388
                   SameType<Signature_mustQuote, &U::mustQuote> *);
389
390
  template <typename U> static double test(...);
391
392
  static bool const value =
393
      (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
394
};
395
396
// Test if MappingContextTraits<T> is defined on type T.
397
template <class T, class Context> struct has_MappingTraits {
398
  using Signature_mapping = void (*)(class IO &, T &, Context &);
399
400
  template <typename U>
401
  static char test(SameType<Signature_mapping, &U::mapping>*);
402
403
  template <typename U>
404
  static double test(...);
405
406
  static bool const value =
407
      (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
408
};
409
410
// Test if MappingTraits<T> is defined on type T.
411
template <class T> struct has_MappingTraits<T, EmptyContext> {
412
  using Signature_mapping = void (*)(class IO &, T &);
413
414
  template <typename U>
415
  static char test(SameType<Signature_mapping, &U::mapping> *);
416
417
  template <typename U> static double test(...);
418
419
  static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
420
};
421
422
// Test if MappingContextTraits<T>::validate() is defined on type T.
423
template <class T, class Context> struct has_MappingValidateTraits {
424
  using Signature_validate = StringRef (*)(class IO &, T &, Context &);
425
426
  template <typename U>
427
  static char test(SameType<Signature_validate, &U::validate>*);
428
429
  template <typename U>
430
  static double test(...);
431
432
  static bool const value =
433
      (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
434
};
435
436
// Test if MappingTraits<T>::validate() is defined on type T.
437
template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
438
  using Signature_validate = StringRef (*)(class IO &, T &);
439
440
  template <typename U>
441
  static char test(SameType<Signature_validate, &U::validate> *);
442
443
  template <typename U> static double test(...);
444
445
  static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
446
};
447
448
// Test if SequenceTraits<T> is defined on type T.
449
template <class T>
450
struct has_SequenceMethodTraits
451
{
452
  using Signature_size = size_t (*)(class IO&, T&);
453
454
  template <typename U>
455
  static char test(SameType<Signature_size, &U::size>*);
456
457
  template <typename U>
458
  static double test(...);
459
460
  static bool const value =  (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
461
};
462
463
// Test if CustomMappingTraits<T> is defined on type T.
464
template <class T>
465
struct has_CustomMappingTraits
466
{
467
  using Signature_input = void (*)(IO &io, StringRef key, T &v);
468
469
  template <typename U>
470
  static char test(SameType<Signature_input, &U::inputOne>*);
471
472
  template <typename U>
473
  static double test(...);
474
475
  static bool const value =
476
      (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
477
};
478
479
// has_FlowTraits<int> will cause an error with some compilers because
480
// it subclasses int.  Using this wrapper only instantiates the
481
// real has_FlowTraits only if the template type is a class.
482
template <typename T, bool Enabled = std::is_class<T>::value>
483
class has_FlowTraits
484
{
485
public:
486
   static const bool value = false;
487
};
488
489
// Some older gcc compilers don't support straight forward tests
490
// for members, so test for ambiguity cause by the base and derived
491
// classes both defining the member.
492
template <class T>
493
struct has_FlowTraits<T, true>
494
{
495
  struct Fallback { bool flow; };
496
  struct Derived : T, Fallback { };
497
498
  template<typename C>
499
  static char (&f(SameType<bool Fallback::*, &C::flow>*))[1];
500
501
  template<typename C>
502
  static char (&f(...))[2];
503
504
  static bool const value = sizeof(f<Derived>(nullptr)) == 2;
505
};
506
507
// Test if SequenceTraits<T> is defined on type T
508
template<typename T>
509
struct has_SequenceTraits : public std::integral_constant<bool,
510
                                      has_SequenceMethodTraits<T>::value > { };
511
512
// Test if DocumentListTraits<T> is defined on type T
513
template <class T>
514
struct has_DocumentListTraits
515
{
516
  using Signature_size = size_t (*)(class IO &, T &);
517
518
  template <typename U>
519
  static char test(SameType<Signature_size, &U::size>*);
520
521
  template <typename U>
522
  static double test(...);
523
524
  static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
525
};
526
527
template <class T> struct has_PolymorphicTraits {
528
  using Signature_getKind = NodeKind (*)(const T &);
529
530
  template <typename U>
531
  static char test(SameType<Signature_getKind, &U::getKind> *);
532
533
  template <typename U> static double test(...);
534
535
  static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
536
};
537
538
209k
inline bool isNumeric(StringRef S) {
539
209k
  const static auto skipDigits = [](StringRef Input) {
540
206k
    return Input.drop_front(
541
206k
        std::min(Input.find_first_not_of("0123456789"), Input.size()));
542
206k
  };
543
209k
544
209k
  // Make S.front() and S.drop_front().front() (if S.front() is [+-]) calls
545
209k
  // safe.
546
209k
  if (S.empty() || 
S.equals("+")209k
||
S.equals("-")209k
)
547
1
    return false;
548
209k
549
209k
  if (S.equals(".nan") || 
S.equals(".NaN")209k
||
S.equals(".NAN")209k
)
550
3
    return true;
551
209k
552
209k
  // Infinity and decimal numbers can be prefixed with sign.
553
209k
  StringRef Tail = (S.front() == '-' || 
S.front() == '+'209k
) ?
S.drop_front()62
:
S209k
;
554
209k
555
209k
  // Check for infinity first, because checking for hex and oct numbers is more
556
209k
  // expensive.
557
209k
  if (Tail.equals(".inf") || 
Tail.equals(".Inf")209k
||
Tail.equals(".INF")209k
)
558
5
    return true;
559
209k
560
209k
  // Section 10.3.2 Tag Resolution
561
209k
  // YAML 1.2 Specification prohibits Base 8 and Base 16 numbers prefixed with
562
209k
  // [-+], so S should be used instead of Tail.
563
209k
  if (S.startswith("0o"))
564
2
    return S.size() > 2 &&
565
2
           S.drop_front(2).find_first_not_of("01234567") == StringRef::npos;
566
209k
567
209k
  if (S.startswith("0x"))
568
5
    return S.size() > 2 && S.drop_front(2).find_first_not_of(
569
5
                               "0123456789abcdefABCDEF") == StringRef::npos;
570
209k
571
209k
  // Parse float: [-+]? (\. [0-9]+ | [0-9]+ (\. [0-9]* )?) ([eE] [-+]? [0-9]+)?
572
209k
  S = Tail;
573
209k
574
209k
  // Handle cases when the number starts with '.' and hence needs at least one
575
209k
  // digit after dot (as opposed by number which has digits before the dot), but
576
209k
  // doesn't have one.
577
209k
  if (S.startswith(".") &&
578
209k
      
(1.18k
S.equals(".")1.18k
||
579
1.18k
       
(1.17k
S.size() > 11.17k
&&
std::strchr("0123456789", S[1]) == nullptr1.17k
)))
580
1.17k
    return false;
581
208k
582
208k
  if (S.startswith("E") || 
S.startswith("e")207k
)
583
1.17k
    return false;
584
206k
585
206k
  enum ParseState {
586
206k
    Default,
587
206k
    FoundDot,
588
206k
    FoundExponent,
589
206k
  };
590
206k
  ParseState State = Default;
591
206k
592
206k
  S = skipDigits(S);
593
206k
594
206k
  // Accept decimal integer.
595
206k
  if (S.empty())
596
566
    return true;
597
206k
598
206k
  if (S.front() == '.') {
599
17
    State = FoundDot;
600
17
    S = S.drop_front();
601
206k
  } else if (S.front() == 'e' || 
S.front() == 'E'206k
) {
602
20
    State = FoundExponent;
603
20
    S = S.drop_front();
604
206k
  } else {
605
206k
    return false;
606
206k
  }
607
37
608
37
  if (State == FoundDot) {
609
17
    S = skipDigits(S);
610
17
    if (S.empty())
611
8
      return true;
612
9
613
9
    if (S.front() == 'e' || 
S.front() == 'E'0
) {
614
9
      State = FoundExponent;
615
9
      S = S.drop_front();
616
9
    } else {
617
0
      return false;
618
0
    }
619
29
  }
620
29
621
29
  assert(State == FoundExponent && "Should have found exponent at this point.");
622
29
  if (S.empty())
623
1
    return false;
624
28
625
28
  if (S.front() == '+' || 
S.front() == '-'22
) {
626
6
    S = S.drop_front();
627
6
    if (S.empty())
628
1
      return false;
629
27
  }
630
27
631
27
  return skipDigits(S).empty();
632
27
}
633
634
209k
inline bool isNull(StringRef S) {
635
209k
  return S.equals("null") || 
S.equals("Null")209k
||
S.equals("NULL")209k
||
636
209k
         
S.equals("~")209k
;
637
209k
}
638
639
209k
inline bool isBool(StringRef S) {
640
209k
  return S.equals("true") || 
S.equals("True")209k
||
S.equals("TRUE")209k
||
641
209k
         
S.equals("false")209k
||
S.equals("False")209k
||
S.equals("FALSE")209k
;
642
209k
}
643
644
// 5.1. Character Set
645
// The allowed character range explicitly excludes the C0 control block #x0-#x1F
646
// (except for TAB #x9, LF #xA, and CR #xD which are allowed), DEL #x7F, the C1
647
// control block #x80-#x9F (except for NEL #x85 which is allowed), the surrogate
648
// block #xD800-#xDFFF, #xFFFE, and #xFFFF.
649
394k
inline QuotingType needsQuotes(StringRef S) {
650
394k
  if (S.empty())
651
184k
    return QuotingType::Single;
652
209k
  if (isspace(S.front()) || 
isspace(S.back())209k
)
653
654
    return QuotingType::Single;
654
209k
  if (isNull(S))
655
2
    return QuotingType::Single;
656
209k
  if (isBool(S))
657
6
    return QuotingType::Single;
658
209k
  if (isNumeric(S))
659
567
    return QuotingType::Single;
660
208k
661
208k
  // 7.3.3 Plain Style
662
208k
  // Plain scalars must not begin with most indicators, as this would cause
663
208k
  // ambiguity with other YAML constructs.
664
208k
  static constexpr char Indicators[] = R"(-?:\,[]{}#&*!|>'"%@`)";
665
208k
  if (S.find_first_of(Indicators) == 0)
666
2.23k
    return QuotingType::Single;
667
206k
668
206k
  QuotingType MaxQuotingNeeded = QuotingType::None;
669
2.06M
  for (unsigned char C : S) {
670
2.06M
    // Alphanum is safe.
671
2.06M
    if (isAlnum(C))
672
1.77M
      continue;
673
288k
674
288k
    switch (C) {
675
288k
    // Safe scalar characters.
676
288k
    case '_':
677
233k
    case '-':
678
233k
    case '^':
679
233k
    case '.':
680
233k
    case ',':
681
233k
    case ' ':
682
233k
    // TAB (0x9) is allowed in unquoted strings.
683
233k
    case 0x9:
684
233k
      continue;
685
233k
    // LF(0xA) and CR(0xD) may delimit values and so require at least single
686
233k
    // quotes.
687
233k
    case 0xA:
688
2
    case 0xD:
689
2
      MaxQuotingNeeded = QuotingType::Single;
690
2
      continue;
691
2
    // DEL (0x7F) are excluded from the allowed character range.
692
2
    case 0x7F:
693
0
      return QuotingType::Double;
694
2
    // Forward slash is allowed to be unquoted, but we quote it anyway.  We have
695
2
    // many tests that use FileCheck against YAML output, and this output often
696
2
    // contains paths.  If we quote backslashes but not forward slashes then
697
2
    // paths will come out either quoted or unquoted depending on which platform
698
2
    // the test is run on, making FileCheck comparisons difficult.
699
5.58k
    case '/':
700
54.4k
    default: {
701
54.4k
      // C0 control block (0x0 - 0x1F) is excluded from the allowed character
702
54.4k
      // range.
703
54.4k
      if (C <= 0x1F)
704
5
        return QuotingType::Double;
705
54.4k
706
54.4k
      // Always double quote UTF-8.
707
54.4k
      if ((C & 0x80) != 0)
708
3
        return QuotingType::Double;
709
54.4k
710
54.4k
      // The character is not safe, at least simple quoting needed.
711
54.4k
      MaxQuotingNeeded = QuotingType::Single;
712
54.4k
    }
713
288k
    }
714
288k
  }
715
206k
716
206k
  
return MaxQuotingNeeded206k
;
717
206k
}
718
719
template <typename T, typename Context>
720
struct missingTraits
721
    : public std::integral_constant<bool,
722
                                    !has_ScalarEnumerationTraits<T>::value &&
723
                                        !has_ScalarBitSetTraits<T>::value &&
724
                                        !has_ScalarTraits<T>::value &&
725
                                        !has_BlockScalarTraits<T>::value &&
726
                                        !has_TaggedScalarTraits<T>::value &&
727
                                        !has_MappingTraits<T, Context>::value &&
728
                                        !has_SequenceTraits<T>::value &&
729
                                        !has_CustomMappingTraits<T>::value &&
730
                                        !has_DocumentListTraits<T>::value &&
731
                                        !has_PolymorphicTraits<T>::value> {};
732
733
template <typename T, typename Context>
734
struct validatedMappingTraits
735
    : public std::integral_constant<
736
          bool, has_MappingTraits<T, Context>::value &&
737
                    has_MappingValidateTraits<T, Context>::value> {};
738
739
template <typename T, typename Context>
740
struct unvalidatedMappingTraits
741
    : public std::integral_constant<
742
          bool, has_MappingTraits<T, Context>::value &&
743
                    !has_MappingValidateTraits<T, Context>::value> {};
744
745
// Base class for Input and Output.
746
class IO {
747
public:
748
  IO(void *Ctxt = nullptr);
749
  virtual ~IO();
750
751
  virtual bool outputting() = 0;
752
753
  virtual unsigned beginSequence() = 0;
754
  virtual bool preflightElement(unsigned, void *&) = 0;
755
  virtual void postflightElement(void*) = 0;
756
  virtual void endSequence() = 0;
757
  virtual bool canElideEmptySequence() = 0;
758
759
  virtual unsigned beginFlowSequence() = 0;
760
  virtual bool preflightFlowElement(unsigned, void *&) = 0;
761
  virtual void postflightFlowElement(void*) = 0;
762
  virtual void endFlowSequence() = 0;
763
764
  virtual bool mapTag(StringRef Tag, bool Default=false) = 0;
765
  virtual void beginMapping() = 0;
766
  virtual void endMapping() = 0;
767
  virtual bool preflightKey(const char*, bool, bool, bool &, void *&) = 0;
768
  virtual void postflightKey(void*) = 0;
769
  virtual std::vector<StringRef> keys() = 0;
770
771
  virtual void beginFlowMapping() = 0;
772
  virtual void endFlowMapping() = 0;
773
774
  virtual void beginEnumScalar() = 0;
775
  virtual bool matchEnumScalar(const char*, bool) = 0;
776
  virtual bool matchEnumFallback() = 0;
777
  virtual void endEnumScalar() = 0;
778
779
  virtual bool beginBitSetScalar(bool &) = 0;
780
  virtual bool bitSetMatch(const char*, bool) = 0;
781
  virtual void endBitSetScalar() = 0;
782
783
  virtual void scalarString(StringRef &, QuotingType) = 0;
784
  virtual void blockScalarString(StringRef &) = 0;
785
  virtual void scalarTag(std::string &) = 0;
786
787
  virtual NodeKind getNodeKind() = 0;
788
789
  virtual void setError(const Twine &) = 0;
790
791
  template <typename T>
792
249k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
249k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal216k
) ) {
794
3.80k
      Val = ConstVal;
795
3.80k
    }
796
249k
  }
void llvm::yaml::IO::enumCase<llvm::MachineJumpTableInfo::JTEntryKind>(llvm::MachineJumpTableInfo::JTEntryKind&, char const*, llvm::MachineJumpTableInfo::JTEntryKind)
Line
Count
Source
792
174
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
174
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal78
) ) {
794
15
      Val = ConstVal;
795
15
    }
796
174
  }
void llvm::yaml::IO::enumCase<llvm::yaml::MachineStackObject::ObjectType>(llvm::yaml::MachineStackObject::ObjectType&, char const*, llvm::yaml::MachineStackObject::ObjectType)
Line
Count
Source
792
4.50k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
4.50k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal3.12k
) ) {
794
460
      Val = ConstVal;
795
460
    }
796
4.50k
  }
void llvm::yaml::IO::enumCase<llvm::yaml::FixedMachineStackObject::ObjectType>(llvm::yaml::FixedMachineStackObject::ObjectType&, char const*, llvm::yaml::FixedMachineStackObject::ObjectType)
Line
Count
Source
792
1.47k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
1.47k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal1.22k
) ) {
794
122
      Val = ConstVal;
795
122
    }
796
1.47k
  }
void llvm::yaml::IO::enumCase<llvm::TargetStackID::Value>(llvm::TargetStackID::Value&, char const*, llvm::TargetStackID::Value)
Line
Count
Source
792
6.45k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
6.45k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal4.96k
) ) {
794
495
      Val = ConstVal;
795
495
    }
796
6.45k
  }
void llvm::yaml::IO::enumCase<llvm::TypeTestResolution::Kind>(llvm::TypeTestResolution::Kind&, char const*, llvm::TypeTestResolution::Kind)
Line
Count
Source
792
425
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
425
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal250
) ) {
794
35
      Val = ConstVal;
795
35
    }
796
425
  }
void llvm::yaml::IO::enumCase<llvm::WholeProgramDevirtResolution::Kind>(llvm::WholeProgramDevirtResolution::Kind&, char const*, llvm::WholeProgramDevirtResolution::Kind)
Line
Count
Source
792
156
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
156
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal96
) ) {
794
20
      Val = ConstVal;
795
20
    }
796
156
  }
void llvm::yaml::IO::enumCase<llvm::WholeProgramDevirtResolution::ByArg::Kind>(llvm::WholeProgramDevirtResolution::ByArg::Kind&, char const*, llvm::WholeProgramDevirtResolution::ByArg::Kind)
Line
Count
Source
792
108
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
108
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal40
) ) {
794
17
      Val = ConstVal;
795
17
    }
796
108
  }
void llvm::yaml::IO::enumCase<llvm::AMDGPU::HSAMD::ValueKind>(llvm::AMDGPU::HSAMD::ValueKind&, char const*, llvm::AMDGPU::HSAMD::ValueKind)
Line
Count
Source
792
114k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
114k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal99.9k
) ) {
794
966
      Val = ConstVal;
795
966
    }
796
114k
  }
void llvm::yaml::IO::enumCase<llvm::AMDGPU::HSAMD::ValueType>(llvm::AMDGPU::HSAMD::ValueType&, char const*, llvm::AMDGPU::HSAMD::ValueType)
Line
Count
Source
792
91.5k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
91.5k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal79.9k
) ) {
794
966
      Val = ConstVal;
795
966
    }
796
91.5k
  }
void llvm::yaml::IO::enumCase<llvm::AMDGPU::HSAMD::AddressSpaceQualifier>(llvm::AMDGPU::HSAMD::AddressSpaceQualifier&, char const*, llvm::AMDGPU::HSAMD::AddressSpaceQualifier)
Line
Count
Source
792
26.3k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
26.3k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal23.1k
) ) {
794
532
      Val = ConstVal;
795
532
    }
796
26.3k
  }
void llvm::yaml::IO::enumCase<llvm::AMDGPU::HSAMD::AccessQualifier>(llvm::AMDGPU::HSAMD::AccessQualifier&, char const*, llvm::AMDGPU::HSAMD::AccessQualifier)
Line
Count
Source
792
4.00k
  void enumCase(T &Val, const char* Str, const T ConstVal) {
793
4.00k
    if ( matchEnumScalar(Str, outputting() && 
Val == ConstVal3.30k
) ) {
794
173
      Val = ConstVal;
795
173
    }
796
4.00k
  }
797
798
  // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
799
  template <typename T>
800
  void enumCase(T &Val, const char* Str, const uint32_t ConstVal) {
801
    if ( matchEnumScalar(Str, outputting() && Val == static_cast<T>(ConstVal)) ) {
802
      Val = ConstVal;
803
    }
804
  }
805
806
  template <typename FBT, typename T>
807
  void enumFallback(T &Val) {
808
    if (matchEnumFallback()) {
809
      EmptyContext Context;
810
      // FIXME: Force integral conversion to allow strong typedefs to convert.
811
      FBT Res = static_cast<typename FBT::BaseType>(Val);
812
      yamlize(*this, Res, true, Context);
813
      Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res));
814
    }
815
  }
816
817
  template <typename T>
818
  void bitSetCase(T &Val, const char* Str, const T ConstVal) {
819
    if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
820
      Val = static_cast<T>(Val | ConstVal);
821
    }
822
  }
823
824
  // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
825
  template <typename T>
826
  void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) {
827
    if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
828
      Val = static_cast<T>(Val | ConstVal);
829
    }
830
  }
831
832
  template <typename T>
833
  void maskedBitSetCase(T &Val, const char *Str, T ConstVal, T Mask) {
834
    if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
835
      Val = Val | ConstVal;
836
  }
837
838
  template <typename T>
839
  void maskedBitSetCase(T &Val, const char *Str, uint32_t ConstVal,
840
                        uint32_t Mask) {
841
    if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
842
      Val = Val | ConstVal;
843
  }
844
845
  void *getContext();
846
  void setContext(void *);
847
848
489k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
489k
    EmptyContext Ctx;
850
489k
    this->processKey(Key, Val, true, Ctx);
851
489k
  }
void llvm::yaml::IO::mapRequired<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
848
5.00k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
5.00k
    EmptyContext Ctx;
850
5.00k
    this->processKey(Key, Val, true, Ctx);
851
5.00k
  }
void llvm::yaml::IO::mapRequired<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&)
Line
Count
Source
848
9
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
9
    EmptyContext Ctx;
850
9
    this->processKey(Key, Val, true, Ctx);
851
9
  }
void llvm::yaml::IO::mapRequired<llvm::yaml::UnsignedValue>(char const*, llvm::yaml::UnsignedValue&)
Line
Count
Source
848
88.8k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
88.8k
    EmptyContext Ctx;
850
88.8k
    this->processKey(Key, Val, true, Ctx);
851
88.8k
  }
void llvm::yaml::IO::mapRequired<llvm::yaml::StringValue>(char const*, llvm::yaml::StringValue&)
Line
Count
Source
848
102k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
102k
    EmptyContext Ctx;
850
102k
    this->processKey(Key, Val, true, Ctx);
851
102k
  }
void llvm::yaml::IO::mapRequired<unsigned long long>(char const*, unsigned long long&)
Line
Count
Source
848
7.58k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
7.58k
    EmptyContext Ctx;
850
7.58k
    this->processKey(Key, Val, true, Ctx);
851
7.58k
  }
void llvm::yaml::IO::mapRequired<unsigned short>(char const*, unsigned short&)
Line
Count
Source
848
8.62k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
8.62k
    EmptyContext Ctx;
850
8.62k
    this->processKey(Key, Val, true, Ctx);
851
8.62k
  }
void llvm::yaml::IO::mapRequired<unsigned int>(char const*, unsigned int&)
Line
Count
Source
848
39.5k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
39.5k
    EmptyContext Ctx;
850
39.5k
    this->processKey(Key, Val, true, Ctx);
851
39.5k
  }
void llvm::yaml::IO::mapRequired<llvm::MachineJumpTableInfo::JTEntryKind>(char const*, llvm::MachineJumpTableInfo::JTEntryKind&)
Line
Count
Source
848
29
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
29
    EmptyContext Ctx;
850
29
    this->processKey(Key, Val, true, Ctx);
851
29
  }
void llvm::yaml::IO::mapRequired<llvm::StringRef>(char const*, llvm::StringRef&)
Line
Count
Source
848
38.2k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
38.2k
    EmptyContext Ctx;
850
38.2k
    this->processKey(Key, Val, true, Ctx);
851
38.2k
  }
void llvm::yaml::IO::mapRequired<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> > >(char const*, std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >&)
Line
Count
Source
848
96
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
96
    EmptyContext Ctx;
850
96
    this->processKey(Key, Val, true, Ctx);
851
96
  }
void llvm::yaml::IO::mapRequired<llvm::TypeIdSummary>(char const*, llvm::TypeIdSummary&)
Line
Count
Source
848
104
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
104
    EmptyContext Ctx;
850
104
    this->processKey(Key, Val, true, Ctx);
851
104
  }
void llvm::yaml::IO::mapRequired<llvm::WholeProgramDevirtResolution>(char const*, llvm::WholeProgramDevirtResolution&)
Line
Count
Source
848
52
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
52
    EmptyContext Ctx;
850
52
    this->processKey(Key, Val, true, Ctx);
851
52
  }
void llvm::yaml::IO::mapRequired<llvm::WholeProgramDevirtResolution::ByArg>(char const*, llvm::WholeProgramDevirtResolution::ByArg&)
Line
Count
Source
848
27
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
27
    EmptyContext Ctx;
850
27
    this->processKey(Key, Val, true, Ctx);
851
27
  }
void llvm::yaml::IO::mapRequired<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > >(char const*, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&)
Line
Count
Source
848
544
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
544
    EmptyContext Ctx;
850
544
    this->processKey(Key, Val, true, Ctx);
851
544
  }
void llvm::yaml::IO::mapRequired<llvm::AMDGPU::HSAMD::ValueKind>(char const*, llvm::AMDGPU::HSAMD::ValueKind&)
Line
Count
Source
848
7.63k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
7.63k
    EmptyContext Ctx;
850
7.63k
    this->processKey(Key, Val, true, Ctx);
851
7.63k
  }
void llvm::yaml::IO::mapRequired<llvm::AMDGPU::HSAMD::ValueType>(char const*, llvm::AMDGPU::HSAMD::ValueType&)
Line
Count
Source
848
7.63k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
7.63k
    EmptyContext Ctx;
850
7.63k
    this->processKey(Key, Val, true, Ctx);
851
7.63k
  }
Unexecuted instantiation: void llvm::yaml::IO::mapRequired<llvm::yaml::StringBlockVal>(char const*, llvm::yaml::StringBlockVal&)
void llvm::yaml::IO::mapRequired<llvm::msgpack::DocNode>(char const*, llvm::msgpack::DocNode&)
Line
Count
Source
848
182k
  template <typename T> void mapRequired(const char *Key, T &Val) {
849
182k
    EmptyContext Ctx;
850
182k
    this->processKey(Key, Val, true, Ctx);
851
182k
  }
852
853
  template <typename T, typename Context>
854
  void mapRequired(const char *Key, T &Val, Context &Ctx) {
855
    this->processKey(Key, Val, true, Ctx);
856
  }
857
858
175k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
175k
    EmptyContext Ctx;
860
175k
    mapOptionalWithContext(Key, Val, Ctx);
861
175k
  }
void llvm::yaml::IO::mapOptional<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&)
Line
Count
Source
858
3.59k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
3.59k
    EmptyContext Ctx;
860
3.59k
    mapOptionalWithContext(Key, Val, Ctx);
861
3.59k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&)
Line
Count
Source
858
1.69k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
1.69k
    EmptyContext Ctx;
860
1.69k
    mapOptionalWithContext(Key, Val, Ctx);
861
1.69k
  }
cc1gen_reproducer_main.cpp:void llvm::yaml::IO::mapOptional<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> > >(char const*, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&)
Line
Count
Source
858
3
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
3
    EmptyContext Ctx;
860
3
    mapOptionalWithContext(Key, Val, Ctx);
861
3
  }
void llvm::yaml::IO::mapOptional<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> > >(char const*, std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >&)
Line
Count
Source
858
23.2k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
23.2k
    EmptyContext Ctx;
860
23.2k
    mapOptionalWithContext(Key, Val, Ctx);
861
23.2k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<unsigned int> >(char const*, llvm::Optional<unsigned int>&)
Line
Count
Source
858
13.5k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
13.5k
    EmptyContext Ctx;
860
13.5k
    mapOptionalWithContext(Key, Val, Ctx);
861
13.5k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<llvm::yaml::SIArgument> >(char const*, llvm::Optional<llvm::yaml::SIArgument>&)
Line
Count
Source
858
95.6k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
95.6k
    EmptyContext Ctx;
860
95.6k
    mapOptionalWithContext(Key, Val, Ctx);
861
95.6k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<llvm::yaml::SIArgumentInfo> >(char const*, llvm::Optional<llvm::yaml::SIArgumentInfo>&)
Line
Count
Source
858
6.00k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
6.00k
    EmptyContext Ctx;
860
6.00k
    mapOptionalWithContext(Key, Val, Ctx);
861
6.00k
  }
void llvm::yaml::IO::mapOptional<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > > >(char const*, std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >&)
Line
Count
Source
858
73
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
73
    EmptyContext Ctx;
860
73
    mapOptionalWithContext(Key, Val, Ctx);
861
73
  }
void llvm::yaml::IO::mapOptional<unsigned int>(char const*, unsigned int&)
Line
Count
Source
858
5.95k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
5.95k
    EmptyContext Ctx;
860
5.95k
    mapOptionalWithContext(Key, Val, Ctx);
861
5.95k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >(char const*, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&)
Line
Count
Source
858
899
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
899
    EmptyContext Ctx;
860
899
    mapOptionalWithContext(Key, Val, Ctx);
861
899
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> > >(char const*, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&)
Line
Count
Source
858
192
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
192
    EmptyContext Ctx;
860
192
    mapOptionalWithContext(Key, Val, Ctx);
861
192
  }
void llvm::yaml::IO::mapOptional<unsigned long long>(char const*, unsigned long long&)
Line
Count
Source
858
598
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
598
    EmptyContext Ctx;
860
598
    mapOptionalWithContext(Key, Val, Ctx);
861
598
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> > >(char const*, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&)
Line
Count
Source
858
192
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
192
    EmptyContext Ctx;
860
192
    mapOptionalWithContext(Key, Val, Ctx);
861
192
  }
void llvm::yaml::IO::mapOptional<llvm::FunctionSummary::VFuncId>(char const*, llvm::FunctionSummary::VFuncId&)
Line
Count
Source
858
48
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
48
    EmptyContext Ctx;
860
48
    mapOptionalWithContext(Key, Val, Ctx);
861
48
  }
void llvm::yaml::IO::mapOptional<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > > >(char const*, std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >&)
Line
Count
Source
858
73
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
73
    EmptyContext Ctx;
860
73
    mapOptionalWithContext(Key, Val, Ctx);
861
73
  }
void llvm::yaml::IO::mapOptional<llvm::TypeTestResolution>(char const*, llvm::TypeTestResolution&)
Line
Count
Source
858
104
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
104
    EmptyContext Ctx;
860
104
    mapOptionalWithContext(Key, Val, Ctx);
861
104
  }
void llvm::yaml::IO::mapOptional<llvm::TypeTestResolution::Kind>(char const*, llvm::TypeTestResolution::Kind&)
Line
Count
Source
858
85
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
85
    EmptyContext Ctx;
860
85
    mapOptionalWithContext(Key, Val, Ctx);
861
85
  }
void llvm::yaml::IO::mapOptional<unsigned char>(char const*, unsigned char&)
Line
Count
Source
858
85
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
85
    EmptyContext Ctx;
860
85
    mapOptionalWithContext(Key, Val, Ctx);
861
85
  }
void llvm::yaml::IO::mapOptional<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > > >(char const*, std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >&)
Line
Count
Source
858
104
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
104
    EmptyContext Ctx;
860
104
    mapOptionalWithContext(Key, Val, Ctx);
861
104
  }
void llvm::yaml::IO::mapOptional<llvm::WholeProgramDevirtResolution::Kind>(char const*, llvm::WholeProgramDevirtResolution::Kind&)
Line
Count
Source
858
52
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
52
    EmptyContext Ctx;
860
52
    mapOptionalWithContext(Key, Val, Ctx);
861
52
  }
void llvm::yaml::IO::mapOptional<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > > >(char const*, std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >&)
Line
Count
Source
858
52
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
52
    EmptyContext Ctx;
860
52
    mapOptionalWithContext(Key, Val, Ctx);
861
52
  }
void llvm::yaml::IO::mapOptional<llvm::WholeProgramDevirtResolution::ByArg::Kind>(char const*, llvm::WholeProgramDevirtResolution::ByArg::Kind&)
Line
Count
Source
858
27
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
27
    EmptyContext Ctx;
860
27
    mapOptionalWithContext(Key, Val, Ctx);
861
27
  }
void llvm::yaml::IO::mapOptional<bool>(char const*, bool&)
Line
Count
Source
858
16.5k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
16.5k
    EmptyContext Ctx;
860
16.5k
    mapOptionalWithContext(Key, Val, Ctx);
861
16.5k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> > >(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&)
Line
Count
Source
858
287
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
287
    EmptyContext Ctx;
860
287
    mapOptionalWithContext(Key, Val, Ctx);
861
287
  }
void llvm::yaml::IO::mapOptional<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata>(char const*, llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata&)
Line
Count
Source
858
288
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
288
    EmptyContext Ctx;
860
288
    mapOptionalWithContext(Key, Val, Ctx);
861
288
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> > >(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&)
Line
Count
Source
858
1.49k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
1.49k
    EmptyContext Ctx;
860
1.49k
    mapOptionalWithContext(Key, Val, Ctx);
861
1.49k
  }
void llvm::yaml::IO::mapOptional<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata>(char const*, llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata&)
Line
Count
Source
858
1.79k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
1.79k
    EmptyContext Ctx;
860
1.79k
    mapOptionalWithContext(Key, Val, Ctx);
861
1.79k
  }
void llvm::yaml::IO::mapOptional<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata>(char const*, llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata&)
Line
Count
Source
858
138
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
138
    EmptyContext Ctx;
860
138
    mapOptionalWithContext(Key, Val, Ctx);
861
138
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<llvm::remarks::RemarkLocation> >(char const*, llvm::Optional<llvm::remarks::RemarkLocation>&)
Line
Count
Source
858
1.86k
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
1.86k
    EmptyContext Ctx;
860
1.86k
    mapOptionalWithContext(Key, Val, Ctx);
861
1.86k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<unsigned long long> >(char const*, llvm::Optional<unsigned long long>&)
Line
Count
Source
858
427
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
427
    EmptyContext Ctx;
860
427
    mapOptionalWithContext(Key, Val, Ctx);
861
427
  }
void llvm::yaml::IO::mapOptional<llvm::ArrayRef<llvm::remarks::Argument> >(char const*, llvm::ArrayRef<llvm::remarks::Argument>&)
Line
Count
Source
858
427
  template <typename T> void mapOptional(const char *Key, T &Val) {
859
427
    EmptyContext Ctx;
860
427
    mapOptionalWithContext(Key, Val, Ctx);
861
427
  }
862
863
  template <typename T, typename DefaultT>
864
942k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
942k
    EmptyContext Ctx;
866
942k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
942k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::StringValue, llvm::yaml::StringValue>(char const*, llvm::yaml::StringValue&, llvm::yaml::StringValue const&)
Line
Count
Source
864
165k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
165k
    EmptyContext Ctx;
866
165k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
165k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::MachineStackObject::ObjectType, llvm::yaml::MachineStackObject::ObjectType>(char const*, llvm::yaml::MachineStackObject::ObjectType&, llvm::yaml::MachineStackObject::ObjectType const&)
Line
Count
Source
864
1.64k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
1.64k
    EmptyContext Ctx;
866
1.64k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
1.64k
  }
void llvm::yaml::IO::mapOptional<long long, long long>(char const*, long long&, long long const&)
Line
Count
Source
864
3.64k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
3.64k
    EmptyContext Ctx;
866
3.64k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
3.64k
  }
void llvm::yaml::IO::mapOptional<unsigned int, unsigned int>(char const*, unsigned int&, unsigned int const&)
Line
Count
Source
864
103k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
103k
    EmptyContext Ctx;
866
103k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
103k
  }
void llvm::yaml::IO::mapOptional<llvm::TargetStackID::Value, llvm::TargetStackID::Value>(char const*, llvm::TargetStackID::Value&, llvm::TargetStackID::Value const&)
Line
Count
Source
864
2.50k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
2.50k
    EmptyContext Ctx;
866
2.50k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
2.50k
  }
void llvm::yaml::IO::mapOptional<bool, bool>(char const*, bool&, bool const&)
Line
Count
Source
864
352k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
352k
    EmptyContext Ctx;
866
352k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
352k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<long long>, llvm::Optional<long long> >(char const*, llvm::Optional<long long>&, llvm::Optional<long long> const&)
Line
Count
Source
864
1.64k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
1.64k
    EmptyContext Ctx;
866
1.64k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
1.64k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::FixedMachineStackObject::ObjectType, llvm::yaml::FixedMachineStackObject::ObjectType>(char const*, llvm::yaml::FixedMachineStackObject::ObjectType&, llvm::yaml::FixedMachineStackObject::ObjectType const&)
Line
Count
Source
864
859
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
859
    EmptyContext Ctx;
866
859
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
859
  }
void llvm::yaml::IO::mapOptional<unsigned long long, unsigned long long>(char const*, unsigned long long&, unsigned long long const&)
Line
Count
Source
864
20.9k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
20.9k
    EmptyContext Ctx;
866
20.9k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
20.9k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > >(char const*, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > const&)
Line
Count
Source
864
7
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
7
    EmptyContext Ctx;
866
7
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
7
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >(char const*, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > const&)
Line
Count
Source
864
39
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
39
    EmptyContext Ctx;
866
39
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
39
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > >(char const*, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > const&)
Line
Count
Source
864
29
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
29
    EmptyContext Ctx;
866
29
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
29
  }
void llvm::yaml::IO::mapOptional<int, int>(char const*, int&, int const&)
Line
Count
Source
864
13.0k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
13.0k
    EmptyContext Ctx;
866
13.0k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
13.0k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > >(char const*, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > >(char const*, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > > >(char const*, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >&, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::MachineFrameInfo, llvm::yaml::MachineFrameInfo>(char const*, llvm::yaml::MachineFrameInfo&, llvm::yaml::MachineFrameInfo const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > >(char const*, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > >(char const*, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > >(char const*, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > >(char const*, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::MachineJumpTable, llvm::yaml::MachineJumpTable>(char const*, llvm::yaml::MachineJumpTable&, llvm::yaml::MachineJumpTable const&)
Line
Count
Source
864
11.3k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
11.3k
    EmptyContext Ctx;
866
11.3k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
11.3k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::BlockStringValue, llvm::yaml::BlockStringValue>(char const*, llvm::yaml::BlockStringValue&, llvm::yaml::BlockStringValue const&)
Line
Count
Source
864
23.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
23.2k
    EmptyContext Ctx;
866
23.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
23.2k
  }
void llvm::yaml::IO::mapOptional<llvm::yaml::SIMode, llvm::yaml::SIMode>(char const*, llvm::yaml::SIMode&, llvm::yaml::SIMode const&)
Line
Count
Source
864
6.00k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
6.00k
    EmptyContext Ctx;
866
6.00k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
6.00k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&)
Line
Count
Source
864
380
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
380
    EmptyContext Ctx;
866
380
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
380
  }
void llvm::yaml::IO::mapOptional<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> > >(char const*, 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
864
17.4k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
17.4k
    EmptyContext Ctx;
866
17.4k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
17.4k
  }
void llvm::yaml::IO::mapOptional<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > >(char const*, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > const&)
Line
Count
Source
864
2.17k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
2.17k
    EmptyContext Ctx;
866
2.17k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
2.17k
  }
void llvm::yaml::IO::mapOptional<llvm::AMDGPU::HSAMD::AddressSpaceQualifier, llvm::AMDGPU::HSAMD::AddressSpaceQualifier>(char const*, llvm::AMDGPU::HSAMD::AddressSpaceQualifier&, llvm::AMDGPU::HSAMD::AddressSpaceQualifier const&)
Line
Count
Source
864
7.63k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
7.63k
    EmptyContext Ctx;
866
7.63k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
7.63k
  }
void llvm::yaml::IO::mapOptional<llvm::AMDGPU::HSAMD::AccessQualifier, llvm::AMDGPU::HSAMD::AccessQualifier>(char const*, llvm::AMDGPU::HSAMD::AccessQualifier&, llvm::AMDGPU::HSAMD::AccessQualifier const&)
Line
Count
Source
864
15.2k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
15.2k
    EmptyContext Ctx;
866
15.2k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
15.2k
  }
void llvm::yaml::IO::mapOptional<unsigned short, unsigned short>(char const*, unsigned short&, unsigned short const&)
Line
Count
Source
864
7.29k
  void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865
7.29k
    EmptyContext Ctx;
866
7.29k
    mapOptionalWithContext(Key, Val, Default, Ctx);
867
7.29k
  }
868
869
  template <typename T, typename Context>
870
  typename std::enable_if<has_SequenceTraits<T>::value, void>::type
871
5.19k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
5.19k
    // omit key/value instead of outputting empty sequence
873
5.19k
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())2.43k
)
874
282
      return;
875
4.90k
    this->processKey(Key, Val, false, Ctx);
876
4.90k
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
1.69k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
1.69k
    // omit key/value instead of outputting empty sequence
873
1.69k
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())80
)
874
67
      return;
875
1.63k
    this->processKey(Key, Val, false, Ctx);
876
1.63k
  }
cc1gen_reproducer_main.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
3
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
3
    // omit key/value instead of outputting empty sequence
873
3
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())0
)
874
0
      return;
875
3
    this->processKey(Key, Val, false, Ctx);
876
3
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
899
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
899
    // omit key/value instead of outputting empty sequence
873
899
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())167
)
874
119
      return;
875
780
    this->processKey(Key, Val, false, Ctx);
876
780
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
192
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
192
    // omit key/value instead of outputting empty sequence
873
192
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())72
)
874
48
      return;
875
144
    this->processKey(Key, Val, false, Ctx);
876
144
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
192
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
192
    // omit key/value instead of outputting empty sequence
873
192
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())72
)
874
48
      return;
875
144
    this->processKey(Key, Val, false, Ctx);
876
144
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
287
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
287
    // omit key/value instead of outputting empty sequence
873
287
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())259
)
874
0
      return;
875
287
    this->processKey(Key, Val, false, Ctx);
876
287
  }
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
1.49k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
1.49k
    // omit key/value instead of outputting empty sequence
873
1.49k
    if (this->canElideEmptySequence() && 
!(Val.begin() != Val.end())1.35k
)
874
0
      return;
875
1.49k
    this->processKey(Key, Val, false, Ctx);
876
1.49k
  }
std::__1::enable_if<has_SequenceTraits<llvm::ArrayRef<llvm::remarks::Argument> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::ArrayRef<llvm::remarks::Argument>, llvm::yaml::EmptyContext>(char const*, llvm::ArrayRef<llvm::remarks::Argument>&, llvm::yaml::EmptyContext&)
Line
Count
Source
871
427
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872
427
    // omit key/value instead of outputting empty sequence
873
427
    if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
874
0
      return;
875
427
    this->processKey(Key, Val, false, Ctx);
876
427
  }
877
878
  template <typename T, typename Context>
879
117k
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
117k
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
117k
                                Ctx);
882
117k
  }
void llvm::yaml::IO::mapOptionalWithContext<unsigned int, llvm::yaml::EmptyContext>(char const*, llvm::Optional<unsigned int>&, llvm::yaml::EmptyContext&)
Line
Count
Source
879
13.5k
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
13.5k
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
13.5k
                                Ctx);
882
13.5k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::SIArgument, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::yaml::SIArgument>&, llvm::yaml::EmptyContext&)
Line
Count
Source
879
95.6k
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
95.6k
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
95.6k
                                Ctx);
882
95.6k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::SIArgumentInfo, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::yaml::SIArgumentInfo>&, llvm::yaml::EmptyContext&)
Line
Count
Source
879
6.00k
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
6.00k
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
6.00k
                                Ctx);
882
6.00k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::remarks::RemarkLocation, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::remarks::RemarkLocation>&, llvm::yaml::EmptyContext&)
Line
Count
Source
879
1.86k
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
1.86k
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
1.86k
                                Ctx);
882
1.86k
  }
void llvm::yaml::IO::mapOptionalWithContext<unsigned long long, llvm::yaml::EmptyContext>(char const*, llvm::Optional<unsigned long long>&, llvm::yaml::EmptyContext&)
Line
Count
Source
879
427
  void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880
427
    this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881
427
                                Ctx);
882
427
  }
883
884
  template <typename T, typename Context>
885
  typename std::enable_if<!has_SequenceTraits<T>::value, void>::type
886
52.8k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
52.8k
    this->processKey(Key, Val, false, Ctx);
888
52.8k
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::yaml::EmptyContext>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
3.59k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
3.59k
    this->processKey(Key, Val, false, Ctx);
888
3.59k
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >, llvm::yaml::EmptyContext>(char const*, std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
23.2k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
23.2k
    this->processKey(Key, Val, false, Ctx);
888
23.2k
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
73
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
73
    this->processKey(Key, Val, false, Ctx);
888
73
  }
std::__1::enable_if<!(has_SequenceTraits<unsigned int>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<unsigned int, llvm::yaml::EmptyContext>(char const*, unsigned int&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
5.95k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
5.95k
    this->processKey(Key, Val, false, Ctx);
888
5.95k
  }
std::__1::enable_if<!(has_SequenceTraits<unsigned long long>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<unsigned long long, llvm::yaml::EmptyContext>(char const*, unsigned long long&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
598
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
598
    this->processKey(Key, Val, false, Ctx);
888
598
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::FunctionSummary::VFuncId>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::FunctionSummary::VFuncId, llvm::yaml::EmptyContext>(char const*, llvm::FunctionSummary::VFuncId&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
48
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
48
    this->processKey(Key, Val, false, Ctx);
888
48
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >, llvm::yaml::EmptyContext>(char const*, std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
73
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
73
    this->processKey(Key, Val, false, Ctx);
888
73
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::TypeTestResolution>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::TypeTestResolution, llvm::yaml::EmptyContext>(char const*, llvm::TypeTestResolution&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
104
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
104
    this->processKey(Key, Val, false, Ctx);
888
104
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::TypeTestResolution::Kind>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::TypeTestResolution::Kind, llvm::yaml::EmptyContext>(char const*, llvm::TypeTestResolution::Kind&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
85
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
85
    this->processKey(Key, Val, false, Ctx);
888
85
  }
std::__1::enable_if<!(has_SequenceTraits<unsigned char>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<unsigned char, llvm::yaml::EmptyContext>(char const*, unsigned char&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
85
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
85
    this->processKey(Key, Val, false, Ctx);
888
85
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
104
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
104
    this->processKey(Key, Val, false, Ctx);
888
104
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::WholeProgramDevirtResolution::Kind>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::WholeProgramDevirtResolution::Kind, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution::Kind&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
52
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
52
    this->processKey(Key, Val, false, Ctx);
888
52
  }
std::__1::enable_if<!(has_SequenceTraits<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > > >::value), void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
52
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
52
    this->processKey(Key, Val, false, Ctx);
888
52
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::WholeProgramDevirtResolution::ByArg::Kind>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::WholeProgramDevirtResolution::ByArg::Kind, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution::ByArg::Kind&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
27
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
27
    this->processKey(Key, Val, false, Ctx);
888
27
  }
std::__1::enable_if<!(has_SequenceTraits<bool>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<bool, llvm::yaml::EmptyContext>(char const*, bool&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
16.5k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
16.5k
    this->processKey(Key, Val, false, Ctx);
888
16.5k
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
288
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
288
    this->processKey(Key, Val, false, Ctx);
888
288
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
1.79k
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
1.79k
    this->processKey(Key, Val, false, Ctx);
888
1.79k
  }
std::__1::enable_if<!(has_SequenceTraits<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
886
138
  mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887
138
    this->processKey(Key, Val, false, Ctx);
888
138
  }
889
890
  template <typename T, typename Context, typename DefaultT>
891
  void mapOptionalWithContext(const char *Key, T &Val, const DefaultT &Default,
892
942k
                              Context &Ctx) {
893
942k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
942k
                  "Default type must be implicitly convertible to value type!");
895
942k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
942k
                                false, Ctx);
897
942k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::StringValue, llvm::yaml::EmptyContext, llvm::yaml::StringValue>(char const*, llvm::yaml::StringValue&, llvm::yaml::StringValue const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
165k
                              Context &Ctx) {
893
165k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
165k
                  "Default type must be implicitly convertible to value type!");
895
165k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
165k
                                false, Ctx);
897
165k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::MachineStackObject::ObjectType, llvm::yaml::EmptyContext, llvm::yaml::MachineStackObject::ObjectType>(char const*, llvm::yaml::MachineStackObject::ObjectType&, llvm::yaml::MachineStackObject::ObjectType const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
1.64k
                              Context &Ctx) {
893
1.64k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
1.64k
                  "Default type must be implicitly convertible to value type!");
895
1.64k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
1.64k
                                false, Ctx);
897
1.64k
  }
void llvm::yaml::IO::mapOptionalWithContext<long long, llvm::yaml::EmptyContext, long long>(char const*, long long&, long long const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
3.64k
                              Context &Ctx) {
893
3.64k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
3.64k
                  "Default type must be implicitly convertible to value type!");
895
3.64k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
3.64k
                                false, Ctx);
897
3.64k
  }
void llvm::yaml::IO::mapOptionalWithContext<unsigned int, llvm::yaml::EmptyContext, unsigned int>(char const*, unsigned int&, unsigned int const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
103k
                              Context &Ctx) {
893
103k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
103k
                  "Default type must be implicitly convertible to value type!");
895
103k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
103k
                                false, Ctx);
897
103k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::TargetStackID::Value, llvm::yaml::EmptyContext, llvm::TargetStackID::Value>(char const*, llvm::TargetStackID::Value&, llvm::TargetStackID::Value const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
2.50k
                              Context &Ctx) {
893
2.50k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
2.50k
                  "Default type must be implicitly convertible to value type!");
895
2.50k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
2.50k
                                false, Ctx);
897
2.50k
  }
void llvm::yaml::IO::mapOptionalWithContext<bool, llvm::yaml::EmptyContext, bool>(char const*, bool&, bool const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
352k
                              Context &Ctx) {
893
352k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
352k
                  "Default type must be implicitly convertible to value type!");
895
352k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
352k
                                false, Ctx);
897
352k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::Optional<long long>, llvm::yaml::EmptyContext, llvm::Optional<long long> >(char const*, llvm::Optional<long long>&, llvm::Optional<long long> const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
1.64k
                              Context &Ctx) {
893
1.64k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
1.64k
                  "Default type must be implicitly convertible to value type!");
895
1.64k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
1.64k
                                false, Ctx);
897
1.64k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::FixedMachineStackObject::ObjectType, llvm::yaml::EmptyContext, llvm::yaml::FixedMachineStackObject::ObjectType>(char const*, llvm::yaml::FixedMachineStackObject::ObjectType&, llvm::yaml::FixedMachineStackObject::ObjectType const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
859
                              Context &Ctx) {
893
859
    static_assert(std::is_convertible<DefaultT, T>::value,
894
859
                  "Default type must be implicitly convertible to value type!");
895
859
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
859
                                false, Ctx);
897
859
  }
void llvm::yaml::IO::mapOptionalWithContext<unsigned long long, llvm::yaml::EmptyContext, unsigned long long>(char const*, unsigned long long&, unsigned long long const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
20.9k
                              Context &Ctx) {
893
20.9k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
20.9k
                  "Default type must be implicitly convertible to value type!");
895
20.9k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
20.9k
                                false, Ctx);
897
20.9k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > >(char const*, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
7
                              Context &Ctx) {
893
7
    static_assert(std::is_convertible<DefaultT, T>::value,
894
7
                  "Default type must be implicitly convertible to value type!");
895
7
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
7
                                false, Ctx);
897
7
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >(char const*, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
39
                              Context &Ctx) {
893
39
    static_assert(std::is_convertible<DefaultT, T>::value,
894
39
                  "Default type must be implicitly convertible to value type!");
895
39
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
39
                                false, Ctx);
897
39
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > >(char const*, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
29
                              Context &Ctx) {
893
29
    static_assert(std::is_convertible<DefaultT, T>::value,
894
29
                  "Default type must be implicitly convertible to value type!");
895
29
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
29
                                false, Ctx);
897
29
  }
void llvm::yaml::IO::mapOptionalWithContext<int, llvm::yaml::EmptyContext, int>(char const*, int&, int const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
13.0k
                              Context &Ctx) {
893
13.0k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
13.0k
                  "Default type must be implicitly convertible to value type!");
895
13.0k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
13.0k
                                false, Ctx);
897
13.0k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > >(char const*, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > >(char const*, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >, llvm::yaml::EmptyContext, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > > >(char const*, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >&, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::MachineFrameInfo, llvm::yaml::EmptyContext, llvm::yaml::MachineFrameInfo>(char const*, llvm::yaml::MachineFrameInfo&, llvm::yaml::MachineFrameInfo const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > >(char const*, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > >(char const*, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > >(char const*, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, llvm::yaml::EmptyContext, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > >(char const*, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::MachineJumpTable, llvm::yaml::EmptyContext, llvm::yaml::MachineJumpTable>(char const*, llvm::yaml::MachineJumpTable&, llvm::yaml::MachineJumpTable const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
11.3k
                              Context &Ctx) {
893
11.3k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
11.3k
                  "Default type must be implicitly convertible to value type!");
895
11.3k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
11.3k
                                false, Ctx);
897
11.3k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::BlockStringValue, llvm::yaml::EmptyContext, llvm::yaml::BlockStringValue>(char const*, llvm::yaml::BlockStringValue&, llvm::yaml::BlockStringValue const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
23.2k
                              Context &Ctx) {
893
23.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
23.2k
                  "Default type must be implicitly convertible to value type!");
895
23.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
23.2k
                                false, Ctx);
897
23.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::SIMode, llvm::yaml::EmptyContext, llvm::yaml::SIMode>(char const*, llvm::yaml::SIMode&, llvm::yaml::SIMode const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
6.00k
                              Context &Ctx) {
893
6.00k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
6.00k
                  "Default type must be implicitly convertible to value type!");
895
6.00k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
6.00k
                                false, Ctx);
897
6.00k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, llvm::yaml::EmptyContext, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
380
                              Context &Ctx) {
893
380
    static_assert(std::is_convertible<DefaultT, T>::value,
894
380
                  "Default type must be implicitly convertible to value type!");
895
380
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
380
                                false, Ctx);
897
380
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::yaml::EmptyContext, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(char const*, 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&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
17.4k
                              Context &Ctx) {
893
17.4k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
17.4k
                  "Default type must be implicitly convertible to value type!");
895
17.4k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
17.4k
                                false, Ctx);
897
17.4k
  }
void llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, llvm::yaml::EmptyContext, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > >(char const*, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
2.17k
                              Context &Ctx) {
893
2.17k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
2.17k
                  "Default type must be implicitly convertible to value type!");
895
2.17k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
2.17k
                                false, Ctx);
897
2.17k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::AMDGPU::HSAMD::AddressSpaceQualifier, llvm::yaml::EmptyContext, llvm::AMDGPU::HSAMD::AddressSpaceQualifier>(char const*, llvm::AMDGPU::HSAMD::AddressSpaceQualifier&, llvm::AMDGPU::HSAMD::AddressSpaceQualifier const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
7.63k
                              Context &Ctx) {
893
7.63k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
7.63k
                  "Default type must be implicitly convertible to value type!");
895
7.63k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
7.63k
                                false, Ctx);
897
7.63k
  }
void llvm::yaml::IO::mapOptionalWithContext<llvm::AMDGPU::HSAMD::AccessQualifier, llvm::yaml::EmptyContext, llvm::AMDGPU::HSAMD::AccessQualifier>(char const*, llvm::AMDGPU::HSAMD::AccessQualifier&, llvm::AMDGPU::HSAMD::AccessQualifier const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
15.2k
                              Context &Ctx) {
893
15.2k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
15.2k
                  "Default type must be implicitly convertible to value type!");
895
15.2k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
15.2k
                                false, Ctx);
897
15.2k
  }
void llvm::yaml::IO::mapOptionalWithContext<unsigned short, llvm::yaml::EmptyContext, unsigned short>(char const*, unsigned short&, unsigned short const&, llvm::yaml::EmptyContext&)
Line
Count
Source
892
7.29k
                              Context &Ctx) {
893
7.29k
    static_assert(std::is_convertible<DefaultT, T>::value,
894
7.29k
                  "Default type must be implicitly convertible to value type!");
895
7.29k
    this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896
7.29k
                                false, Ctx);
897
7.29k
  }
898
899
private:
900
  template <typename T, typename Context>
901
  void processKeyWithDefault(const char *Key, Optional<T> &Val,
902
                             const Optional<T> &DefaultValue, bool Required,
903
142k
                             Context &Ctx) {
904
142k
    assert(DefaultValue.hasValue() == false &&
905
142k
           "Optional<T> shouldn't have a value!");
906
142k
    void *SaveInfo;
907
142k
    bool UseDefault = true;
908
142k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()128k
;
909
142k
    if (!outputting() && 
!Val.hasValue()13.9k
)
910
13.9k
      Val = T();
911
142k
    if (Val.hasValue() &&
912
142k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
31.6k
                           SaveInfo)) {
914
17.8k
      yamlize(*this, Val.getValue(), Required, Ctx);
915
17.8k
      this->postflightKey(SaveInfo);
916
124k
    } else {
917
124k
      if (UseDefault)
918
124k
        Val = DefaultValue;
919
124k
    }
920
142k
  }
void llvm::yaml::IO::processKeyWithDefault<long long, llvm::yaml::EmptyContext>(char const*, llvm::Optional<long long>&, llvm::Optional<long long> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
1.64k
                             Context &Ctx) {
904
1.64k
    assert(DefaultValue.hasValue() == false &&
905
1.64k
           "Optional<T> shouldn't have a value!");
906
1.64k
    void *SaveInfo;
907
1.64k
    bool UseDefault = true;
908
1.64k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()1.04k
;
909
1.64k
    if (!outputting() && 
!Val.hasValue()598
)
910
598
      Val = T();
911
1.64k
    if (Val.hasValue() &&
912
1.64k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
707
                           SaveInfo)) {
914
209
      yamlize(*this, Val.getValue(), Required, Ctx);
915
209
      this->postflightKey(SaveInfo);
916
1.43k
    } else {
917
1.43k
      if (UseDefault)
918
1.43k
        Val = DefaultValue;
919
1.43k
    }
920
1.64k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, llvm::yaml::EmptyContext>(char const*, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >&, llvm::Optional<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
23.2k
                             Context &Ctx) {
904
23.2k
    assert(DefaultValue.hasValue() == false &&
905
23.2k
           "Optional<T> shouldn't have a value!");
906
23.2k
    void *SaveInfo;
907
23.2k
    bool UseDefault = true;
908
23.2k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()11.9k
;
909
23.2k
    if (!outputting() && 
!Val.hasValue()11.3k
)
910
11.3k
      Val = T();
911
23.2k
    if (Val.hasValue() &&
912
23.2k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
11.3k
                           SaveInfo)) {
914
29
      yamlize(*this, Val.getValue(), Required, Ctx);
915
29
      this->postflightKey(SaveInfo);
916
23.2k
    } else {
917
23.2k
      if (UseDefault)
918
23.2k
        Val = DefaultValue;
919
23.2k
    }
920
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<unsigned int, llvm::yaml::EmptyContext>(char const*, llvm::Optional<unsigned int>&, llvm::Optional<unsigned int> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
13.5k
                             Context &Ctx) {
904
13.5k
    assert(DefaultValue.hasValue() == false &&
905
13.5k
           "Optional<T> shouldn't have a value!");
906
13.5k
    void *SaveInfo;
907
13.5k
    bool UseDefault = true;
908
13.5k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()11.9k
;
909
13.5k
    if (!outputting() && 
!Val.hasValue()1.67k
)
910
1.67k
      Val = T();
911
13.5k
    if (Val.hasValue() &&
912
13.5k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
1.69k
                           SaveInfo)) {
914
30
      yamlize(*this, Val.getValue(), Required, Ctx);
915
30
      this->postflightKey(SaveInfo);
916
13.5k
    } else {
917
13.5k
      if (UseDefault)
918
13.5k
        Val = DefaultValue;
919
13.5k
    }
920
13.5k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::SIArgument, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::yaml::SIArgument>&, llvm::Optional<llvm::yaml::SIArgument> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
95.6k
                             Context &Ctx) {
904
95.6k
    assert(DefaultValue.hasValue() == false &&
905
95.6k
           "Optional<T> shouldn't have a value!");
906
95.6k
    void *SaveInfo;
907
95.6k
    bool UseDefault = true;
908
95.6k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()95.4k
;
909
95.6k
    if (!outputting() && 
!Val.hasValue()221
)
910
221
      Val = T();
911
95.6k
    if (Val.hasValue() &&
912
95.6k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
11.8k
                           SaveInfo)) {
914
11.6k
      yamlize(*this, Val.getValue(), Required, Ctx);
915
11.6k
      this->postflightKey(SaveInfo);
916
83.9k
    } else {
917
83.9k
      if (UseDefault)
918
83.9k
        Val = DefaultValue;
919
83.9k
    }
920
95.6k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::SIArgumentInfo, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::yaml::SIArgumentInfo>&, llvm::Optional<llvm::yaml::SIArgumentInfo> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
6.00k
                             Context &Ctx) {
904
6.00k
    assert(DefaultValue.hasValue() == false &&
905
6.00k
           "Optional<T> shouldn't have a value!");
906
6.00k
    void *SaveInfo;
907
6.00k
    bool UseDefault = true;
908
6.00k
    const bool sameAsDefault = outputting() && 
!Val.hasValue()5.80k
;
909
6.00k
    if (!outputting() && 
!Val.hasValue()202
)
910
202
      Val = T();
911
6.00k
    if (Val.hasValue() &&
912
6.00k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
5.81k
                           SaveInfo)) {
914
5.62k
      yamlize(*this, Val.getValue(), Required, Ctx);
915
5.62k
      this->postflightKey(SaveInfo);
916
5.62k
    } else {
917
383
      if (UseDefault)
918
381
        Val = DefaultValue;
919
383
    }
920
6.00k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::remarks::RemarkLocation, llvm::yaml::EmptyContext>(char const*, llvm::Optional<llvm::remarks::RemarkLocation>&, llvm::Optional<llvm::remarks::RemarkLocation> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
1.86k
                             Context &Ctx) {
904
1.86k
    assert(DefaultValue.hasValue() == false &&
905
1.86k
           "Optional<T> shouldn't have a value!");
906
1.86k
    void *SaveInfo;
907
1.86k
    bool UseDefault = true;
908
1.86k
    const bool sameAsDefault = outputting() && !Val.hasValue();
909
1.86k
    if (!outputting() && 
!Val.hasValue()0
)
910
0
      Val = T();
911
1.86k
    if (Val.hasValue() &&
912
1.86k
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
230
                           SaveInfo)) {
914
230
      yamlize(*this, Val.getValue(), Required, Ctx);
915
230
      this->postflightKey(SaveInfo);
916
1.63k
    } else {
917
1.63k
      if (UseDefault)
918
1.63k
        Val = DefaultValue;
919
1.63k
    }
920
1.86k
  }
void llvm::yaml::IO::processKeyWithDefault<unsigned long long, llvm::yaml::EmptyContext>(char const*, llvm::Optional<unsigned long long>&, llvm::Optional<unsigned long long> const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
903
427
                             Context &Ctx) {
904
427
    assert(DefaultValue.hasValue() == false &&
905
427
           "Optional<T> shouldn't have a value!");
906
427
    void *SaveInfo;
907
427
    bool UseDefault = true;
908
427
    const bool sameAsDefault = outputting() && !Val.hasValue();
909
427
    if (!outputting() && 
!Val.hasValue()0
)
910
0
      Val = T();
911
427
    if (Val.hasValue() &&
912
427
        this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913
40
                           SaveInfo)) {
914
40
      yamlize(*this, Val.getValue(), Required, Ctx);
915
40
      this->postflightKey(SaveInfo);
916
387
    } else {
917
387
      if (UseDefault)
918
387
        Val = DefaultValue;
919
387
    }
920
427
  }
921
922
  template <typename T, typename Context>
923
  void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
924
917k
                             bool Required, Context &Ctx) {
925
917k
    void *SaveInfo;
926
917k
    bool UseDefault;
927
917k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue661k
;
928
917k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
917k
                                                                  SaveInfo) ) {
930
655k
      yamlize(*this, Val, Required, Ctx);
931
655k
      this->postflightKey(SaveInfo);
932
655k
    }
933
261k
    else {
934
261k
      if ( UseDefault )
935
185k
        Val = DefaultValue;
936
261k
    }
937
917k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::StringValue, llvm::yaml::EmptyContext>(char const*, llvm::yaml::StringValue&, llvm::yaml::StringValue const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
165k
                             bool Required, Context &Ctx) {
925
165k
    void *SaveInfo;
926
165k
    bool UseDefault;
927
165k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue138k
;
928
165k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
165k
                                                                  SaveInfo) ) {
930
146k
      yamlize(*this, Val, Required, Ctx);
931
146k
      this->postflightKey(SaveInfo);
932
146k
    }
933
18.3k
    else {
934
18.3k
      if ( UseDefault )
935
16.9k
        Val = DefaultValue;
936
18.3k
    }
937
165k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::MachineStackObject::ObjectType, llvm::yaml::EmptyContext>(char const*, llvm::yaml::MachineStackObject::ObjectType&, llvm::yaml::MachineStackObject::ObjectType const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
1.64k
                             bool Required, Context &Ctx) {
925
1.64k
    void *SaveInfo;
926
1.64k
    bool UseDefault;
927
1.64k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue1.04k
;
928
1.64k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
1.64k
                                                                  SaveInfo) ) {
930
1.50k
      yamlize(*this, Val, Required, Ctx);
931
1.50k
      this->postflightKey(SaveInfo);
932
1.50k
    }
933
140
    else {
934
140
      if ( UseDefault )
935
138
        Val = DefaultValue;
936
140
    }
937
1.64k
  }
void llvm::yaml::IO::processKeyWithDefault<long long, llvm::yaml::EmptyContext>(char const*, long long&, long long const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
3.64k
                             bool Required, Context &Ctx) {
925
3.64k
    void *SaveInfo;
926
3.64k
    bool UseDefault;
927
3.64k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue2.13k
;
928
3.64k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
3.64k
                                                                  SaveInfo) ) {
930
2.62k
      yamlize(*this, Val, Required, Ctx);
931
2.62k
      this->postflightKey(SaveInfo);
932
2.62k
    }
933
1.02k
    else {
934
1.02k
      if ( UseDefault )
935
698
        Val = DefaultValue;
936
1.02k
    }
937
3.64k
  }
void llvm::yaml::IO::processKeyWithDefault<unsigned int, llvm::yaml::EmptyContext>(char const*, unsigned int&, unsigned int const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
103k
                             bool Required, Context &Ctx) {
925
103k
    void *SaveInfo;
926
103k
    bool UseDefault;
927
103k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue82.3k
;
928
103k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
103k
                                                                  SaveInfo) ) {
930
82.2k
      yamlize(*this, Val, Required, Ctx);
931
82.2k
      this->postflightKey(SaveInfo);
932
82.2k
    }
933
21.1k
    else {
934
21.1k
      if ( UseDefault )
935
13.3k
        Val = DefaultValue;
936
21.1k
    }
937
103k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::TargetStackID::Value, llvm::yaml::EmptyContext>(char const*, llvm::TargetStackID::Value&, llvm::TargetStackID::Value const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
2.50k
                             bool Required, Context &Ctx) {
925
2.50k
    void *SaveInfo;
926
2.50k
    bool UseDefault;
927
2.50k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue1.65k
;
928
2.50k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
2.50k
                                                                  SaveInfo) ) {
930
2.15k
      yamlize(*this, Val, Required, Ctx);
931
2.15k
      this->postflightKey(SaveInfo);
932
2.15k
    }
933
350
    else {
934
350
      if ( UseDefault )
935
347
        Val = DefaultValue;
936
350
    }
937
2.50k
  }
void llvm::yaml::IO::processKeyWithDefault<bool, llvm::yaml::EmptyContext>(char const*, bool&, bool const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
352k
                             bool Required, Context &Ctx) {
925
352k
    void *SaveInfo;
926
352k
    bool UseDefault;
927
352k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue258k
;
928
352k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
352k
                                                                  SaveInfo) ) {
930
253k
      yamlize(*this, Val, Required, Ctx);
931
253k
      this->postflightKey(SaveInfo);
932
253k
    }
933
98.9k
    else {
934
98.9k
      if ( UseDefault )
935
66.9k
        Val = DefaultValue;
936
98.9k
    }
937
352k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::FixedMachineStackObject::ObjectType, llvm::yaml::EmptyContext>(char const*, llvm::yaml::FixedMachineStackObject::ObjectType&, llvm::yaml::FixedMachineStackObject::ObjectType const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
859
                             bool Required, Context &Ctx) {
925
859
    void *SaveInfo;
926
859
    bool UseDefault;
927
859
    const bool sameAsDefault = outputting() && 
Val == DefaultValue615
;
928
859
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
859
                                                                  SaveInfo) ) {
930
736
      yamlize(*this, Val, Required, Ctx);
931
736
      this->postflightKey(SaveInfo);
932
736
    }
933
123
    else {
934
123
      if ( UseDefault )
935
122
        Val = DefaultValue;
936
123
    }
937
859
  }
void llvm::yaml::IO::processKeyWithDefault<unsigned long long, llvm::yaml::EmptyContext>(char const*, unsigned long long&, unsigned long long const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
20.9k
                             bool Required, Context &Ctx) {
925
20.9k
    void *SaveInfo;
926
20.9k
    bool UseDefault;
927
20.9k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue19.1k
;
928
20.9k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
20.9k
                                                                  SaveInfo) ) {
930
19.2k
      yamlize(*this, Val, Required, Ctx);
931
19.2k
      this->postflightKey(SaveInfo);
932
19.2k
    }
933
1.66k
    else {
934
1.66k
      if ( UseDefault )
935
725
        Val = DefaultValue;
936
1.66k
    }
937
20.9k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
7
                             bool Required, Context &Ctx) {
925
7
    void *SaveInfo;
926
7
    bool UseDefault;
927
7
    const bool sameAsDefault = outputting() && 
Val == DefaultValue2
;
928
7
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
7
                                                                  SaveInfo) ) {
930
7
      yamlize(*this, Val, Required, Ctx);
931
7
      this->postflightKey(SaveInfo);
932
7
    }
933
0
    else {
934
0
      if ( UseDefault )
935
0
        Val = DefaultValue;
936
0
    }
937
7
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
39
                             bool Required, Context &Ctx) {
925
39
    void *SaveInfo;
926
39
    bool UseDefault;
927
39
    const bool sameAsDefault = outputting() && 
Val == DefaultValue18
;
928
39
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
39
                                                                  SaveInfo) ) {
930
39
      yamlize(*this, Val, Required, Ctx);
931
39
      this->postflightKey(SaveInfo);
932
39
    }
933
0
    else {
934
0
      if ( UseDefault )
935
0
        Val = DefaultValue;
936
0
    }
937
39
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
29
                             bool Required, Context &Ctx) {
925
29
    void *SaveInfo;
926
29
    bool UseDefault;
927
29
    const bool sameAsDefault = outputting() && 
Val == DefaultValue13
;
928
29
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
29
                                                                  SaveInfo) ) {
930
28
      yamlize(*this, Val, Required, Ctx);
931
28
      this->postflightKey(SaveInfo);
932
28
    }
933
1
    else {
934
1
      if ( UseDefault )
935
0
        Val = DefaultValue;
936
1
    }
937
29
  }
void llvm::yaml::IO::processKeyWithDefault<int, llvm::yaml::EmptyContext>(char const*, int&, int const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
13.0k
                             bool Required, Context &Ctx) {
925
13.0k
    void *SaveInfo;
926
13.0k
    bool UseDefault;
927
13.0k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue12.1k
;
928
13.0k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
13.0k
                                                                  SaveInfo) ) {
930
12.4k
      yamlize(*this, Val, Required, Ctx);
931
12.4k
      this->postflightKey(SaveInfo);
932
12.4k
    }
933
570
    else {
934
570
      if ( UseDefault )
935
151
        Val = DefaultValue;
936
570
    }
937
13.0k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
15.8k
      yamlize(*this, Val, Required, Ctx);
931
15.8k
      this->postflightKey(SaveInfo);
932
15.8k
    }
933
7.42k
    else {
934
7.42k
      if ( UseDefault )
935
7.41k
        Val = DefaultValue;
936
7.42k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
13.2k
      yamlize(*this, Val, Required, Ctx);
931
13.2k
      this->postflightKey(SaveInfo);
932
13.2k
    }
933
9.94k
    else {
934
9.94k
      if ( UseDefault )
935
9.90k
        Val = DefaultValue;
936
9.94k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::MachineFrameInfo, llvm::yaml::EmptyContext>(char const*, llvm::yaml::MachineFrameInfo&, llvm::yaml::MachineFrameInfo const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
12.7k
      yamlize(*this, Val, Required, Ctx);
931
12.7k
      this->postflightKey(SaveInfo);
932
12.7k
    }
933
10.4k
    else {
934
10.4k
      if ( UseDefault )
935
10.4k
        Val = DefaultValue;
936
10.4k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
12.5k
      yamlize(*this, Val, Required, Ctx);
931
12.5k
      this->postflightKey(SaveInfo);
932
12.5k
    }
933
10.6k
    else {
934
10.6k
      if ( UseDefault )
935
10.4k
        Val = DefaultValue;
936
10.6k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
12.6k
      yamlize(*this, Val, Required, Ctx);
931
12.6k
      this->postflightKey(SaveInfo);
932
12.6k
    }
933
10.5k
    else {
934
10.5k
      if ( UseDefault )
935
10.3k
        Val = DefaultValue;
936
10.5k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
11.7k
      yamlize(*this, Val, Required, Ctx);
931
11.7k
      this->postflightKey(SaveInfo);
932
11.7k
    }
933
11.4k
    else {
934
11.4k
      if ( UseDefault )
935
11.2k
        Val = DefaultValue;
936
11.4k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
12.5k
      yamlize(*this, Val, Required, Ctx);
931
12.5k
      this->postflightKey(SaveInfo);
932
12.5k
    }
933
10.7k
    else {
934
10.7k
      if ( UseDefault )
935
10.5k
        Val = DefaultValue;
936
10.7k
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::MachineJumpTable, llvm::yaml::EmptyContext>(char const*, llvm::yaml::MachineJumpTable&, llvm::yaml::MachineJumpTable const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
11.3k
                             bool Required, Context &Ctx) {
925
11.3k
    void *SaveInfo;
926
11.3k
    bool UseDefault;
927
11.3k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue13
;
928
11.3k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
11.3k
                                                                  SaveInfo) ) {
930
29
      yamlize(*this, Val, Required, Ctx);
931
29
      this->postflightKey(SaveInfo);
932
29
    }
933
11.2k
    else {
934
11.2k
      if ( UseDefault )
935
11.2k
        Val = DefaultValue;
936
11.2k
    }
937
11.3k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::BlockStringValue, llvm::yaml::EmptyContext>(char const*, llvm::yaml::BlockStringValue&, llvm::yaml::BlockStringValue const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
23.2k
                             bool Required, Context &Ctx) {
925
23.2k
    void *SaveInfo;
926
23.2k
    bool UseDefault;
927
23.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue11.9k
;
928
23.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
23.2k
                                                                  SaveInfo) ) {
930
23.2k
      yamlize(*this, Val, Required, Ctx);
931
23.2k
      this->postflightKey(SaveInfo);
932
23.2k
    }
933
19
    else {
934
19
      if ( UseDefault )
935
14
        Val = DefaultValue;
936
19
    }
937
23.2k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::SIMode, llvm::yaml::EmptyContext>(char const*, llvm::yaml::SIMode&, llvm::yaml::SIMode const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
6.00k
                             bool Required, Context &Ctx) {
925
6.00k
    void *SaveInfo;
926
6.00k
    bool UseDefault;
927
6.00k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue5.80k
;
928
6.00k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
6.00k
                                                                  SaveInfo) ) {
930
5.83k
      yamlize(*this, Val, Required, Ctx);
931
5.83k
      this->postflightKey(SaveInfo);
932
5.83k
    }
933
176
    else {
934
176
      if ( UseDefault )
935
168
        Val = DefaultValue;
936
176
    }
937
6.00k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
380
                             bool Required, Context &Ctx) {
925
380
    void *SaveInfo;
926
380
    bool UseDefault;
927
380
    const bool sameAsDefault = outputting() && 
Val == DefaultValue352
;
928
380
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
380
                                                                  SaveInfo) ) {
930
48
      yamlize(*this, Val, Required, Ctx);
931
48
      this->postflightKey(SaveInfo);
932
48
    }
933
332
    else {
934
332
      if ( UseDefault )
935
7
        Val = DefaultValue;
936
332
    }
937
380
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::yaml::EmptyContext>(char const*, 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&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
17.4k
                             bool Required, Context &Ctx) {
925
17.4k
    void *SaveInfo;
926
17.4k
    bool UseDefault;
927
17.4k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue15.2k
;
928
17.4k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
17.4k
                                                                  SaveInfo) ) {
930
4.61k
      yamlize(*this, Val, Required, Ctx);
931
4.61k
      this->postflightKey(SaveInfo);
932
4.61k
    }
933
12.8k
    else {
934
12.8k
      if ( UseDefault )
935
1.64k
        Val = DefaultValue;
936
12.8k
    }
937
17.4k
  }
void llvm::yaml::IO::processKeyWithDefault<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
2.17k
                             bool Required, Context &Ctx) {
925
2.17k
    void *SaveInfo;
926
2.17k
    bool UseDefault;
927
2.17k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue1.96k
;
928
2.17k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
2.17k
                                                                  SaveInfo) ) {
930
714
      yamlize(*this, Val, Required, Ctx);
931
714
      this->postflightKey(SaveInfo);
932
714
    }
933
1.45k
    else {
934
1.45k
      if ( UseDefault )
935
70
        Val = DefaultValue;
936
1.45k
    }
937
2.17k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::AMDGPU::HSAMD::AddressSpaceQualifier, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::AddressSpaceQualifier&, llvm::AMDGPU::HSAMD::AddressSpaceQualifier const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
7.63k
                             bool Required, Context &Ctx) {
925
7.63k
    void *SaveInfo;
926
7.63k
    bool UseDefault;
927
7.63k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue6.66k
;
928
7.63k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
7.63k
                                                                  SaveInfo) ) {
930
4.38k
      yamlize(*this, Val, Required, Ctx);
931
4.38k
      this->postflightKey(SaveInfo);
932
4.38k
    }
933
3.24k
    else {
934
3.24k
      if ( UseDefault )
935
434
        Val = DefaultValue;
936
3.24k
    }
937
7.63k
  }
void llvm::yaml::IO::processKeyWithDefault<llvm::AMDGPU::HSAMD::AccessQualifier, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::AccessQualifier&, llvm::AMDGPU::HSAMD::AccessQualifier const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
15.2k
                             bool Required, Context &Ctx) {
925
15.2k
    void *SaveInfo;
926
15.2k
    bool UseDefault;
927
15.2k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue13.3k
;
928
15.2k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
15.2k
                                                                  SaveInfo) ) {
930
1.00k
      yamlize(*this, Val, Required, Ctx);
931
1.00k
      this->postflightKey(SaveInfo);
932
1.00k
    }
933
14.2k
    else {
934
14.2k
      if ( UseDefault )
935
1.75k
        Val = DefaultValue;
936
14.2k
    }
937
15.2k
  }
void llvm::yaml::IO::processKeyWithDefault<unsigned short, llvm::yaml::EmptyContext>(char const*, unsigned short&, unsigned short const&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
924
7.29k
                             bool Required, Context &Ctx) {
925
7.29k
    void *SaveInfo;
926
7.29k
    bool UseDefault;
927
7.29k
    const bool sameAsDefault = outputting() && 
Val == DefaultValue6.71k
;
928
7.29k
    if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929
7.29k
                                                                  SaveInfo) ) {
930
2.74k
      yamlize(*this, Val, Required, Ctx);
931
2.74k
      this->postflightKey(SaveInfo);
932
2.74k
    }
933
4.54k
    else {
934
4.54k
      if ( UseDefault )
935
436
        Val = DefaultValue;
936
4.54k
    }
937
7.29k
  }
938
939
  template <typename T, typename Context>
940
563k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
563k
    void *SaveInfo;
942
563k
    bool UseDefault;
943
563k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
525k
      yamlize(*this, Val, Required, Ctx);
945
525k
      this->postflightKey(SaveInfo);
946
525k
    }
947
563k
  }
void llvm::yaml::IO::processKey<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::yaml::EmptyContext>(char const*, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
8.59k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
8.59k
    void *SaveInfo;
942
8.59k
    bool UseDefault;
943
8.59k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
5.41k
      yamlize(*this, Val, Required, Ctx);
945
5.41k
      this->postflightKey(SaveInfo);
946
5.41k
    }
947
8.59k
  }
void llvm::yaml::IO::processKey<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
1.64k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
1.64k
    void *SaveInfo;
942
1.64k
    bool UseDefault;
943
1.64k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
46
      yamlize(*this, Val, Required, Ctx);
945
46
      this->postflightKey(SaveInfo);
946
46
    }
947
1.64k
  }
cc1gen_reproducer_main.cpp:void llvm::yaml::IO::processKey<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
3
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
3
    void *SaveInfo;
942
3
    bool UseDefault;
943
3
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
2
      yamlize(*this, Val, Required, Ctx);
945
2
      this->postflightKey(SaveInfo);
946
2
    }
947
3
  }
void llvm::yaml::IO::processKey<llvm::yaml::UnsignedValue, llvm::yaml::EmptyContext>(char const*, llvm::yaml::UnsignedValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
88.8k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
88.8k
    void *SaveInfo;
942
88.8k
    bool UseDefault;
943
88.8k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
88.8k
      yamlize(*this, Val, Required, Ctx);
945
88.8k
      this->postflightKey(SaveInfo);
946
88.8k
    }
947
88.8k
  }
void llvm::yaml::IO::processKey<llvm::yaml::StringValue, llvm::yaml::EmptyContext>(char const*, llvm::yaml::StringValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
102k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
102k
    void *SaveInfo;
942
102k
    bool UseDefault;
943
102k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
102k
      yamlize(*this, Val, Required, Ctx);
945
102k
      this->postflightKey(SaveInfo);
946
102k
    }
947
102k
  }
void llvm::yaml::IO::processKey<unsigned long long, llvm::yaml::EmptyContext>(char const*, unsigned long long&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
8.17k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
8.17k
    void *SaveInfo;
942
8.17k
    bool UseDefault;
943
8.17k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
8.13k
      yamlize(*this, Val, Required, Ctx);
945
8.13k
      this->postflightKey(SaveInfo);
946
8.13k
    }
947
8.17k
  }
void llvm::yaml::IO::processKey<unsigned short, llvm::yaml::EmptyContext>(char const*, unsigned short&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
8.62k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
8.62k
    void *SaveInfo;
942
8.62k
    bool UseDefault;
943
8.62k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
8.62k
      yamlize(*this, Val, Required, Ctx);
945
8.62k
      this->postflightKey(SaveInfo);
946
8.62k
    }
947
8.62k
  }
void llvm::yaml::IO::processKey<unsigned int, llvm::yaml::EmptyContext>(char const*, unsigned int&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
45.4k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
45.4k
    void *SaveInfo;
942
45.4k
    bool UseDefault;
943
45.4k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
40.6k
      yamlize(*this, Val, Required, Ctx);
945
40.6k
      this->postflightKey(SaveInfo);
946
40.6k
    }
947
45.4k
  }
void llvm::yaml::IO::processKey<llvm::MachineJumpTableInfo::JTEntryKind, llvm::yaml::EmptyContext>(char const*, llvm::MachineJumpTableInfo::JTEntryKind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
29
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
29
    void *SaveInfo;
942
29
    bool UseDefault;
943
29
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
29
      yamlize(*this, Val, Required, Ctx);
945
29
      this->postflightKey(SaveInfo);
946
29
    }
947
29
  }
void llvm::yaml::IO::processKey<llvm::StringRef, llvm::yaml::EmptyContext>(char const*, llvm::StringRef&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
45.3k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
45.3k
    void *SaveInfo;
942
45.3k
    bool UseDefault;
943
45.3k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
44.7k
      yamlize(*this, Val, Required, Ctx);
945
44.7k
      this->postflightKey(SaveInfo);
946
44.7k
    }
947
45.3k
  }
void llvm::yaml::IO::processKey<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >, llvm::yaml::EmptyContext>(char const*, std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
23.2k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
23.2k
    void *SaveInfo;
942
23.2k
    bool UseDefault;
943
23.2k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
12.5k
      yamlize(*this, Val, Required, Ctx);
945
12.5k
      this->postflightKey(SaveInfo);
946
12.5k
    }
947
23.2k
  }
void llvm::yaml::IO::processKey<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
73
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
73
    void *SaveInfo;
942
73
    bool UseDefault;
943
73
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
54
      yamlize(*this, Val, Required, Ctx);
945
54
      this->postflightKey(SaveInfo);
946
54
    }
947
73
  }
void llvm::yaml::IO::processKey<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
96
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
96
    void *SaveInfo;
942
96
    bool UseDefault;
943
96
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
96
      yamlize(*this, Val, Required, Ctx);
945
96
      this->postflightKey(SaveInfo);
946
96
    }
947
96
  }
void llvm::yaml::IO::processKey<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
780
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
780
    void *SaveInfo;
942
780
    bool UseDefault;
943
780
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
94
      yamlize(*this, Val, Required, Ctx);
945
94
      this->postflightKey(SaveInfo);
946
94
    }
947
780
  }
void llvm::yaml::IO::processKey<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
144
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
144
    void *SaveInfo;
942
144
    bool UseDefault;
943
144
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
48
      yamlize(*this, Val, Required, Ctx);
945
48
      this->postflightKey(SaveInfo);
946
48
    }
947
144
  }
void llvm::yaml::IO::processKey<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
144
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
144
    void *SaveInfo;
942
144
    bool UseDefault;
943
144
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
48
      yamlize(*this, Val, Required, Ctx);
945
48
      this->postflightKey(SaveInfo);
946
48
    }
947
144
  }
void llvm::yaml::IO::processKey<llvm::FunctionSummary::VFuncId, llvm::yaml::EmptyContext>(char const*, llvm::FunctionSummary::VFuncId&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
48
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
48
    void *SaveInfo;
942
48
    bool UseDefault;
943
48
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
48
      yamlize(*this, Val, Required, Ctx);
945
48
      this->postflightKey(SaveInfo);
946
48
    }
947
48
  }
void llvm::yaml::IO::processKey<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >, llvm::yaml::EmptyContext>(char const*, std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
73
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
73
    void *SaveInfo;
942
73
    bool UseDefault;
943
73
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
47
      yamlize(*this, Val, Required, Ctx);
945
47
      this->postflightKey(SaveInfo);
946
47
    }
947
73
  }
void llvm::yaml::IO::processKey<llvm::TypeIdSummary, llvm::yaml::EmptyContext>(char const*, llvm::TypeIdSummary&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
104
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
104
    void *SaveInfo;
942
104
    bool UseDefault;
943
104
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
104
      yamlize(*this, Val, Required, Ctx);
945
104
      this->postflightKey(SaveInfo);
946
104
    }
947
104
  }
void llvm::yaml::IO::processKey<llvm::TypeTestResolution, llvm::yaml::EmptyContext>(char const*, llvm::TypeTestResolution&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
104
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
104
    void *SaveInfo;
942
104
    bool UseDefault;
943
104
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
85
      yamlize(*this, Val, Required, Ctx);
945
85
      this->postflightKey(SaveInfo);
946
85
    }
947
104
  }
void llvm::yaml::IO::processKey<llvm::TypeTestResolution::Kind, llvm::yaml::EmptyContext>(char const*, llvm::TypeTestResolution::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
85
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
85
    void *SaveInfo;
942
85
    bool UseDefault;
943
85
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
85
      yamlize(*this, Val, Required, Ctx);
945
85
      this->postflightKey(SaveInfo);
946
85
    }
947
85
  }
void llvm::yaml::IO::processKey<unsigned char, llvm::yaml::EmptyContext>(char const*, unsigned char&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
7.17k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
7.17k
    void *SaveInfo;
942
7.17k
    bool UseDefault;
943
7.17k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
7.14k
      yamlize(*this, Val, Required, Ctx);
945
7.14k
      this->postflightKey(SaveInfo);
946
7.14k
    }
947
7.17k
  }
void llvm::yaml::IO::processKey<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
104
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
104
    void *SaveInfo;
942
104
    bool UseDefault;
943
104
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
69
      yamlize(*this, Val, Required, Ctx);
945
69
      this->postflightKey(SaveInfo);
946
69
    }
947
104
  }
void llvm::yaml::IO::processKey<llvm::WholeProgramDevirtResolution, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
52
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
52
    void *SaveInfo;
942
52
    bool UseDefault;
943
52
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
52
      yamlize(*this, Val, Required, Ctx);
945
52
      this->postflightKey(SaveInfo);
946
52
    }
947
52
  }
void llvm::yaml::IO::processKey<llvm::WholeProgramDevirtResolution::Kind, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
52
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
52
    void *SaveInfo;
942
52
    bool UseDefault;
943
52
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
52
      yamlize(*this, Val, Required, Ctx);
945
52
      this->postflightKey(SaveInfo);
946
52
    }
947
52
  }
void llvm::yaml::IO::processKey<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >, llvm::yaml::EmptyContext>(char const*, std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
52
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
52
    void *SaveInfo;
942
52
    bool UseDefault;
943
52
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
47
      yamlize(*this, Val, Required, Ctx);
945
47
      this->postflightKey(SaveInfo);
946
47
    }
947
52
  }
void llvm::yaml::IO::processKey<llvm::WholeProgramDevirtResolution::ByArg, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution::ByArg&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
27
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
27
    void *SaveInfo;
942
27
    bool UseDefault;
943
27
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
27
      yamlize(*this, Val, Required, Ctx);
945
27
      this->postflightKey(SaveInfo);
946
27
    }
947
27
  }
void llvm::yaml::IO::processKey<llvm::WholeProgramDevirtResolution::ByArg::Kind, llvm::yaml::EmptyContext>(char const*, llvm::WholeProgramDevirtResolution::ByArg::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
27
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
27
    void *SaveInfo;
942
27
    bool UseDefault;
943
27
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
27
      yamlize(*this, Val, Required, Ctx);
945
27
      this->postflightKey(SaveInfo);
946
27
    }
947
27
  }
void llvm::yaml::IO::processKey<bool, llvm::yaml::EmptyContext>(char const*, bool&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
18.5k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
18.5k
    void *SaveInfo;
942
18.5k
    bool UseDefault;
943
18.5k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
2.61k
      yamlize(*this, Val, Required, Ctx);
945
2.61k
      this->postflightKey(SaveInfo);
946
2.61k
    }
947
18.5k
  }
void llvm::yaml::IO::processKey<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
979
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
979
    void *SaveInfo;
942
979
    bool UseDefault;
943
979
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
708
      yamlize(*this, Val, Required, Ctx);
945
708
      this->postflightKey(SaveInfo);
946
708
    }
947
979
  }
void llvm::yaml::IO::processKey<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
287
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
287
    void *SaveInfo;
942
287
    bool UseDefault;
943
287
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
286
      yamlize(*this, Val, Required, Ctx);
945
286
      this->postflightKey(SaveInfo);
946
286
    }
947
287
  }
void llvm::yaml::IO::processKey<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
288
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
288
    void *SaveInfo;
942
288
    bool UseDefault;
943
288
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
186
      yamlize(*this, Val, Required, Ctx);
945
186
      this->postflightKey(SaveInfo);
946
186
    }
947
288
  }
void llvm::yaml::IO::processKey<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
1.49k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
1.49k
    void *SaveInfo;
942
1.49k
    bool UseDefault;
943
1.49k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
1.47k
      yamlize(*this, Val, Required, Ctx);
945
1.47k
      this->postflightKey(SaveInfo);
946
1.47k
    }
947
1.49k
  }
void llvm::yaml::IO::processKey<llvm::AMDGPU::HSAMD::ValueKind, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::ValueKind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
7.63k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
7.63k
    void *SaveInfo;
942
7.63k
    bool UseDefault;
943
7.63k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
7.63k
      yamlize(*this, Val, Required, Ctx);
945
7.63k
      this->postflightKey(SaveInfo);
946
7.63k
    }
947
7.63k
  }
void llvm::yaml::IO::processKey<llvm::AMDGPU::HSAMD::ValueType, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::ValueType&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
7.63k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
7.63k
    void *SaveInfo;
942
7.63k
    bool UseDefault;
943
7.63k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
7.63k
      yamlize(*this, Val, Required, Ctx);
945
7.63k
      this->postflightKey(SaveInfo);
946
7.63k
    }
947
7.63k
  }
void llvm::yaml::IO::processKey<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
1.79k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
1.79k
    void *SaveInfo;
942
1.79k
    bool UseDefault;
943
1.79k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
1.77k
      yamlize(*this, Val, Required, Ctx);
945
1.77k
      this->postflightKey(SaveInfo);
946
1.77k
    }
947
1.79k
  }
void llvm::yaml::IO::processKey<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata, llvm::yaml::EmptyContext>(char const*, llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
138
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
138
    void *SaveInfo;
942
138
    bool UseDefault;
943
138
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
6
      yamlize(*this, Val, Required, Ctx);
945
6
      this->postflightKey(SaveInfo);
946
6
    }
947
138
  }
void llvm::yaml::IO::processKey<llvm::ArrayRef<llvm::remarks::Argument>, llvm::yaml::EmptyContext>(char const*, llvm::ArrayRef<llvm::remarks::Argument>&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
427
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
427
    void *SaveInfo;
942
427
    bool UseDefault;
943
427
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
427
      yamlize(*this, Val, Required, Ctx);
945
427
      this->postflightKey(SaveInfo);
946
427
    }
947
427
  }
Unexecuted instantiation: void llvm::yaml::IO::processKey<llvm::yaml::StringBlockVal, llvm::yaml::EmptyContext>(char const*, llvm::yaml::StringBlockVal&, bool, llvm::yaml::EmptyContext&)
void llvm::yaml::IO::processKey<llvm::msgpack::DocNode, llvm::yaml::EmptyContext>(char const*, llvm::msgpack::DocNode&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
940
182k
  void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941
182k
    void *SaveInfo;
942
182k
    bool UseDefault;
943
182k
    if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
944
182k
      yamlize(*this, Val, Required, Ctx);
945
182k
      this->postflightKey(SaveInfo);
946
182k
    }
947
182k
  }
948
949
private:
950
  void *Ctxt;
951
};
952
953
namespace detail {
954
955
template <typename T, typename Context>
956
void doMapping(IO &io, T &Val, Context &Ctx) {
957
  MappingContextTraits<T, Context>::mapping(io, Val, Ctx);
958
}
959
960
180k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
180k
  MappingTraits<T>::mapping(io, Val);
962
180k
}
cc1gen_reproducer_main.cpp:void llvm::yaml::detail::doMapping<(anonymous namespace)::ClangInvocationInfo>(llvm::yaml::IO&, (anonymous namespace)::ClangInvocationInfo&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
3
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
3
  MappingTraits<T>::mapping(io, Val);
962
3
}
cc1gen_reproducer_main.cpp:void llvm::yaml::detail::doMapping<(anonymous namespace)::UnsavedFileHash>(llvm::yaml::IO&, (anonymous namespace)::UnsavedFileHash&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
2
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
2
  MappingTraits<T>::mapping(io, Val);
962
2
}
void llvm::yaml::detail::doMapping<llvm::yaml::CallSiteInfo::ArgRegPair>(llvm::yaml::IO&, llvm::yaml::CallSiteInfo::ArgRegPair&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
13
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
13
  MappingTraits<T>::mapping(io, Val);
962
13
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineJumpTable::Entry>(llvm::yaml::IO&, llvm::yaml::MachineJumpTable::Entry&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
39
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
39
  MappingTraits<T>::mapping(io, Val);
962
39
}
void llvm::yaml::detail::doMapping<llvm::yaml::VirtualRegisterDefinition>(llvm::yaml::IO&, llvm::yaml::VirtualRegisterDefinition&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
86.2k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
86.2k
  MappingTraits<T>::mapping(io, Val);
962
86.2k
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineFunctionLiveIn>(llvm::yaml::IO&, llvm::yaml::MachineFunctionLiveIn&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
4.83k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
4.83k
  MappingTraits<T>::mapping(io, Val);
962
4.83k
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineFrameInfo>(llvm::yaml::IO&, llvm::yaml::MachineFrameInfo&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
12.7k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
12.7k
  MappingTraits<T>::mapping(io, Val);
962
12.7k
}
void llvm::yaml::detail::doMapping<llvm::yaml::FixedMachineStackObject>(llvm::yaml::IO&, llvm::yaml::FixedMachineStackObject&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
859
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
859
  MappingTraits<T>::mapping(io, Val);
962
859
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineStackObject>(llvm::yaml::IO&, llvm::yaml::MachineStackObject&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
1.64k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
1.64k
  MappingTraits<T>::mapping(io, Val);
962
1.64k
}
void llvm::yaml::detail::doMapping<llvm::yaml::CallSiteInfo>(llvm::yaml::IO&, llvm::yaml::CallSiteInfo&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
7
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
7
  MappingTraits<T>::mapping(io, Val);
962
7
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineConstantPoolValue>(llvm::yaml::IO&, llvm::yaml::MachineConstantPoolValue&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
124
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
124
  MappingTraits<T>::mapping(io, Val);
962
124
}
void llvm::yaml::detail::doMapping<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> > >(llvm::yaml::IO&, std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
12.5k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
12.5k
  MappingTraits<T>::mapping(io, Val);
962
12.5k
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineJumpTable>(llvm::yaml::IO&, llvm::yaml::MachineJumpTable&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
29
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
29
  MappingTraits<T>::mapping(io, Val);
962
29
}
void llvm::yaml::detail::doMapping<llvm::yaml::SIArgument>(llvm::yaml::IO&, llvm::yaml::SIArgument&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
11.6k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
11.6k
  MappingTraits<T>::mapping(io, Val);
962
11.6k
}
void llvm::yaml::detail::doMapping<llvm::yaml::SIArgumentInfo>(llvm::yaml::IO&, llvm::yaml::SIArgumentInfo&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
5.62k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
5.62k
  MappingTraits<T>::mapping(io, Val);
962
5.62k
}
void llvm::yaml::detail::doMapping<llvm::yaml::SIMode>(llvm::yaml::IO&, llvm::yaml::SIMode&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
5.83k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
5.83k
  MappingTraits<T>::mapping(io, Val);
962
5.83k
}
void llvm::yaml::detail::doMapping<llvm::yaml::MachineFunction>(llvm::yaml::IO&, llvm::yaml::MachineFunction&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
23.2k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
23.2k
  MappingTraits<T>::mapping(io, Val);
962
23.2k
}
void llvm::yaml::detail::doMapping<llvm::ModuleSummaryIndex>(llvm::yaml::IO&, llvm::ModuleSummaryIndex&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
73
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
73
  MappingTraits<T>::mapping(io, Val);
962
73
}
void llvm::yaml::detail::doMapping<llvm::yaml::FunctionSummaryYaml>(llvm::yaml::IO&, llvm::yaml::FunctionSummaryYaml&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
96
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
96
  MappingTraits<T>::mapping(io, Val);
962
96
}
void llvm::yaml::detail::doMapping<llvm::FunctionSummary::VFuncId>(llvm::yaml::IO&, llvm::FunctionSummary::VFuncId&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
100
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
100
  MappingTraits<T>::mapping(io, Val);
962
100
}
void llvm::yaml::detail::doMapping<llvm::FunctionSummary::ConstVCall>(llvm::yaml::IO&, llvm::FunctionSummary::ConstVCall&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
48
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
48
  MappingTraits<T>::mapping(io, Val);
962
48
}
void llvm::yaml::detail::doMapping<llvm::TypeIdSummary>(llvm::yaml::IO&, llvm::TypeIdSummary&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
104
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
104
  MappingTraits<T>::mapping(io, Val);
962
104
}
void llvm::yaml::detail::doMapping<llvm::TypeTestResolution>(llvm::yaml::IO&, llvm::TypeTestResolution&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
85
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
85
  MappingTraits<T>::mapping(io, Val);
962
85
}
void llvm::yaml::detail::doMapping<llvm::WholeProgramDevirtResolution>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
52
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
52
  MappingTraits<T>::mapping(io, Val);
962
52
}
void llvm::yaml::detail::doMapping<llvm::WholeProgramDevirtResolution::ByArg>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution::ByArg&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
27
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
27
  MappingTraits<T>::mapping(io, Val);
962
27
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
380
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
380
  MappingTraits<T>::mapping(io, Val);
962
380
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Kernel::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
1.79k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
1.79k
  MappingTraits<T>::mapping(io, Val);
962
1.79k
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
186
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
186
  MappingTraits<T>::mapping(io, Val);
962
186
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
7.63k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
7.63k
  MappingTraits<T>::mapping(io, Val);
962
7.63k
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
1.77k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
1.77k
  MappingTraits<T>::mapping(io, Val);
962
1.77k
}
void llvm::yaml::detail::doMapping<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
6
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
6
  MappingTraits<T>::mapping(io, Val);
962
6
}
FrontendActions.cpp:void llvm::yaml::detail::doMapping<(anonymous namespace)::TemplightEntry>(llvm::yaml::IO&, (anonymous namespace)::TemplightEntry&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
152
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
152
  MappingTraits<T>::mapping(io, Val);
962
152
}
void llvm::yaml::detail::doMapping<llvm::remarks::Remark*>(llvm::yaml::IO&, llvm::remarks::Remark*&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
427
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
427
  MappingTraits<T>::mapping(io, Val);
962
427
}
void llvm::yaml::detail::doMapping<llvm::remarks::RemarkLocation>(llvm::yaml::IO&, llvm::remarks::RemarkLocation&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
230
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
230
  MappingTraits<T>::mapping(io, Val);
962
230
}
void llvm::yaml::detail::doMapping<llvm::remarks::Argument>(llvm::yaml::IO&, llvm::remarks::Argument&, llvm::yaml::EmptyContext&)
Line
Count
Source
960
1.43k
template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961
1.43k
  MappingTraits<T>::mapping(io, Val);
962
1.43k
}
963
964
} // end namespace detail
965
966
template <typename T>
967
typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type
968
25.2k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
25.2k
  io.beginEnumScalar();
970
25.2k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
25.2k
  io.endEnumScalar();
972
25.2k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::yaml::MachineStackObject::ObjectType>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineStackObject::ObjectType>(llvm::yaml::IO&, llvm::yaml::MachineStackObject::ObjectType&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
1.50k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
1.50k
  io.beginEnumScalar();
970
1.50k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
1.50k
  io.endEnumScalar();
972
1.50k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::TargetStackID::Value>::value, void>::type llvm::yaml::yamlize<llvm::TargetStackID::Value>(llvm::yaml::IO&, llvm::TargetStackID::Value&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
2.15k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
2.15k
  io.beginEnumScalar();
970
2.15k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
2.15k
  io.endEnumScalar();
972
2.15k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::yaml::FixedMachineStackObject::ObjectType>::value, void>::type llvm::yaml::yamlize<llvm::yaml::FixedMachineStackObject::ObjectType>(llvm::yaml::IO&, llvm::yaml::FixedMachineStackObject::ObjectType&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
736
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
736
  io.beginEnumScalar();
970
736
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
736
  io.endEnumScalar();
972
736
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachineJumpTableInfo::JTEntryKind>::value, void>::type llvm::yaml::yamlize<llvm::MachineJumpTableInfo::JTEntryKind>(llvm::yaml::IO&, llvm::MachineJumpTableInfo::JTEntryKind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
29
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
29
  io.beginEnumScalar();
970
29
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
29
  io.endEnumScalar();
972
29
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::TypeTestResolution::Kind>::value, void>::type llvm::yaml::yamlize<llvm::TypeTestResolution::Kind>(llvm::yaml::IO&, llvm::TypeTestResolution::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
85
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
85
  io.beginEnumScalar();
970
85
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
85
  io.endEnumScalar();
972
85
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::WholeProgramDevirtResolution::Kind>::value, void>::type llvm::yaml::yamlize<llvm::WholeProgramDevirtResolution::Kind>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
52
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
52
  io.beginEnumScalar();
970
52
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
52
  io.endEnumScalar();
972
52
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::WholeProgramDevirtResolution::ByArg::Kind>::value, void>::type llvm::yaml::yamlize<llvm::WholeProgramDevirtResolution::ByArg::Kind>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution::ByArg::Kind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
27
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
27
  io.beginEnumScalar();
970
27
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
27
  io.endEnumScalar();
972
27
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::AMDGPU::HSAMD::ValueKind>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::ValueKind>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::ValueKind&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
7.63k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
7.63k
  io.beginEnumScalar();
970
7.63k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
7.63k
  io.endEnumScalar();
972
7.63k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::AMDGPU::HSAMD::ValueType>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::ValueType>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::ValueType&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
7.63k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
7.63k
  io.beginEnumScalar();
970
7.63k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
7.63k
  io.endEnumScalar();
972
7.63k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::AMDGPU::HSAMD::AddressSpaceQualifier>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::AddressSpaceQualifier>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::AddressSpaceQualifier&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
4.38k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
4.38k
  io.beginEnumScalar();
970
4.38k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
4.38k
  io.endEnumScalar();
972
4.38k
}
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::AMDGPU::HSAMD::AccessQualifier>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::AccessQualifier>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::AccessQualifier&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
968
1.00k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969
1.00k
  io.beginEnumScalar();
970
1.00k
  ScalarEnumerationTraits<T>::enumeration(io, Val);
971
1.00k
  io.endEnumScalar();
972
1.00k
}
973
974
template <typename T>
975
typename std::enable_if<has_ScalarBitSetTraits<T>::value, void>::type
976
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
977
  bool DoClear;
978
  if ( io.beginBitSetScalar(DoClear) ) {
979
    if ( DoClear )
980
      Val = T();
981
    ScalarBitSetTraits<T>::bitset(io, Val);
982
    io.endBitSetScalar();
983
  }
984
}
985
986
template <typename T>
987
typename std::enable_if<has_ScalarTraits<T>::value, void>::type
988
859k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
859k
  if ( io.outputting() ) {
990
719k
    std::string Storage;
991
719k
    raw_string_ostream Buffer(Storage);
992
719k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
719k
    StringRef Str = Buffer.str();
994
719k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
719k
  }
996
140k
  else {
997
140k
    StringRef Str;
998
140k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
140k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
140k
    if ( !Result.empty() ) {
1001
8
      io.setError(Twine(Result));
1002
8
    }
1003
140k
  }
1004
859k
}
std::__1::enable_if<has_ScalarTraits<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >::value, void>::type llvm::yaml::yamlize<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(llvm::yaml::IO&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
10.2k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
10.2k
  if ( io.outputting() ) {
990
8.94k
    std::string Storage;
991
8.94k
    raw_string_ostream Buffer(Storage);
992
8.94k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
8.94k
    StringRef Str = Buffer.str();
994
8.94k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
8.94k
  }
996
1.29k
  else {
997
1.29k
    StringRef Str;
998
1.29k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
1.29k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
1.29k
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
1.29k
  }
1004
10.2k
}
std::__1::enable_if<has_ScalarTraits<llvm::yaml::UnsignedValue>::value, void>::type llvm::yaml::yamlize<llvm::yaml::UnsignedValue>(llvm::yaml::IO&, llvm::yaml::UnsignedValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
88.8k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
88.8k
  if ( io.outputting() ) {
990
70.5k
    std::string Storage;
991
70.5k
    raw_string_ostream Buffer(Storage);
992
70.5k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
70.5k
    StringRef Str = Buffer.str();
994
70.5k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
70.5k
  }
996
18.3k
  else {
997
18.3k
    StringRef Str;
998
18.3k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
18.3k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
18.3k
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
18.3k
  }
1004
88.8k
}
std::__1::enable_if<has_ScalarTraits<llvm::yaml::StringValue>::value, void>::type llvm::yaml::yamlize<llvm::yaml::StringValue>(llvm::yaml::IO&, llvm::yaml::StringValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
249k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
249k
  if ( io.outputting() ) {
990
219k
    std::string Storage;
991
219k
    raw_string_ostream Buffer(Storage);
992
219k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
219k
    StringRef Str = Buffer.str();
994
219k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
219k
  }
996
29.8k
  else {
997
29.8k
    StringRef Str;
998
29.8k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
29.8k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
29.8k
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
29.8k
  }
1004
249k
}
std::__1::enable_if<has_ScalarTraits<long long>::value, void>::type llvm::yaml::yamlize<long long>(llvm::yaml::IO&, long long&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
2.94k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
2.94k
  if ( io.outputting() ) {
990
1.99k
    std::string Storage;
991
1.99k
    raw_string_ostream Buffer(Storage);
992
1.99k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
1.99k
    StringRef Str = Buffer.str();
994
1.99k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
1.99k
  }
996
950
  else {
997
950
    StringRef Str;
998
950
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
950
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
950
    if ( !Result.empty() ) {
1001
2
      io.setError(Twine(Result));
1002
2
    }
1003
950
  }
1004
2.94k
}
std::__1::enable_if<has_ScalarTraits<unsigned long long>::value, void>::type llvm::yaml::yamlize<unsigned long long>(llvm::yaml::IO&, unsigned long long&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
27.5k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
27.5k
  if ( io.outputting() ) {
990
23.1k
    std::string Storage;
991
23.1k
    raw_string_ostream Buffer(Storage);
992
23.1k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
23.1k
    StringRef Str = Buffer.str();
994
23.1k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
23.1k
  }
996
4.44k
  else {
997
4.44k
    StringRef Str;
998
4.44k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
4.44k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
4.44k
    if ( !Result.empty() ) {
1001
1
      io.setError(Twine(Result));
1002
1
    }
1003
4.44k
  }
1004
27.5k
}
std::__1::enable_if<has_ScalarTraits<unsigned int>::value, void>::type llvm::yaml::yamlize<unsigned int>(llvm::yaml::IO&, unsigned int&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
126k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
126k
  if ( io.outputting() ) {
990
105k
    std::string Storage;
991
105k
    raw_string_ostream Buffer(Storage);
992
105k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
105k
    StringRef Str = Buffer.str();
994
105k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
105k
  }
996
20.6k
  else {
997
20.6k
    StringRef Str;
998
20.6k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
20.6k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
20.6k
    if ( !Result.empty() ) {
1001
1
      io.setError(Twine(Result));
1002
1
    }
1003
20.6k
  }
1004
126k
}
std::__1::enable_if<has_ScalarTraits<bool>::value, void>::type llvm::yaml::yamlize<bool>(llvm::yaml::IO&, bool&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
256k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
256k
  if ( io.outputting() ) {
990
227k
    std::string Storage;
991
227k
    raw_string_ostream Buffer(Storage);
992
227k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
227k
    StringRef Str = Buffer.str();
994
227k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
227k
  }
996
28.9k
  else {
997
28.9k
    StringRef Str;
998
28.9k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
28.9k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
28.9k
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
28.9k
  }
1004
256k
}
std::__1::enable_if<has_ScalarTraits<unsigned short>::value, void>::type llvm::yaml::yamlize<unsigned short>(llvm::yaml::IO&, unsigned short&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
11.3k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
11.3k
  if ( io.outputting() ) {
990
5.63k
    std::string Storage;
991
5.63k
    raw_string_ostream Buffer(Storage);
992
5.63k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
5.63k
    StringRef Str = Buffer.str();
994
5.63k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
5.63k
  }
996
5.75k
  else {
997
5.75k
    StringRef Str;
998
5.75k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
5.75k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
5.75k
    if ( !Result.empty() ) {
1001
1
      io.setError(Twine(Result));
1002
1
    }
1003
5.75k
  }
1004
11.3k
}
std::__1::enable_if<has_ScalarTraits<llvm::yaml::FlowStringValue>::value, void>::type llvm::yaml::yamlize<llvm::yaml::FlowStringValue>(llvm::yaml::IO&, llvm::yaml::FlowStringValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
1.56k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
1.56k
  if ( io.outputting() ) {
990
651
    std::string Storage;
991
651
    raw_string_ostream Buffer(Storage);
992
651
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
651
    StringRef Str = Buffer.str();
994
651
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
651
  }
996
913
  else {
997
913
    StringRef Str;
998
913
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
913
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
913
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
913
  }
1004
1.56k
}
std::__1::enable_if<has_ScalarTraits<int>::value, void>::type llvm::yaml::yamlize<int>(llvm::yaml::IO&, int&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
17.1k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
17.1k
  if ( io.outputting() ) {
990
12.9k
    std::string Storage;
991
12.9k
    raw_string_ostream Buffer(Storage);
992
12.9k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
12.9k
    StringRef Str = Buffer.str();
994
12.9k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
12.9k
  }
996
4.23k
  else {
997
4.23k
    StringRef Str;
998
4.23k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
4.23k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
4.23k
    if ( !Result.empty() ) {
1001
2
      io.setError(Twine(Result));
1002
2
    }
1003
4.23k
  }
1004
17.1k
}
std::__1::enable_if<has_ScalarTraits<llvm::StringRef>::value, void>::type llvm::yaml::yamlize<llvm::StringRef>(llvm::yaml::IO&, llvm::StringRef&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
60.0k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
60.0k
  if ( io.outputting() ) {
990
36.6k
    std::string Storage;
991
36.6k
    raw_string_ostream Buffer(Storage);
992
36.6k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
36.6k
    StringRef Str = Buffer.str();
994
36.6k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
36.6k
  }
996
23.4k
  else {
997
23.4k
    StringRef Str;
998
23.4k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
23.4k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
23.4k
    if ( !Result.empty() ) {
1001
0
      io.setError(Twine(Result));
1002
0
    }
1003
23.4k
  }
1004
60.0k
}
std::__1::enable_if<has_ScalarTraits<unsigned char>::value, void>::type llvm::yaml::yamlize<unsigned char>(llvm::yaml::IO&, unsigned char&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
988
7.62k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989
7.62k
  if ( io.outputting() ) {
990
6.46k
    std::string Storage;
991
6.46k
    raw_string_ostream Buffer(Storage);
992
6.46k
    ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993
6.46k
    StringRef Str = Buffer.str();
994
6.46k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995
6.46k
  }
996
1.16k
  else {
997
1.16k
    StringRef Str;
998
1.16k
    io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999
1.16k
    StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000
1.16k
    if ( !Result.empty() ) {
1001
1
      io.setError(Twine(Result));
1002
1
    }
1003
1.16k
  }
1004
7.62k
}
1005
1006
template <typename T>
1007
typename std::enable_if<has_BlockScalarTraits<T>::value, void>::type
1008
25.3k
yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1009
25.3k
  if (YamlIO.outputting()) {
1010
14.0k
    std::string Storage;
1011
14.0k
    raw_string_ostream Buffer(Storage);
1012
14.0k
    BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1013
14.0k
    StringRef Str = Buffer.str();
1014
14.0k
    YamlIO.blockScalarString(Str);
1015
14.0k
  } else {
1016
11.2k
    StringRef Str;
1017
11.2k
    YamlIO.blockScalarString(Str);
1018
11.2k
    StringRef Result =
1019
11.2k
        BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1020
11.2k
    if (!Result.empty())
1021
0
      YamlIO.setError(Twine(Result));
1022
11.2k
  }
1023
25.3k
}
std::__1::enable_if<has_BlockScalarTraits<llvm::yaml::BlockStringValue>::value, void>::type llvm::yaml::yamlize<llvm::yaml::BlockStringValue>(llvm::yaml::IO&, llvm::yaml::BlockStringValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1008
23.2k
yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1009
23.2k
  if (YamlIO.outputting()) {
1010
11.9k
    std::string Storage;
1011
11.9k
    raw_string_ostream Buffer(Storage);
1012
11.9k
    BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1013
11.9k
    StringRef Str = Buffer.str();
1014
11.9k
    YamlIO.blockScalarString(Str);
1015
11.9k
  } else {
1016
11.2k
    StringRef Str;
1017
11.2k
    YamlIO.blockScalarString(Str);
1018
11.2k
    StringRef Result =
1019
11.2k
        BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1020
11.2k
    if (!Result.empty())
1021
0
      YamlIO.setError(Twine(Result));
1022
11.2k
  }
1023
23.2k
}
std::__1::enable_if<has_BlockScalarTraits<llvm::Module>::value, void>::type llvm::yaml::yamlize<llvm::Module>(llvm::yaml::IO&, llvm::Module&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1008
2.09k
yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1009
2.09k
  if (YamlIO.outputting()) {
1010
2.09k
    std::string Storage;
1011
2.09k
    raw_string_ostream Buffer(Storage);
1012
2.09k
    BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1013
2.09k
    StringRef Str = Buffer.str();
1014
2.09k
    YamlIO.blockScalarString(Str);
1015
2.09k
  } else {
1016
0
    StringRef Str;
1017
0
    YamlIO.blockScalarString(Str);
1018
0
    StringRef Result =
1019
0
        BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1020
0
    if (!Result.empty())
1021
0
      YamlIO.setError(Twine(Result));
1022
0
  }
1023
2.09k
}
Unexecuted instantiation: std::__1::enable_if<has_BlockScalarTraits<llvm::yaml::StringBlockVal>::value, void>::type llvm::yaml::yamlize<llvm::yaml::StringBlockVal>(llvm::yaml::IO&, llvm::yaml::StringBlockVal&, bool, llvm::yaml::EmptyContext&)
1024
1025
template <typename T>
1026
typename std::enable_if<has_TaggedScalarTraits<T>::value, void>::type
1027
176k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1028
176k
  if (io.outputting()) {
1029
169k
    std::string ScalarStorage, TagStorage;
1030
169k
    raw_string_ostream ScalarBuffer(ScalarStorage), TagBuffer(TagStorage);
1031
169k
    TaggedScalarTraits<T>::output(Val, io.getContext(), ScalarBuffer,
1032
169k
                                  TagBuffer);
1033
169k
    io.scalarTag(TagBuffer.str());
1034
169k
    StringRef ScalarStr = ScalarBuffer.str();
1035
169k
    io.scalarString(ScalarStr,
1036
169k
                    TaggedScalarTraits<T>::mustQuote(Val, ScalarStr));
1037
169k
  } else {
1038
6.62k
    std::string Tag;
1039
6.62k
    io.scalarTag(Tag);
1040
6.62k
    StringRef Str;
1041
6.62k
    io.scalarString(Str, QuotingType::None);
1042
6.62k
    StringRef Result =
1043
6.62k
        TaggedScalarTraits<T>::input(Str, Tag, io.getContext(), Val);
1044
6.62k
    if (!Result.empty()) {
1045
0
      io.setError(Twine(Result));
1046
0
    }
1047
6.62k
  }
1048
176k
}
1049
1050
template <typename T, typename Context>
1051
typename std::enable_if<validatedMappingTraits<T, Context>::value, void>::type
1052
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1053
  if (has_FlowTraits<MappingTraits<T>>::value)
1054
    io.beginFlowMapping();
1055
  else
1056
    io.beginMapping();
1057
  if (io.outputting()) {
1058
    StringRef Err = MappingTraits<T>::validate(io, Val);
1059
    if (!Err.empty()) {
1060
      errs() << Err << "\n";
1061
      assert(Err.empty() && "invalid struct trying to be written as yaml");
1062
    }
1063
  }
1064
  detail::doMapping(io, Val, Ctx);
1065
  if (!io.outputting()) {
1066
    StringRef Err = MappingTraits<T>::validate(io, Val);
1067
    if (!Err.empty())
1068
      io.setError(Err);
1069
  }
1070
  if (has_FlowTraits<MappingTraits<T>>::value)
1071
    io.endFlowMapping();
1072
  else
1073
    io.endMapping();
1074
}
1075
1076
template <typename T, typename Context>
1077
typename std::enable_if<unvalidatedMappingTraits<T, Context>::value, void>::type
1078
180k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
180k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
105k
    io.beginFlowMapping();
1081
105k
    detail::doMapping(io, Val, Ctx);
1082
105k
    io.endFlowMapping();
1083
105k
  } else {
1084
74.6k
    io.beginMapping();
1085
74.6k
    detail::doMapping(io, Val, Ctx);
1086
74.6k
    io.endMapping();
1087
74.6k
  }
1088
180k
}
cc1gen_reproducer_main.cpp:std::__1::enable_if<unvalidatedMappingTraits<(anonymous namespace)::ClangInvocationInfo, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::ClangInvocationInfo, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::ClangInvocationInfo&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
3
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
3
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
3
  } else {
1084
3
    io.beginMapping();
1085
3
    detail::doMapping(io, Val, Ctx);
1086
3
    io.endMapping();
1087
3
  }
1088
3
}
cc1gen_reproducer_main.cpp:std::__1::enable_if<unvalidatedMappingTraits<(anonymous namespace)::UnsavedFileHash, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::UnsavedFileHash, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::UnsavedFileHash&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
2
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
2
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
2
  } else {
1084
2
    io.beginMapping();
1085
2
    detail::doMapping(io, Val, Ctx);
1086
2
    io.endMapping();
1087
2
  }
1088
2
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::CallSiteInfo::ArgRegPair, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::CallSiteInfo::ArgRegPair, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::CallSiteInfo::ArgRegPair&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
13
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
13
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
13
    io.beginFlowMapping();
1081
13
    detail::doMapping(io, Val, Ctx);
1082
13
    io.endFlowMapping();
1083
13
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
13
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineJumpTable::Entry, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineJumpTable::Entry, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineJumpTable::Entry&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
39
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
39
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
39
  } else {
1084
39
    io.beginMapping();
1085
39
    detail::doMapping(io, Val, Ctx);
1086
39
    io.endMapping();
1087
39
  }
1088
39
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::VirtualRegisterDefinition, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::VirtualRegisterDefinition, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::VirtualRegisterDefinition&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
86.2k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
86.2k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
86.2k
    io.beginFlowMapping();
1081
86.2k
    detail::doMapping(io, Val, Ctx);
1082
86.2k
    io.endFlowMapping();
1083
86.2k
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
86.2k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineFunctionLiveIn, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineFunctionLiveIn, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineFunctionLiveIn&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
4.83k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
4.83k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
4.83k
    io.beginFlowMapping();
1081
4.83k
    detail::doMapping(io, Val, Ctx);
1082
4.83k
    io.endFlowMapping();
1083
4.83k
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
4.83k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineFrameInfo, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineFrameInfo, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineFrameInfo&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
12.7k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
12.7k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
12.7k
  } else {
1084
12.7k
    io.beginMapping();
1085
12.7k
    detail::doMapping(io, Val, Ctx);
1086
12.7k
    io.endMapping();
1087
12.7k
  }
1088
12.7k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::FixedMachineStackObject, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::FixedMachineStackObject, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::FixedMachineStackObject&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
859
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
859
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
859
    io.beginFlowMapping();
1081
859
    detail::doMapping(io, Val, Ctx);
1082
859
    io.endFlowMapping();
1083
859
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
859
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineStackObject, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineStackObject, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineStackObject&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
1.64k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
1.64k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
1.64k
    io.beginFlowMapping();
1081
1.64k
    detail::doMapping(io, Val, Ctx);
1082
1.64k
    io.endFlowMapping();
1083
1.64k
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
1.64k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::CallSiteInfo, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::CallSiteInfo, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::CallSiteInfo&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
7
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
7
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
7
    io.beginFlowMapping();
1081
7
    detail::doMapping(io, Val, Ctx);
1082
7
    io.endFlowMapping();
1083
7
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
7
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineConstantPoolValue, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineConstantPoolValue, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineConstantPoolValue&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
124
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
124
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
124
  } else {
1084
124
    io.beginMapping();
1085
124
    detail::doMapping(io, Val, Ctx);
1086
124
    io.endMapping();
1087
124
  }
1088
124
}
std::__1::enable_if<unvalidatedMappingTraits<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::unique_ptr<llvm::yaml::MachineFunctionInfo, std::__1::default_delete<llvm::yaml::MachineFunctionInfo> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
12.5k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
12.5k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
12.5k
  } else {
1084
12.5k
    io.beginMapping();
1085
12.5k
    detail::doMapping(io, Val, Ctx);
1086
12.5k
    io.endMapping();
1087
12.5k
  }
1088
12.5k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineJumpTable, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineJumpTable, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineJumpTable&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
29
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
29
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
29
  } else {
1084
29
    io.beginMapping();
1085
29
    detail::doMapping(io, Val, Ctx);
1086
29
    io.endMapping();
1087
29
  }
1088
29
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::SIArgument, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::SIArgument, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::SIArgument&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
11.6k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
11.6k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
11.6k
    io.beginFlowMapping();
1081
11.6k
    detail::doMapping(io, Val, Ctx);
1082
11.6k
    io.endFlowMapping();
1083
11.6k
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
11.6k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::SIArgumentInfo, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::SIArgumentInfo, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::SIArgumentInfo&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
5.62k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
5.62k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
5.62k
  } else {
1084
5.62k
    io.beginMapping();
1085
5.62k
    detail::doMapping(io, Val, Ctx);
1086
5.62k
    io.endMapping();
1087
5.62k
  }
1088
5.62k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::SIMode, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::SIMode, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::SIMode&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
5.83k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
5.83k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
5.83k
  } else {
1084
5.83k
    io.beginMapping();
1085
5.83k
    detail::doMapping(io, Val, Ctx);
1086
5.83k
    io.endMapping();
1087
5.83k
  }
1088
5.83k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::MachineFunction, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::MachineFunction, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::MachineFunction&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
23.2k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
23.2k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
23.2k
  } else {
1084
23.2k
    io.beginMapping();
1085
23.2k
    detail::doMapping(io, Val, Ctx);
1086
23.2k
    io.endMapping();
1087
23.2k
  }
1088
23.2k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::ModuleSummaryIndex, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::ModuleSummaryIndex, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::ModuleSummaryIndex&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
73
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
73
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
73
  } else {
1084
73
    io.beginMapping();
1085
73
    detail::doMapping(io, Val, Ctx);
1086
73
    io.endMapping();
1087
73
  }
1088
73
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::yaml::FunctionSummaryYaml, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::yaml::FunctionSummaryYaml, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::yaml::FunctionSummaryYaml&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
96
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
96
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
96
  } else {
1084
96
    io.beginMapping();
1085
96
    detail::doMapping(io, Val, Ctx);
1086
96
    io.endMapping();
1087
96
  }
1088
96
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::FunctionSummary::VFuncId, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::FunctionSummary::VFuncId, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::FunctionSummary::VFuncId&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
100
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
100
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
100
  } else {
1084
100
    io.beginMapping();
1085
100
    detail::doMapping(io, Val, Ctx);
1086
100
    io.endMapping();
1087
100
  }
1088
100
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::FunctionSummary::ConstVCall, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::FunctionSummary::ConstVCall, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::FunctionSummary::ConstVCall&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
48
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
48
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
48
  } else {
1084
48
    io.beginMapping();
1085
48
    detail::doMapping(io, Val, Ctx);
1086
48
    io.endMapping();
1087
48
  }
1088
48
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::TypeIdSummary, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::TypeIdSummary, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::TypeIdSummary&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
104
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
104
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
104
  } else {
1084
104
    io.beginMapping();
1085
104
    detail::doMapping(io, Val, Ctx);
1086
104
    io.endMapping();
1087
104
  }
1088
104
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::TypeTestResolution, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::TypeTestResolution, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::TypeTestResolution&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
85
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
85
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
85
  } else {
1084
85
    io.beginMapping();
1085
85
    detail::doMapping(io, Val, Ctx);
1086
85
    io.endMapping();
1087
85
  }
1088
85
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::WholeProgramDevirtResolution, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::WholeProgramDevirtResolution, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
52
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
52
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
52
  } else {
1084
52
    io.beginMapping();
1085
52
    detail::doMapping(io, Val, Ctx);
1086
52
    io.endMapping();
1087
52
  }
1088
52
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::WholeProgramDevirtResolution::ByArg, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::WholeProgramDevirtResolution::ByArg, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::WholeProgramDevirtResolution::ByArg&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
27
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
27
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
27
  } else {
1084
27
    io.beginMapping();
1085
27
    detail::doMapping(io, Val, Ctx);
1086
27
    io.endMapping();
1087
27
  }
1088
27
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
380
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
380
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
380
  } else {
1084
380
    io.beginMapping();
1085
380
    detail::doMapping(io, Val, Ctx);
1086
380
    io.endMapping();
1087
380
  }
1088
380
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Kernel::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Kernel::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
1.79k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
1.79k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
1.79k
  } else {
1084
1.79k
    io.beginMapping();
1085
1.79k
    detail::doMapping(io, Val, Ctx);
1086
1.79k
    io.endMapping();
1087
1.79k
  }
1088
1.79k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Attrs::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
186
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
186
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
186
  } else {
1084
186
    io.beginMapping();
1085
186
    detail::doMapping(io, Val, Ctx);
1086
186
    io.endMapping();
1087
186
  }
1088
186
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
7.63k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
7.63k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
7.63k
  } else {
1084
7.63k
    io.beginMapping();
1085
7.63k
    detail::doMapping(io, Val, Ctx);
1086
7.63k
    io.endMapping();
1087
7.63k
  }
1088
7.63k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::CodeProps::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
1.77k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
1.77k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
1.77k
  } else {
1084
1.77k
    io.beginMapping();
1085
1.77k
    detail::doMapping(io, Val, Ctx);
1086
1.77k
    io.endMapping();
1087
1.77k
  }
1088
1.77k
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::AMDGPU::HSAMD::Kernel::DebugProps::Metadata&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
6
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
6
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
6
  } else {
1084
6
    io.beginMapping();
1085
6
    detail::doMapping(io, Val, Ctx);
1086
6
    io.endMapping();
1087
6
  }
1088
6
}
FrontendActions.cpp:std::__1::enable_if<unvalidatedMappingTraits<(anonymous namespace)::TemplightEntry, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::TemplightEntry, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::TemplightEntry&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
152
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
152
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
152
  } else {
1084
152
    io.beginMapping();
1085
152
    detail::doMapping(io, Val, Ctx);
1086
152
    io.endMapping();
1087
152
  }
1088
152
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::remarks::Remark*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::remarks::Remark*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::remarks::Remark*&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
427
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
427
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
427
  } else {
1084
427
    io.beginMapping();
1085
427
    detail::doMapping(io, Val, Ctx);
1086
427
    io.endMapping();
1087
427
  }
1088
427
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::remarks::RemarkLocation, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::remarks::RemarkLocation, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::remarks::RemarkLocation&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
230
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
230
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
230
    io.beginFlowMapping();
1081
230
    detail::doMapping(io, Val, Ctx);
1082
230
    io.endFlowMapping();
1083
230
  } else {
1084
0
    io.beginMapping();
1085
0
    detail::doMapping(io, Val, Ctx);
1086
0
    io.endMapping();
1087
0
  }
1088
230
}
std::__1::enable_if<unvalidatedMappingTraits<llvm::remarks::Argument, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::remarks::Argument, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::remarks::Argument&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1078
1.43k
yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079
1.43k
  if (has_FlowTraits<MappingTraits<T>>::value) {
1080
0
    io.beginFlowMapping();
1081
0
    detail::doMapping(io, Val, Ctx);
1082
0
    io.endFlowMapping();
1083
1.43k
  } else {
1084
1.43k
    io.beginMapping();
1085
1.43k
    detail::doMapping(io, Val, Ctx);
1086
1.43k
    io.endMapping();
1087
1.43k
  }
1088
1.43k
}
1089
1090
template <typename T>
1091
typename std::enable_if<has_CustomMappingTraits<T>::value, void>::type
1092
24.7k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
24.7k
  if ( io.outputting() ) {
1094
23.6k
    io.beginMapping();
1095
23.6k
    CustomMappingTraits<T>::output(io, Val);
1096
23.6k
    io.endMapping();
1097
23.6k
  } else {
1098
1.16k
    io.beginMapping();
1099
1.16k
    for (StringRef key : io.keys())
1100
6.74k
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
1.16k
    io.endMapping();
1102
1.16k
  }
1103
24.7k
}
std::__1::enable_if<has_CustomMappingTraits<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > > >::value, void>::type llvm::yaml::yamlize<std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > > >(llvm::yaml::IO&, std::__1::map<unsigned long long, llvm::GlobalValueSummaryInfo, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::GlobalValueSummaryInfo> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1092
54
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
54
  if ( io.outputting() ) {
1094
26
    io.beginMapping();
1095
26
    CustomMappingTraits<T>::output(io, Val);
1096
26
    io.endMapping();
1097
28
  } else {
1098
28
    io.beginMapping();
1099
28
    for (StringRef key : io.keys())
1100
60
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
28
    io.endMapping();
1102
28
  }
1103
54
}
std::__1::enable_if<has_CustomMappingTraits<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > > >::value, void>::type llvm::yaml::yamlize<std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > > >(llvm::yaml::IO&, std::__1::multimap<unsigned long long, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary>, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, llvm::TypeIdSummary> > > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1092
47
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
47
  if ( io.outputting() ) {
1094
26
    io.beginMapping();
1095
26
    CustomMappingTraits<T>::output(io, Val);
1096
26
    io.endMapping();
1097
26
  } else {
1098
21
    io.beginMapping();
1099
21
    for (StringRef key : io.keys())
1100
54
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
21
    io.endMapping();
1102
21
  }
1103
47
}
std::__1::enable_if<has_CustomMappingTraits<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > > >::value, void>::type llvm::yaml::yamlize<std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > > >(llvm::yaml::IO&, std::__1::map<unsigned long long, llvm::WholeProgramDevirtResolution, std::__1::less<unsigned long long>, std::__1::allocator<std::__1::pair<unsigned long long const, llvm::WholeProgramDevirtResolution> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1092
69
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
69
  if ( io.outputting() ) {
1094
50
    io.beginMapping();
1095
50
    CustomMappingTraits<T>::output(io, Val);
1096
50
    io.endMapping();
1097
50
  } else {
1098
19
    io.beginMapping();
1099
19
    for (StringRef key : io.keys())
1100
20
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
19
    io.endMapping();
1102
19
  }
1103
69
}
std::__1::enable_if<has_CustomMappingTraits<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > > >::value, void>::type llvm::yaml::yamlize<std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > > >(llvm::yaml::IO&, std::__1::map<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::WholeProgramDevirtResolution::ByArg, std::__1::less<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >, std::__1::allocator<std::__1::pair<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > const, llvm::WholeProgramDevirtResolution::ByArg> > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1092
47
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
47
  if ( io.outputting() ) {
1094
32
    io.beginMapping();
1095
32
    CustomMappingTraits<T>::output(io, Val);
1096
32
    io.endMapping();
1097
32
  } else {
1098
15
    io.beginMapping();
1099
15
    for (StringRef key : io.keys())
1100
17
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
15
    io.endMapping();
1102
15
  }
1103
47
}
std::__1::enable_if<has_CustomMappingTraits<llvm::msgpack::MapDocNode>::value, void>::type llvm::yaml::yamlize<llvm::msgpack::MapDocNode>(llvm::yaml::IO&, llvm::msgpack::MapDocNode&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1092
24.5k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093
24.5k
  if ( io.outputting() ) {
1094
23.4k
    io.beginMapping();
1095
23.4k
    CustomMappingTraits<T>::output(io, Val);
1096
23.4k
    io.endMapping();
1097
23.4k
  } else {
1098
1.08k
    io.beginMapping();
1099
1.08k
    for (StringRef key : io.keys())
1100
6.59k
      CustomMappingTraits<T>::inputOne(io, key, Val);
1101
1.08k
    io.endMapping();
1102
1.08k
  }
1103
24.5k
}
1104
1105
template <typename T>
1106
typename std::enable_if<has_PolymorphicTraits<T>::value, void>::type
1107
209k
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1108
209k
  switch (io.outputting() ? 
PolymorphicTraits<T>::getKind(Val)201k
1109
209k
                          : 
io.getNodeKind()8.00k
) {
1110
209k
  case NodeKind::Scalar:
1111
176k
    return yamlize(io, PolymorphicTraits<T>::getAsScalar(Val), true, Ctx);
1112
209k
  case NodeKind::Map:
1113
24.5k
    return yamlize(io, PolymorphicTraits<T>::getAsMap(Val), true, Ctx);
1114
209k
  case NodeKind::Sequence:
1115
8.48k
    return yamlize(io, PolymorphicTraits<T>::getAsSequence(Val), true, Ctx);
1116
209k
  }
1117
209k
}
1118
1119
template <typename T>
1120
typename std::enable_if<missingTraits<T, EmptyContext>::value, void>::type
1121
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1122
  char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1123
}
1124
1125
template <typename T, typename Context>
1126
typename std::enable_if<has_SequenceTraits<T>::value, void>::type
1127
91.2k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
91.2k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
1.59k
    unsigned incnt = io.beginFlowSequence();
1130
1.59k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)1.28k
:
incnt307
;
1131
6.44k
    for(unsigned i=0; i < count; 
++i4.85k
) {
1132
4.85k
      void *SaveInfo;
1133
4.85k
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
4.85k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
4.85k
        io.postflightFlowElement(SaveInfo);
1136
4.85k
      }
1137
4.85k
    }
1138
1.59k
    io.endFlowSequence();
1139
1.59k
  }
1140
89.6k
  else {
1141
89.6k
    unsigned incnt = io.beginSequence();
1142
89.6k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)81.1k
:
incnt8.48k
;
1143
220k
    for(unsigned i=0; i < count; 
++i131k
) {
1144
131k
      void *SaveInfo;
1145
131k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
131k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
131k
        io.postflightElement(SaveInfo);
1148
131k
      }
1149
131k
    }
1150
89.6k
    io.endSequence();
1151
89.6k
  }
1152
91.2k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
94
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
94
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
94
  else {
1141
94
    unsigned incnt = io.beginSequence();
1142
94
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)44
:
incnt50
;
1143
287
    for(unsigned i=0; i < count; 
++i193
) {
1144
193
      void *SaveInfo;
1145
193
      if ( io.preflightElement(i, SaveInfo) ) {
1146
193
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
193
        io.postflightElement(SaveInfo);
1148
193
      }
1149
193
    }
1150
94
    io.endSequence();
1151
94
  }
1152
94
}
cc1gen_reproducer_main.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
2
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
2
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
2
  else {
1141
2
    unsigned incnt = io.beginSequence();
1142
2
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)0
: incnt;
1143
4
    for(unsigned i=0; i < count; 
++i2
) {
1144
2
      void *SaveInfo;
1145
2
      if ( io.preflightElement(i, SaveInfo) ) {
1146
2
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
2
        io.postflightElement(SaveInfo);
1148
2
      }
1149
2
    }
1150
2
    io.endSequence();
1151
2
  }
1152
2
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
7
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
7
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
7
  else {
1141
7
    unsigned incnt = io.beginSequence();
1142
7
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)2
:
incnt5
;
1143
20
    for(unsigned i=0; i < count; 
++i13
) {
1144
13
      void *SaveInfo;
1145
13
      if ( io.preflightElement(i, SaveInfo) ) {
1146
13
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
13
        io.postflightElement(SaveInfo);
1148
13
      }
1149
13
    }
1150
7
    io.endSequence();
1151
7
  }
1152
7
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
68
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
68
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
68
    unsigned incnt = io.beginFlowSequence();
1130
68
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)30
:
incnt38
;
1131
1.63k
    for(unsigned i=0; i < count; 
++i1.56k
) {
1132
1.56k
      void *SaveInfo;
1133
1.56k
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
1.56k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
1.56k
        io.postflightFlowElement(SaveInfo);
1136
1.56k
      }
1137
1.56k
    }
1138
68
    io.endFlowSequence();
1139
68
  }
1140
0
  else {
1141
0
    unsigned incnt = io.beginSequence();
1142
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1143
0
    for(unsigned i=0; i < count; ++i) {
1144
0
      void *SaveInfo;
1145
0
      if ( io.preflightElement(i, SaveInfo) ) {
1146
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
0
        io.postflightElement(SaveInfo);
1148
0
      }
1149
0
    }
1150
0
    io.endSequence();
1151
0
  }
1152
68
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
28
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
28
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
28
  else {
1141
28
    unsigned incnt = io.beginSequence();
1142
28
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)13
:
incnt15
;
1143
67
    for(unsigned i=0; i < count; 
++i39
) {
1144
39
      void *SaveInfo;
1145
39
      if ( io.preflightElement(i, SaveInfo) ) {
1146
39
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
39
        io.postflightElement(SaveInfo);
1148
39
      }
1149
39
    }
1150
28
    io.endSequence();
1151
28
  }
1152
28
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
15.8k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
15.8k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
15.8k
  else {
1141
15.8k
    unsigned incnt = io.beginSequence();
1142
15.8k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.9k
:
incnt3.88k
;
1143
102k
    for(unsigned i=0; i < count; 
++i86.2k
) {
1144
86.2k
      void *SaveInfo;
1145
86.2k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
86.2k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
86.2k
        io.postflightElement(SaveInfo);
1148
86.2k
      }
1149
86.2k
    }
1150
15.8k
    io.endSequence();
1151
15.8k
  }
1152
15.8k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
13.2k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
13.2k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
13.2k
  else {
1141
13.2k
    unsigned incnt = io.beginSequence();
1142
13.2k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.8k
:
incnt1.39k
;
1143
18.1k
    for(unsigned i=0; i < count; 
++i4.83k
) {
1144
4.83k
      void *SaveInfo;
1145
4.83k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
4.83k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
4.83k
        io.postflightElement(SaveInfo);
1148
4.83k
      }
1149
4.83k
    }
1150
13.2k
    io.endSequence();
1151
13.2k
  }
1152
13.2k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
12.5k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
12.5k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
12.5k
  else {
1141
12.5k
    unsigned incnt = io.beginSequence();
1142
12.5k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.7k
:
incnt846
;
1143
13.4k
    for(unsigned i=0; i < count; 
++i859
) {
1144
859
      void *SaveInfo;
1145
859
      if ( io.preflightElement(i, SaveInfo) ) {
1146
859
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
859
        io.postflightElement(SaveInfo);
1148
859
      }
1149
859
    }
1150
12.5k
    io.endSequence();
1151
12.5k
  }
1152
12.5k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
12.6k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
12.6k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
12.6k
  else {
1141
12.6k
    unsigned incnt = io.beginSequence();
1142
12.6k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.7k
:
incnt923
;
1143
14.2k
    for(unsigned i=0; i < count; 
++i1.64k
) {
1144
1.64k
      void *SaveInfo;
1145
1.64k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
1.64k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
1.64k
        io.postflightElement(SaveInfo);
1148
1.64k
      }
1149
1.64k
    }
1150
12.6k
    io.endSequence();
1151
12.6k
  }
1152
12.6k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
11.7k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
11.7k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
11.7k
  else {
1141
11.7k
    unsigned incnt = io.beginSequence();
1142
11.7k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.7k
:
incnt45
;
1143
11.7k
    for(unsigned i=0; i < count; 
++i7
) {
1144
7
      void *SaveInfo;
1145
7
      if ( io.preflightElement(i, SaveInfo) ) {
1146
7
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
7
        io.postflightElement(SaveInfo);
1148
7
      }
1149
7
    }
1150
11.7k
    io.endSequence();
1151
11.7k
  }
1152
11.7k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
12.5k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
12.5k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
12.5k
  else {
1141
12.5k
    unsigned incnt = io.beginSequence();
1142
12.5k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)11.7k
:
incnt772
;
1143
12.6k
    for(unsigned i=0; i < count; 
++i124
) {
1144
124
      void *SaveInfo;
1145
124
      if ( io.preflightElement(i, SaveInfo) ) {
1146
124
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
124
        io.postflightElement(SaveInfo);
1148
124
      }
1149
124
    }
1150
12.5k
    io.endSequence();
1151
12.5k
  }
1152
12.5k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
96
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
96
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
96
  else {
1141
96
    unsigned incnt = io.beginSequence();
1142
96
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)36
:
incnt60
;
1143
192
    for(unsigned i=0; i < count; 
++i96
) {
1144
96
      void *SaveInfo;
1145
96
      if ( io.preflightElement(i, SaveInfo) ) {
1146
96
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
96
        io.postflightElement(SaveInfo);
1148
96
      }
1149
96
    }
1150
96
    io.endSequence();
1151
96
  }
1152
96
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
95
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
95
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
95
    unsigned incnt = io.beginFlowSequence();
1130
95
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)48
:
incnt47
;
1131
283
    for(unsigned i=0; i < count; 
++i188
) {
1132
188
      void *SaveInfo;
1133
188
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
188
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
188
        io.postflightFlowElement(SaveInfo);
1136
188
      }
1137
188
    }
1138
95
    io.endFlowSequence();
1139
95
  }
1140
0
  else {
1141
0
    unsigned incnt = io.beginSequence();
1142
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1143
0
    for(unsigned i=0; i < count; ++i) {
1144
0
      void *SaveInfo;
1145
0
      if ( io.preflightElement(i, SaveInfo) ) {
1146
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
0
        io.postflightElement(SaveInfo);
1148
0
      }
1149
0
    }
1150
0
    io.endSequence();
1151
0
  }
1152
95
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
48
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
48
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
48
  else {
1141
48
    unsigned incnt = io.beginSequence();
1142
48
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)24
:
incnt24
;
1143
100
    for(unsigned i=0; i < count; 
++i52
) {
1144
52
      void *SaveInfo;
1145
52
      if ( io.preflightElement(i, SaveInfo) ) {
1146
52
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
52
        io.postflightElement(SaveInfo);
1148
52
      }
1149
52
    }
1150
48
    io.endSequence();
1151
48
  }
1152
48
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
48
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
48
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
48
  else {
1141
48
    unsigned incnt = io.beginSequence();
1142
48
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)24
:
incnt24
;
1143
96
    for(unsigned i=0; i < count; 
++i48
) {
1144
48
      void *SaveInfo;
1145
48
      if ( io.preflightElement(i, SaveInfo) ) {
1146
48
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
48
        io.postflightElement(SaveInfo);
1148
48
      }
1149
48
    }
1150
48
    io.endSequence();
1151
48
  }
1152
48
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
1.43k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
1.43k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
1.43k
    unsigned incnt = io.beginFlowSequence();
1130
1.43k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)1.21k
:
incnt222
;
1131
4.53k
    for(unsigned i=0; i < count; 
++i3.10k
) {
1132
3.10k
      void *SaveInfo;
1133
3.10k
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
3.10k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
3.10k
        io.postflightFlowElement(SaveInfo);
1136
3.10k
      }
1137
3.10k
    }
1138
1.43k
    io.endFlowSequence();
1139
1.43k
  }
1140
0
  else {
1141
0
    unsigned incnt = io.beginSequence();
1142
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1143
0
    for(unsigned i=0; i < count; ++i) {
1144
0
      void *SaveInfo;
1145
0
      if ( io.preflightElement(i, SaveInfo) ) {
1146
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
0
        io.postflightElement(SaveInfo);
1148
0
      }
1149
0
    }
1150
0
    io.endSequence();
1151
0
  }
1152
1.43k
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
286
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
286
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
286
  else {
1141
286
    unsigned incnt = io.beginSequence();
1142
286
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)259
:
incnt27
;
1143
2.08k
    for(unsigned i=0; i < count; 
++i1.79k
) {
1144
1.79k
      void *SaveInfo;
1145
1.79k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
1.79k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
1.79k
        io.postflightElement(SaveInfo);
1148
1.79k
      }
1149
1.79k
    }
1150
286
    io.endSequence();
1151
286
  }
1152
286
}
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
1.47k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
1.47k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
1.47k
  else {
1141
1.47k
    unsigned incnt = io.beginSequence();
1142
1.47k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)1.35k
:
incnt117
;
1143
9.10k
    for(unsigned i=0; i < count; 
++i7.63k
) {
1144
7.63k
      void *SaveInfo;
1145
7.63k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
7.63k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
7.63k
        io.postflightElement(SaveInfo);
1148
7.63k
      }
1149
7.63k
    }
1150
1.47k
    io.endSequence();
1151
1.47k
  }
1152
1.47k
}
std::__1::enable_if<has_SequenceTraits<llvm::ArrayRef<llvm::remarks::Argument> >::value, void>::type llvm::yaml::yamlize<llvm::ArrayRef<llvm::remarks::Argument>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::ArrayRef<llvm::remarks::Argument>&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
427
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
427
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
427
  else {
1141
427
    unsigned incnt = io.beginSequence();
1142
427
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : 
incnt0
;
1143
1.86k
    for(unsigned i=0; i < count; 
++i1.43k
) {
1144
1.43k
      void *SaveInfo;
1145
1.43k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
1.43k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
1.43k
        io.postflightElement(SaveInfo);
1148
1.43k
      }
1149
1.43k
    }
1150
427
    io.endSequence();
1151
427
  }
1152
427
}
std::__1::enable_if<has_SequenceTraits<llvm::msgpack::ArrayDocNode>::value, void>::type llvm::yaml::yamlize<llvm::msgpack::ArrayDocNode, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::msgpack::ArrayDocNode&, bool, llvm::yaml::EmptyContext&)
Line
Count
Source
1127
8.48k
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128
8.48k
  if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129
0
    unsigned incnt = io.beginFlowSequence();
1130
0
    unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131
0
    for(unsigned i=0; i < count; ++i) {
1132
0
      void *SaveInfo;
1133
0
      if ( io.preflightFlowElement(i, SaveInfo) ) {
1134
0
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135
0
        io.postflightFlowElement(SaveInfo);
1136
0
      }
1137
0
    }
1138
0
    io.endFlowSequence();
1139
0
  }
1140
8.48k
  else {
1141
8.48k
    unsigned incnt = io.beginSequence();
1142
8.48k
    unsigned count = io.outputting() ? 
SequenceTraits<T>::size(io, Seq)8.19k
:
incnt288
;
1143
34.8k
    for(unsigned i=0; i < count; 
++i26.3k
) {
1144
26.3k
      void *SaveInfo;
1145
26.3k
      if ( io.preflightElement(i, SaveInfo) ) {
1146
26.3k
        yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147
26.3k
        io.postflightElement(SaveInfo);
1148
26.3k
      }
1149
26.3k
    }
1150
8.48k
    io.endSequence();
1151
8.48k
  }
1152
8.48k
}
1153
1154
template<>
1155
struct ScalarTraits<bool> {
1156
  static void output(const bool &, void* , raw_ostream &);
1157
  static StringRef input(StringRef, void *, bool &);
1158
256k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1159
};
1160
1161
template<>
1162
struct ScalarTraits<StringRef> {
1163
  static void output(const StringRef &, void *, raw_ostream &);
1164
  static StringRef input(StringRef, void *, StringRef &);
1165
60.1k
  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1166
};
1167
1168
template<>
1169
struct ScalarTraits<std::string> {
1170
  static void output(const std::string &, void *, raw_ostream &);
1171
  static StringRef input(StringRef, void *, std::string &);
1172
79.4k
  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1173
};
1174
1175
template<>
1176
struct ScalarTraits<uint8_t> {
1177
  static void output(const uint8_t &, void *, raw_ostream &);
1178
  static StringRef input(StringRef, void *, uint8_t &);
1179
7.62k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1180
};
1181
1182
template<>
1183
struct ScalarTraits<uint16_t> {
1184
  static void output(const uint16_t &, void *, raw_ostream &);
1185
  static StringRef input(StringRef, void *, uint16_t &);
1186
11.4k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1187
};
1188
1189
template<>
1190
struct ScalarTraits<uint32_t> {
1191
  static void output(const uint32_t &, void *, raw_ostream &);
1192
  static StringRef input(StringRef, void *, uint32_t &);
1193
215k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1194
};
1195
1196
template<>
1197
struct ScalarTraits<uint64_t> {
1198
  static void output(const uint64_t &, void *, raw_ostream &);
1199
  static StringRef input(StringRef, void *, uint64_t &);
1200
128k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1201
};
1202
1203
template<>
1204
struct ScalarTraits<int8_t> {
1205
  static void output(const int8_t &, void *, raw_ostream &);
1206
  static StringRef input(StringRef, void *, int8_t &);
1207
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1208
};
1209
1210
template<>
1211
struct ScalarTraits<int16_t> {
1212
  static void output(const int16_t &, void *, raw_ostream &);
1213
  static StringRef input(StringRef, void *, int16_t &);
1214
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1215
};
1216
1217
template<>
1218
struct ScalarTraits<int32_t> {
1219
  static void output(const int32_t &, void *, raw_ostream &);
1220
  static StringRef input(StringRef, void *, int32_t &);
1221
17.1k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1222
};
1223
1224
template<>
1225
struct ScalarTraits<int64_t> {
1226
  static void output(const int64_t &, void *, raw_ostream &);
1227
  static StringRef input(StringRef, void *, int64_t &);
1228
2.94k
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1229
};
1230
1231
template<>
1232
struct ScalarTraits<float> {
1233
  static void output(const float &, void *, raw_ostream &);
1234
  static StringRef input(StringRef, void *, float &);
1235
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1236
};
1237
1238
template<>
1239
struct ScalarTraits<double> {
1240
  static void output(const double &, void *, raw_ostream &);
1241
  static StringRef input(StringRef, void *, double &);
1242
33
  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1243
};
1244
1245
// For endian types, we use existing scalar Traits class for the underlying
1246
// type.  This way endian aware types are supported whenever the traits are
1247
// defined for the underlying type.
1248
template <typename value_type, support::endianness endian, size_t alignment>
1249
struct ScalarTraits<
1250
    support::detail::packed_endian_specific_integral<value_type, endian,
1251
                                                     alignment>,
1252
    typename std::enable_if<has_ScalarTraits<value_type>::value>::type> {
1253
  using endian_type =
1254
      support::detail::packed_endian_specific_integral<value_type, endian,
1255
                                                       alignment>;
1256
1257
  static void output(const endian_type &E, void *Ctx, raw_ostream &Stream) {
1258
    ScalarTraits<value_type>::output(static_cast<value_type>(E), Ctx, Stream);
1259
  }
1260
1261
  static StringRef input(StringRef Str, void *Ctx, endian_type &E) {
1262
    value_type V;
1263
    auto R = ScalarTraits<value_type>::input(Str, Ctx, V);
1264
    E = static_cast<endian_type>(V);
1265
    return R;
1266
  }
1267
1268
  static QuotingType mustQuote(StringRef Str) {
1269
    return ScalarTraits<value_type>::mustQuote(Str);
1270
  }
1271
};
1272
1273
template <typename value_type, support::endianness endian, size_t alignment>
1274
struct ScalarEnumerationTraits<
1275
    support::detail::packed_endian_specific_integral<value_type, endian,
1276
                                                     alignment>,
1277
    typename std::enable_if<
1278
        has_ScalarEnumerationTraits<value_type>::value>::type> {
1279
  using endian_type =
1280
      support::detail::packed_endian_specific_integral<value_type, endian,
1281
                                                       alignment>;
1282
1283
  static void enumeration(IO &io, endian_type &E) {
1284
    value_type V = E;
1285
    ScalarEnumerationTraits<value_type>::enumeration(io, V);
1286
    E = V;
1287
  }
1288
};
1289
1290
template <typename value_type, support::endianness endian, size_t alignment>
1291
struct ScalarBitSetTraits<
1292
    support::detail::packed_endian_specific_integral<value_type, endian,
1293
                                                     alignment>,
1294
    typename std::enable_if<has_ScalarBitSetTraits<value_type>::value>::type> {
1295
  using endian_type =
1296
      support::detail::packed_endian_specific_integral<value_type, endian,
1297
                                                       alignment>;
1298
  static void bitset(IO &io, endian_type &E) {
1299
    value_type V = E;
1300
    ScalarBitSetTraits<value_type>::bitset(io, V);
1301
    E = V;
1302
  }
1303
};
1304
1305
// Utility for use within MappingTraits<>::mapping() method
1306
// to [de]normalize an object for use with YAML conversion.
1307
template <typename TNorm, typename TFinal>
1308
struct MappingNormalization {
1309
  MappingNormalization(IO &i_o, TFinal &Obj)
1310
      : io(i_o), BufPtr(nullptr), Result(Obj) {
1311
    if ( io.outputting() ) {
1312
      BufPtr = new (&Buffer) TNorm(io, Obj);
1313
    }
1314
    else {
1315
      BufPtr = new (&Buffer) TNorm(io);
1316
    }
1317
  }
1318
1319
  ~MappingNormalization() {
1320
    if ( ! io.outputting() ) {
1321
      Result = BufPtr->denormalize(io);
1322
    }
1323
    BufPtr->~TNorm();
1324
  }
1325
1326
  TNorm* operator->() { return BufPtr; }
1327
1328
private:
1329
  using Storage = AlignedCharArrayUnion<TNorm>;
1330
1331
  Storage       Buffer;
1332
  IO           &io;
1333
  TNorm        *BufPtr;
1334
  TFinal       &Result;
1335
};
1336
1337
// Utility for use within MappingTraits<>::mapping() method
1338
// to [de]normalize an object for use with YAML conversion.
1339
template <typename TNorm, typename TFinal>
1340
struct MappingNormalizationHeap {
1341
  MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
1342
    : io(i_o), Result(Obj) {
1343
    if ( io.outputting() ) {
1344
      BufPtr = new (&Buffer) TNorm(io, Obj);
1345
    }
1346
    else if (allocator) {
1347
      BufPtr = allocator->Allocate<TNorm>();
1348
      new (BufPtr) TNorm(io);
1349
    } else {
1350
      BufPtr = new TNorm(io);
1351
    }
1352
  }
1353
1354
  ~MappingNormalizationHeap() {
1355
    if ( io.outputting() ) {
1356
      BufPtr->~TNorm();
1357
    }
1358
    else {
1359
      Result = BufPtr->denormalize(io);
1360
    }
1361
  }
1362
1363
  TNorm* operator->() { return BufPtr; }
1364
1365
private:
1366
  using Storage = AlignedCharArrayUnion<TNorm>;
1367
1368
  Storage       Buffer;
1369
  IO           &io;
1370
  TNorm        *BufPtr = nullptr;
1371
  TFinal       &Result;
1372
};
1373
1374
///
1375
/// The Input class is used to parse a yaml document into in-memory structs
1376
/// and vectors.
1377
///
1378
/// It works by using YAMLParser to do a syntax parse of the entire yaml
1379
/// document, then the Input class builds a graph of HNodes which wraps
1380
/// each yaml Node.  The extra layer is buffering.  The low level yaml
1381
/// parser only lets you look at each node once.  The buffering layer lets
1382
/// you search and interate multiple times.  This is necessary because
1383
/// the mapRequired() method calls may not be in the same order
1384
/// as the keys in the document.
1385
///
1386
class Input : public IO {
1387
public:
1388
  // Construct a yaml Input object from a StringRef and optional
1389
  // user-data. The DiagHandler can be specified to provide
1390
  // alternative error reporting.
1391
  Input(StringRef InputContent,
1392
        void *Ctxt = nullptr,
1393
        SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1394
        void *DiagHandlerCtxt = nullptr);
1395
  Input(MemoryBufferRef Input,
1396
        void *Ctxt = nullptr,
1397
        SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1398
        void *DiagHandlerCtxt = nullptr);
1399