/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 | 302k | void enumCase(T &Val, const char* Str, const T ConstVal) { |
793 | 302k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal235k ) ) { |
794 | 5.99k | Val = ConstVal; |
795 | 5.99k | } |
796 | 302k | } 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 | } |
void llvm::yaml::IO::enumCase<lld::MachOLinkingContext::Arch>(lld::MachOLinkingContext::Arch&, char const*, lld::MachOLinkingContext::Arch) Line | Count | Source | 792 | 2.23k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 2.23k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal8 ) ) { | 794 | 278 | Val = ConstVal; | 795 | 278 | } | 796 | 2.23k | } |
void llvm::yaml::IO::enumCase<llvm::MachO::HeaderFileType>(llvm::MachO::HeaderFileType&, char const*, llvm::MachO::HeaderFileType) Line | Count | Source | 792 | 1.11k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 1.11k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal4 ) ) { | 794 | 278 | Val = ConstVal; | 795 | 278 | } | 796 | 1.11k | } |
void llvm::yaml::IO::enumCase<lld::MachOLinkingContext::OS>(lld::MachOLinkingContext::OS&, char const*, lld::MachOLinkingContext::OS) Line | Count | Source | 792 | 284 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 284 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal4 ) ) { | 794 | 70 | Val = ConstVal; | 795 | 70 | } | 796 | 284 | } |
void llvm::yaml::IO::enumCase<llvm::MachO::LoadCommandType>(llvm::MachO::LoadCommandType&, char const*, llvm::MachO::LoadCommandType) Line | Count | Source | 792 | 28.1k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 28.1k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal11.3k ) ) { | 794 | 332 | Val = ConstVal; | 795 | 332 | } | 796 | 28.1k | } |
void llvm::yaml::IO::enumCase<llvm::MachO::SectionType>(llvm::MachO::SectionType&, char const*, llvm::MachO::SectionType) Line | Count | Source | 792 | 6.02k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 6.02k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal0 ) ) { | 794 | 274 | Val = ConstVal; | 795 | 274 | } | 796 | 6.02k | } |
void llvm::yaml::IO::enumCase<llvm::MachO::RelocationInfoType>(llvm::MachO::RelocationInfoType&, char const*, llvm::MachO::RelocationInfoType) Line | Count | Source | 792 | 3.56k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 3.56k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal0 ) ) { | 794 | 410 | Val = ConstVal; | 795 | 410 | } | 796 | 3.56k | } |
void llvm::yaml::IO::enumCase<llvm::MachO::NListType>(llvm::MachO::NListType&, char const*, llvm::MachO::NListType) Line | Count | Source | 792 | 2.23k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 2.23k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal0 ) ) { | 794 | 447 | Val = ConstVal; | 795 | 447 | } | 796 | 2.23k | } |
Unexecuted instantiation: void llvm::yaml::IO::enumCase<llvm::MachO::RebaseType>(llvm::MachO::RebaseType&, char const*, llvm::MachO::RebaseType) Unexecuted instantiation: void llvm::yaml::IO::enumCase<llvm::MachO::BindType>(llvm::MachO::BindType&, char const*, llvm::MachO::BindType) Unexecuted instantiation: void llvm::yaml::IO::enumCase<llvm::MachO::ExportSymbolKind>(llvm::MachO::ExportSymbolKind&, char const*, llvm::MachO::ExportSymbolKind) void llvm::yaml::IO::enumCase<llvm::MachO::DataRegionType>(llvm::MachO::DataRegionType&, char const*, llvm::MachO::DataRegionType) Line | Count | Source | 792 | 90 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 90 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal0 ) ) { | 794 | 18 | Val = ConstVal; | 795 | 18 | } | 796 | 90 | } |
void llvm::yaml::IO::enumCase<lld::Atom::Scope>(lld::Atom::Scope&, char const*, lld::Atom::Scope) Line | Count | Source | 792 | 507 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 507 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal408 ) ) { | 794 | 33 | Val = ConstVal; | 795 | 33 | } | 796 | 507 | } |
void llvm::yaml::IO::enumCase<lld::DefinedAtom::ContentType>(lld::DefinedAtom::ContentType&, char const*, lld::DefinedAtom::ContentType) Line | Count | Source | 792 | 8.18k | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 8.18k | if ( matchEnumScalar(Str, outputting() && Val == ConstVal6.60k ) ) { | 794 | 36 | Val = ConstVal; | 795 | 36 | } | 796 | 8.18k | } |
Unexecuted instantiation: void llvm::yaml::IO::enumCase<lld::DefinedAtom::Interposable>(lld::DefinedAtom::Interposable&, char const*, lld::DefinedAtom::Interposable) void llvm::yaml::IO::enumCase<lld::DefinedAtom::Merge>(lld::DefinedAtom::Merge&, char const*, lld::DefinedAtom::Merge) Line | Count | Source | 792 | 329 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 329 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal301 ) ) { | 794 | 4 | Val = ConstVal; | 795 | 4 | } | 796 | 329 | } |
void llvm::yaml::IO::enumCase<lld::DefinedAtom::SectionChoice>(lld::DefinedAtom::SectionChoice&, char const*, lld::DefinedAtom::SectionChoice) Line | Count | Source | 792 | 51 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 51 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal45 ) ) { | 794 | 2 | Val = ConstVal; | 795 | 2 | } | 796 | 51 | } |
void llvm::yaml::IO::enumCase<lld::DefinedAtom::DeadStripKind>(lld::DefinedAtom::DeadStripKind&, char const*, lld::DefinedAtom::DeadStripKind) Line | Count | Source | 792 | 141 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 141 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal129 ) ) { | 794 | 4 | Val = ConstVal; | 795 | 4 | } | 796 | 141 | } |
Unexecuted instantiation: void llvm::yaml::IO::enumCase<lld::DefinedAtom::DynamicExport>(lld::DefinedAtom::DynamicExport&, char const*, lld::DefinedAtom::DynamicExport) Unexecuted instantiation: void llvm::yaml::IO::enumCase<lld::DefinedAtom::CodeModel>(lld::DefinedAtom::CodeModel&, char const*, lld::DefinedAtom::CodeModel) void llvm::yaml::IO::enumCase<lld::DefinedAtom::ContentPermissions>(lld::DefinedAtom::ContentPermissions&, char const*, lld::DefinedAtom::ContentPermissions) Line | Count | Source | 792 | 7 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 7 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal) ) { | 794 | 0 | Val = ConstVal; | 795 | 0 | } | 796 | 7 | } |
Unexecuted instantiation: void llvm::yaml::IO::enumCase<lld::UndefinedAtom::CanBeNull>(lld::UndefinedAtom::CanBeNull&, char const*, lld::UndefinedAtom::CanBeNull) void llvm::yaml::IO::enumCase<lld::SharedLibraryAtom::Type>(lld::SharedLibraryAtom::Type&, char const*, lld::SharedLibraryAtom::Type) Line | Count | Source | 792 | 51 | void enumCase(T &Val, const char* Str, const T ConstVal) { | 793 | 51 | if ( matchEnumScalar(Str, outputting() && Val == ConstVal33 ) ) { | 794 | 6 | Val = ConstVal; | 795 | 6 | } | 796 | 51 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::enumCase<(anonymous namespace)::FileKinds>((anonymous namespace)::FileKinds&, char const*, (anonymous namespace)::FileKinds) Unexecuted instantiation: void llvm::yaml::IO::enumCase<lld::File::Kind>(lld::File::Kind&, char const*, lld::File::Kind) |
797 | | |
798 | | // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF |
799 | | template <typename T> |
800 | 0 | void enumCase(T &Val, const char* Str, const uint32_t ConstVal) { |
801 | 0 | if ( matchEnumScalar(Str, outputting() && Val == static_cast<T>(ConstVal)) ) { |
802 | 0 | Val = ConstVal; |
803 | 0 | } |
804 | 0 | } |
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 | 2.84k | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { |
827 | 2.84k | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal2 ) ) { |
828 | 865 | Val = static_cast<T>(Val | ConstVal); |
829 | 865 | } |
830 | 2.84k | } void llvm::yaml::IO::bitSetCase<lld::mach_o::normalized::FileFlags>(lld::mach_o::normalized::FileFlags&, char const*, unsigned int) Line | Count | Source | 826 | 340 | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { | 827 | 340 | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal2 ) ) { | 828 | 159 | Val = static_cast<T>(Val | ConstVal); | 829 | 159 | } | 830 | 340 | } |
void llvm::yaml::IO::bitSetCase<lld::mach_o::normalized::SectionAttr>(lld::mach_o::normalized::SectionAttr&, char const*, unsigned int) Line | Count | Source | 826 | 1.64k | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { | 827 | 1.64k | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal0 ) ) { | 828 | 306 | Val = static_cast<T>(Val | ConstVal); | 829 | 306 | } | 830 | 1.64k | } |
void llvm::yaml::IO::bitSetCase<lld::mach_o::normalized::SymbolScope>(lld::mach_o::normalized::SymbolScope&, char const*, unsigned int) Line | Count | Source | 826 | 698 | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { | 827 | 698 | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal0 ) ) { | 828 | 369 | Val = static_cast<T>(Val | ConstVal); | 829 | 369 | } | 830 | 698 | } |
void llvm::yaml::IO::bitSetCase<lld::mach_o::normalized::SymbolDesc>(lld::mach_o::normalized::SymbolDesc&, char const*, unsigned int) Line | Count | Source | 826 | 165 | void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) { | 827 | 165 | if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal0 ) ) { | 828 | 31 | Val = static_cast<T>(Val | ConstVal); | 829 | 31 | } | 830 | 165 | } |
Unexecuted instantiation: void llvm::yaml::IO::bitSetCase<lld::mach_o::normalized::ExportFlags>(lld::mach_o::normalized::ExportFlags&, char const*, unsigned int) |
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 | 513k | template <typename T> void mapRequired(const char *Key, T &Val) { |
849 | 513k | EmptyContext Ctx; |
850 | 513k | this->processKey(Key, Val, true, Ctx); |
851 | 513k | } 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 | } |
void llvm::yaml::IO::mapRequired<lld::MachOLinkingContext::Arch>(char const*, lld::MachOLinkingContext::Arch&) Line | Count | Source | 848 | 279 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 279 | EmptyContext Ctx; | 850 | 279 | this->processKey(Key, Val, true, Ctx); | 851 | 279 | } |
void llvm::yaml::IO::mapRequired<llvm::MachO::HeaderFileType>(char const*, llvm::MachO::HeaderFileType&) Line | Count | Source | 848 | 279 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 279 | EmptyContext Ctx; | 850 | 279 | this->processKey(Key, Val, true, Ctx); | 851 | 279 | } |
void llvm::yaml::IO::mapRequired<llvm::yaml::Hex64>(char const*, llvm::yaml::Hex64&) Line | Count | Source | 848 | 4.44k | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 4.44k | EmptyContext Ctx; | 850 | 4.44k | this->processKey(Key, Val, true, Ctx); | 851 | 4.44k | } |
Unexecuted instantiation: void llvm::yaml::IO::mapRequired<lld::mach_o::normalized::VMProtect>(char const*, lld::mach_o::normalized::VMProtect&) void llvm::yaml::IO::mapRequired<llvm::MachO::SectionType>(char const*, llvm::MachO::SectionType&) Line | Count | Source | 848 | 274 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 274 | EmptyContext Ctx; | 850 | 274 | this->processKey(Key, Val, true, Ctx); | 851 | 274 | } |
void llvm::yaml::IO::mapRequired<llvm::yaml::Hex32>(char const*, llvm::yaml::Hex32&) Line | Count | Source | 848 | 5.09k | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 5.09k | EmptyContext Ctx; | 850 | 5.09k | this->processKey(Key, Val, true, Ctx); | 851 | 5.09k | } |
void llvm::yaml::IO::mapRequired<llvm::MachO::RelocationInfoType>(char const*, llvm::MachO::RelocationInfoType&) Line | Count | Source | 848 | 410 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 410 | EmptyContext Ctx; | 850 | 410 | this->processKey(Key, Val, true, Ctx); | 851 | 410 | } |
void llvm::yaml::IO::mapRequired<unsigned char>(char const*, unsigned char&) Line | Count | Source | 848 | 7.08k | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 7.08k | EmptyContext Ctx; | 850 | 7.08k | this->processKey(Key, Val, true, Ctx); | 851 | 7.08k | } |
void llvm::yaml::IO::mapRequired<bool>(char const*, bool&) Line | Count | Source | 848 | 2.00k | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 2.00k | EmptyContext Ctx; | 850 | 2.00k | this->processKey(Key, Val, true, Ctx); | 851 | 2.00k | } |
void llvm::yaml::IO::mapRequired<llvm::MachO::NListType>(char const*, llvm::MachO::NListType&) Line | Count | Source | 848 | 447 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 447 | EmptyContext Ctx; | 850 | 447 | this->processKey(Key, Val, true, Ctx); | 851 | 447 | } |
void llvm::yaml::IO::mapRequired<int>(char const*, int&) Line | Count | Source | 848 | 4.01k | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 4.01k | EmptyContext Ctx; | 850 | 4.01k | this->processKey(Key, Val, true, Ctx); | 851 | 4.01k | } |
void llvm::yaml::IO::mapRequired<llvm::yaml::Hex16>(char const*, llvm::yaml::Hex16&) Line | Count | Source | 848 | 34 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 34 | EmptyContext Ctx; | 850 | 34 | this->processKey(Key, Val, true, Ctx); | 851 | 34 | } |
void llvm::yaml::IO::mapRequired<llvm::MachO::DataRegionType>(char const*, llvm::MachO::DataRegionType&) Line | Count | Source | 848 | 18 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 18 | EmptyContext Ctx; | 850 | 18 | this->processKey(Key, Val, true, Ctx); | 851 | 18 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapRequired<(anonymous namespace)::RefKind>(char const*, (anonymous namespace)::RefKind&) Line | Count | Source | 848 | 460 | template <typename T> void mapRequired(const char *Key, T &Val) { | 849 | 460 | EmptyContext Ctx; | 850 | 460 | this->processKey(Key, Val, true, Ctx); | 851 | 460 | } |
Unexecuted instantiation: void llvm::yaml::IO::mapRequired<lld::File const*>(char const*, lld::File const*&) |
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 | 190k | template <typename T> void mapOptional(const char *Key, T &Val) { |
859 | 190k | EmptyContext Ctx; |
860 | 190k | mapOptionalWithContext(Key, Val, Ctx); |
861 | 190k | } 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 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::FileFlags>(char const*, lld::mach_o::normalized::FileFlags&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> > >(char const*, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> > >(char const*, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&) Line | Count | Source | 858 | 436 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 436 | EmptyContext Ctx; | 860 | 436 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 436 | } |
void llvm::yaml::IO::mapOptional<lld::MachOLinkingContext::OS>(char const*, lld::MachOLinkingContext::OS&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> > >(char const*, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> > >(char const*, std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::SectionAttr>(char const*, lld::mach_o::normalized::SectionAttr&) Line | Count | Source | 858 | 274 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 274 | EmptyContext Ctx; | 860 | 274 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 274 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> > >(char const*, std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >&) Line | Count | Source | 858 | 1.09k | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 1.09k | EmptyContext Ctx; | 860 | 1.09k | mapOptionalWithContext(Key, Val, Ctx); | 861 | 1.09k | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> > >(char const*, std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >&) Line | Count | Source | 858 | 274 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 274 | EmptyContext Ctx; | 860 | 274 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 274 | } |
void llvm::yaml::IO::mapOptional<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 | 858 | 435 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 435 | EmptyContext Ctx; | 860 | 435 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 435 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> > >(char const*, std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >&) Line | Count | Source | 858 | 837 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 837 | EmptyContext Ctx; | 860 | 837 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 837 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> > >(char const*, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> > >(char const*, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&) Line | Count | Source | 858 | 837 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 837 | EmptyContext Ctx; | 860 | 837 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 837 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> > >(char const*, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<llvm::yaml::Hex64>(char const*, llvm::yaml::Hex64&) Line | Count | Source | 858 | 568 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 568 | EmptyContext Ctx; | 860 | 568 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 568 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::ExportFlags>(char const*, lld::mach_o::normalized::ExportFlags&) Line | Count | Source | 858 | 143 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 143 | EmptyContext Ctx; | 860 | 143 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 143 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> > >(char const*, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&) Line | Count | Source | 858 | 279 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 279 | EmptyContext Ctx; | 860 | 279 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 279 | } |
void llvm::yaml::IO::mapOptional<llvm::StringRef>(char const*, llvm::StringRef&) Line | Count | Source | 858 | 7.14k | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 7.14k | EmptyContext Ctx; | 860 | 7.14k | mapOptionalWithContext(Key, Val, Ctx); | 861 | 7.14k | } |
void llvm::yaml::IO::mapOptional<lld::File::AtomRange<lld::DefinedAtom> >(char const*, lld::File::AtomRange<lld::DefinedAtom>&) Line | Count | Source | 858 | 60 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 60 | EmptyContext Ctx; | 860 | 60 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 60 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> > >(char const*, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&) Line | Count | Source | 858 | 332 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 332 | EmptyContext Ctx; | 860 | 332 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 332 | } |
void llvm::yaml::IO::mapOptional<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> > >(char const*, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&) Line | Count | Source | 858 | 332 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 332 | EmptyContext Ctx; | 860 | 332 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::File::AtomRange<lld::UndefinedAtom> >(char const*, lld::File::AtomRange<lld::UndefinedAtom>&) Line | Count | Source | 858 | 60 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 60 | EmptyContext Ctx; | 860 | 60 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 60 | } |
void llvm::yaml::IO::mapOptional<lld::File::AtomRange<lld::SharedLibraryAtom> >(char const*, lld::File::AtomRange<lld::SharedLibraryAtom>&) Line | Count | Source | 858 | 60 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 60 | EmptyContext Ctx; | 860 | 60 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 60 | } |
void llvm::yaml::IO::mapOptional<lld::File::AtomRange<lld::AbsoluteAtom> >(char const*, lld::File::AtomRange<lld::AbsoluteAtom>&) Line | Count | Source | 858 | 60 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 60 | EmptyContext Ctx; | 860 | 60 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 60 | } |
Unexecuted instantiation: void llvm::yaml::IO::mapOptional<lld::Atom::Scope>(char const*, lld::Atom::Scope&) ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::AtomList<lld::DefinedAtom> >(char const*, (anonymous namespace)::AtomList<lld::DefinedAtom>&) Line | Count | Source | 858 | 19 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 19 | EmptyContext Ctx; | 860 | 19 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::AtomList<lld::UndefinedAtom> >(char const*, (anonymous namespace)::AtomList<lld::UndefinedAtom>&) Line | Count | Source | 858 | 19 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 19 | EmptyContext Ctx; | 860 | 19 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::AtomList<lld::SharedLibraryAtom> >(char const*, (anonymous namespace)::AtomList<lld::SharedLibraryAtom>&) Line | Count | Source | 858 | 19 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 19 | EmptyContext Ctx; | 860 | 19 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::AtomList<lld::AbsoluteAtom> >(char const*, (anonymous namespace)::AtomList<lld::AbsoluteAtom>&) Line | Count | Source | 858 | 19 | template <typename T> void mapOptional(const char *Key, T &Val) { | 859 | 19 | EmptyContext Ctx; | 860 | 19 | mapOptionalWithContext(Key, Val, Ctx); | 861 | 19 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> > >(char const*, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&) |
862 | | |
863 | | template <typename T, typename DefaultT> |
864 | 965k | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { |
865 | 965k | EmptyContext Ctx; |
866 | 965k | mapOptionalWithContext(Key, Val, Default, Ctx); |
867 | 965k | } 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 | } |
void llvm::yaml::IO::mapOptional<llvm::StringRef, llvm::StringRef>(char const*, llvm::StringRef&, llvm::StringRef const&) Line | Count | Source | 864 | 9.09k | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 9.09k | EmptyContext Ctx; | 866 | 9.09k | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 9.09k | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::PackedVersion, lld::mach_o::normalized::PackedVersion>(char const*, lld::mach_o::normalized::PackedVersion&, lld::mach_o::normalized::PackedVersion const&) Line | Count | Source | 864 | 1.11k | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 1.11k | EmptyContext Ctx; | 866 | 1.11k | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 1.11k | } |
void llvm::yaml::IO::mapOptional<llvm::yaml::Hex64, llvm::yaml::Hex64>(char const*, llvm::yaml::Hex64&, llvm::yaml::Hex64 const&) Line | Count | Source | 864 | 7.02k | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 7.02k | EmptyContext Ctx; | 866 | 7.02k | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 7.02k | } |
void llvm::yaml::IO::mapOptional<llvm::MachO::LoadCommandType, llvm::MachO::LoadCommandType>(char const*, llvm::MachO::LoadCommandType&, llvm::MachO::LoadCommandType const&) Line | Count | Source | 864 | 280 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 280 | EmptyContext Ctx; | 866 | 280 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 280 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::SectionAlignment, lld::mach_o::normalized::SectionAlignment>(char const*, lld::mach_o::normalized::SectionAlignment&, lld::mach_o::normalized::SectionAlignment const&) Line | Count | Source | 864 | 274 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 274 | EmptyContext Ctx; | 866 | 274 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 274 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::SymbolScope, lld::mach_o::normalized::SymbolScope>(char const*, lld::mach_o::normalized::SymbolScope&, lld::mach_o::normalized::SymbolScope const&) Line | Count | Source | 864 | 447 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 447 | EmptyContext Ctx; | 866 | 447 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 447 | } |
void llvm::yaml::IO::mapOptional<unsigned char, unsigned char>(char const*, unsigned char&, unsigned char const&) Line | Count | Source | 864 | 447 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 447 | EmptyContext Ctx; | 866 | 447 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 447 | } |
void llvm::yaml::IO::mapOptional<llvm::yaml::Hex16, llvm::yaml::Hex16>(char const*, llvm::yaml::Hex16&, llvm::yaml::Hex16 const&) Line | Count | Source | 864 | 135 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 135 | EmptyContext Ctx; | 866 | 135 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 135 | } |
void llvm::yaml::IO::mapOptional<lld::mach_o::normalized::SymbolDesc, lld::mach_o::normalized::SymbolDesc>(char const*, lld::mach_o::normalized::SymbolDesc&, lld::mach_o::normalized::SymbolDesc const&) Line | Count | Source | 864 | 344 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 344 | EmptyContext Ctx; | 866 | 344 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 344 | } |
void llvm::yaml::IO::mapOptional<llvm::yaml::Hex32, llvm::yaml::Hex32>(char const*, llvm::yaml::Hex32&, llvm::yaml::Hex32 const&) Line | Count | Source | 864 | 526 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 526 | EmptyContext Ctx; | 866 | 526 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 526 | } |
Unexecuted instantiation: void llvm::yaml::IO::mapOptional<llvm::MachO::RebaseType, llvm::MachO::RebaseType>(char const*, llvm::MachO::RebaseType&, llvm::MachO::RebaseType const&) Unexecuted instantiation: void llvm::yaml::IO::mapOptional<llvm::MachO::BindType, llvm::MachO::BindType>(char const*, llvm::MachO::BindType&, llvm::MachO::BindType const&) void llvm::yaml::IO::mapOptional<llvm::MachO::ExportSymbolKind, llvm::MachO::ExportSymbolKind>(char const*, llvm::MachO::ExportSymbolKind&, llvm::MachO::ExportSymbolKind const&) Line | Count | Source | 864 | 143 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 143 | EmptyContext Ctx; | 866 | 143 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 143 | } |
void llvm::yaml::IO::mapOptional<lld::Atom::Scope, lld::Atom::Scope>(char const*, lld::Atom::Scope&, lld::Atom::Scope const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::ContentType, lld::DefinedAtom::ContentType>(char const*, lld::DefinedAtom::ContentType&, lld::DefinedAtom::ContentType const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::Interposable, lld::DefinedAtom::Interposable>(char const*, lld::DefinedAtom::Interposable&, lld::DefinedAtom::Interposable const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::Merge, lld::DefinedAtom::Merge>(char const*, lld::DefinedAtom::Merge&, lld::DefinedAtom::Merge const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::Alignment, lld::DefinedAtom::Alignment>(char const*, lld::DefinedAtom::Alignment&, lld::DefinedAtom::Alignment const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::SectionChoice, lld::DefinedAtom::SectionChoice>(char const*, lld::DefinedAtom::SectionChoice&, lld::DefinedAtom::SectionChoice const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::DeadStripKind, lld::DefinedAtom::DeadStripKind>(char const*, lld::DefinedAtom::DeadStripKind&, lld::DefinedAtom::DeadStripKind const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::DynamicExport, lld::DefinedAtom::DynamicExport>(char const*, lld::DefinedAtom::DynamicExport&, lld::DefinedAtom::DynamicExport const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::CodeModel, lld::DefinedAtom::CodeModel>(char const*, lld::DefinedAtom::CodeModel&, lld::DefinedAtom::CodeModel const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::DefinedAtom::ContentPermissions, lld::DefinedAtom::ContentPermissions>(char const*, lld::DefinedAtom::ContentPermissions&, lld::DefinedAtom::ContentPermissions const&) Line | Count | Source | 864 | 332 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 332 | EmptyContext Ctx; | 866 | 332 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 332 | } |
void llvm::yaml::IO::mapOptional<lld::UndefinedAtom::CanBeNull, lld::UndefinedAtom::CanBeNull>(char const*, lld::UndefinedAtom::CanBeNull&, lld::UndefinedAtom::CanBeNull const&) Line | Count | Source | 864 | 48 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 48 | EmptyContext Ctx; | 866 | 48 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 48 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::ShlibCanBeNull, (anonymous namespace)::ShlibCanBeNull>(char const*, (anonymous namespace)::ShlibCanBeNull&, (anonymous namespace)::ShlibCanBeNull const&) Line | Count | Source | 864 | 17 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 17 | EmptyContext Ctx; | 866 | 17 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 17 | } |
void llvm::yaml::IO::mapOptional<lld::SharedLibraryAtom::Type, lld::SharedLibraryAtom::Type>(char const*, lld::SharedLibraryAtom::Type&, lld::SharedLibraryAtom::Type const&) Line | Count | Source | 864 | 17 | void mapOptional(const char *Key, T &Val, const DefaultT &Default) { | 865 | 17 | EmptyContext Ctx; | 866 | 17 | mapOptionalWithContext(Key, Val, Default, Ctx); | 867 | 17 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptional<(anonymous namespace)::FileKinds, (anonymous namespace)::FileKinds>(char const*, (anonymous namespace)::FileKinds&, (anonymous namespace)::FileKinds const&) |
868 | | |
869 | | template <typename T, typename Context> |
870 | | typename std::enable_if<has_SequenceTraits<T>::value, void>::type |
871 | 11.7k | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { |
872 | 11.7k | // omit key/value instead of outputting empty sequence |
873 | 11.7k | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())3.66k ) |
874 | 876 | return; |
875 | 10.8k | this->processKey(Key, Val, false, Ctx); |
876 | 10.8k | } 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 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 436 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 436 | // omit key/value instead of outputting empty sequence | 873 | 436 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())63 ) | 874 | 20 | return; | 875 | 416 | this->processKey(Key, Val, false, Ctx); | 876 | 416 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 1.09k | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 1.09k | // omit key/value instead of outputting empty sequence | 873 | 1.09k | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())235 ) | 874 | 221 | return; | 875 | 873 | this->processKey(Key, Val, false, Ctx); | 876 | 873 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 274 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 274 | // omit key/value instead of outputting empty sequence | 873 | 274 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())0 ) | 874 | 0 | return; | 875 | 274 | this->processKey(Key, Val, false, Ctx); | 876 | 274 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<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> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 435 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 435 | // omit key/value instead of outputting empty sequence | 873 | 435 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())144 ) | 874 | 0 | return; | 875 | 435 | this->processKey(Key, Val, false, Ctx); | 876 | 435 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 837 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 837 | // omit key/value instead of outputting empty sequence | 873 | 837 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())3 ) | 874 | 3 | return; | 875 | 834 | this->processKey(Key, Val, false, Ctx); | 876 | 834 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 837 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 837 | // omit key/value instead of outputting empty sequence | 873 | 837 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())3 ) | 874 | 3 | return; | 875 | 834 | this->processKey(Key, Val, false, Ctx); | 876 | 834 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 279 | // omit key/value instead of outputting empty sequence | 873 | 279 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())1 ) | 874 | 1 | return; | 875 | 278 | this->processKey(Key, Val, false, Ctx); | 876 | 278 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::DefinedAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<lld::File::AtomRange<lld::DefinedAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::DefinedAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 60 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 60 | // omit key/value instead of outputting empty sequence | 873 | 60 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())) | 874 | 0 | return; | 875 | 60 | this->processKey(Key, Val, false, Ctx); | 876 | 60 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 332 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 332 | // omit key/value instead of outputting empty sequence | 873 | 332 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())268 ) | 874 | 32 | return; | 875 | 300 | this->processKey(Key, Val, false, Ctx); | 876 | 300 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 332 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 332 | // omit key/value instead of outputting empty sequence | 873 | 332 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())272 ) | 874 | 159 | return; | 875 | 173 | this->processKey(Key, Val, false, Ctx); | 876 | 173 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::UndefinedAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<lld::File::AtomRange<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::UndefinedAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 60 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 60 | // omit key/value instead of outputting empty sequence | 873 | 60 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())) | 874 | 37 | return; | 875 | 23 | this->processKey(Key, Val, false, Ctx); | 876 | 23 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::SharedLibraryAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<lld::File::AtomRange<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::SharedLibraryAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 60 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 60 | // omit key/value instead of outputting empty sequence | 873 | 60 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())) | 874 | 53 | return; | 875 | 7 | this->processKey(Key, Val, false, Ctx); | 876 | 7 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::AbsoluteAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<lld::File::AtomRange<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::AbsoluteAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 60 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 60 | // omit key/value instead of outputting empty sequence | 873 | 60 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())) | 874 | 60 | return; | 875 | 0 | this->processKey(Key, Val, false, Ctx); | 876 | 0 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::DefinedAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::AtomList<lld::DefinedAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::DefinedAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 19 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 19 | // omit key/value instead of outputting empty sequence | 873 | 19 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())0 ) | 874 | 0 | return; | 875 | 19 | this->processKey(Key, Val, false, Ctx); | 876 | 19 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::UndefinedAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::AtomList<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::UndefinedAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 19 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 19 | // omit key/value instead of outputting empty sequence | 873 | 19 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())0 ) | 874 | 0 | return; | 875 | 19 | this->processKey(Key, Val, false, Ctx); | 876 | 19 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::SharedLibraryAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::AtomList<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::SharedLibraryAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 19 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 19 | // omit key/value instead of outputting empty sequence | 873 | 19 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())0 ) | 874 | 0 | return; | 875 | 19 | this->processKey(Key, Val, false, Ctx); | 876 | 19 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::AbsoluteAtom> >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::AtomList<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::AbsoluteAtom>&, llvm::yaml::EmptyContext&) Line | Count | Source | 871 | 19 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 872 | 19 | // omit key/value instead of outputting empty sequence | 873 | 19 | if (this->canElideEmptySequence() && !(Val.begin() != Val.end())0 ) | 874 | 0 | return; | 875 | 19 | this->processKey(Key, Val, false, Ctx); | 876 | 19 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> > >::value, void>::type llvm::yaml::IO::mapOptionalWithContext<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&, llvm::yaml::EmptyContext&) |
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 | 61.5k | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { |
887 | 61.5k | this->processKey(Key, Val, false, Ctx); |
888 | 61.5k | } 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 | } |
std::__1::enable_if<!(has_SequenceTraits<lld::mach_o::normalized::FileFlags>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::FileFlags, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::FileFlags&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 279 | this->processKey(Key, Val, false, Ctx); | 888 | 279 | } |
std::__1::enable_if<!(has_SequenceTraits<lld::MachOLinkingContext::OS>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<lld::MachOLinkingContext::OS, llvm::yaml::EmptyContext>(char const*, lld::MachOLinkingContext::OS&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 279 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 279 | this->processKey(Key, Val, false, Ctx); | 888 | 279 | } |
std::__1::enable_if<!(has_SequenceTraits<lld::mach_o::normalized::SectionAttr>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::SectionAttr, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::SectionAttr&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 274 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 274 | this->processKey(Key, Val, false, Ctx); | 888 | 274 | } |
std::__1::enable_if<!(has_SequenceTraits<llvm::yaml::Hex64>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::Hex64, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex64&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 568 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 568 | this->processKey(Key, Val, false, Ctx); | 888 | 568 | } |
std::__1::enable_if<!(has_SequenceTraits<lld::mach_o::normalized::ExportFlags>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::ExportFlags, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::ExportFlags&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 143 | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 143 | this->processKey(Key, Val, false, Ctx); | 888 | 143 | } |
std::__1::enable_if<!(has_SequenceTraits<llvm::StringRef>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<llvm::StringRef, llvm::yaml::EmptyContext>(char const*, llvm::StringRef&, llvm::yaml::EmptyContext&) Line | Count | Source | 886 | 7.14k | mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) { | 887 | 7.14k | this->processKey(Key, Val, false, Ctx); | 888 | 7.14k | } |
Unexecuted instantiation: std::__1::enable_if<!(has_SequenceTraits<lld::Atom::Scope>::value), void>::type llvm::yaml::IO::mapOptionalWithContext<lld::Atom::Scope, llvm::yaml::EmptyContext>(char const*, lld::Atom::Scope&, llvm::yaml::EmptyContext&) |
889 | | |
890 | | template <typename T, typename Context, typename DefaultT> |
891 | | void mapOptionalWithContext(const char *Key, T &Val, const DefaultT &Default, |
892 | 965k | Context &Ctx) { |
893 | 965k | static_assert(std::is_convertible<DefaultT, T>::value, |
894 | 965k | "Default type must be implicitly convertible to value type!"); |
895 | 965k | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), |
896 | 965k | false, Ctx); |
897 | 965k | } 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 | } |
void llvm::yaml::IO::mapOptionalWithContext<llvm::StringRef, llvm::yaml::EmptyContext, llvm::StringRef>(char const*, llvm::StringRef&, llvm::StringRef const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 9.09k | Context &Ctx) { | 893 | 9.09k | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 9.09k | "Default type must be implicitly convertible to value type!"); | 895 | 9.09k | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 9.09k | false, Ctx); | 897 | 9.09k | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::PackedVersion, llvm::yaml::EmptyContext, lld::mach_o::normalized::PackedVersion>(char const*, lld::mach_o::normalized::PackedVersion&, lld::mach_o::normalized::PackedVersion const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 1.11k | Context &Ctx) { | 893 | 1.11k | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 1.11k | "Default type must be implicitly convertible to value type!"); | 895 | 1.11k | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 1.11k | false, Ctx); | 897 | 1.11k | } |
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::Hex64, llvm::yaml::EmptyContext, llvm::yaml::Hex64>(char const*, llvm::yaml::Hex64&, llvm::yaml::Hex64 const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 7.02k | Context &Ctx) { | 893 | 7.02k | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 7.02k | "Default type must be implicitly convertible to value type!"); | 895 | 7.02k | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 7.02k | false, Ctx); | 897 | 7.02k | } |
void llvm::yaml::IO::mapOptionalWithContext<llvm::MachO::LoadCommandType, llvm::yaml::EmptyContext, llvm::MachO::LoadCommandType>(char const*, llvm::MachO::LoadCommandType&, llvm::MachO::LoadCommandType const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 280 | Context &Ctx) { | 893 | 280 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 280 | "Default type must be implicitly convertible to value type!"); | 895 | 280 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 280 | false, Ctx); | 897 | 280 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::SectionAlignment, llvm::yaml::EmptyContext, lld::mach_o::normalized::SectionAlignment>(char const*, lld::mach_o::normalized::SectionAlignment&, lld::mach_o::normalized::SectionAlignment const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 274 | Context &Ctx) { | 893 | 274 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 274 | "Default type must be implicitly convertible to value type!"); | 895 | 274 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 274 | false, Ctx); | 897 | 274 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::SymbolScope, llvm::yaml::EmptyContext, lld::mach_o::normalized::SymbolScope>(char const*, lld::mach_o::normalized::SymbolScope&, lld::mach_o::normalized::SymbolScope const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 447 | Context &Ctx) { | 893 | 447 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 447 | "Default type must be implicitly convertible to value type!"); | 895 | 447 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 447 | false, Ctx); | 897 | 447 | } |
void llvm::yaml::IO::mapOptionalWithContext<unsigned char, llvm::yaml::EmptyContext, unsigned char>(char const*, unsigned char&, unsigned char const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 447 | Context &Ctx) { | 893 | 447 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 447 | "Default type must be implicitly convertible to value type!"); | 895 | 447 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 447 | false, Ctx); | 897 | 447 | } |
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::Hex16, llvm::yaml::EmptyContext, llvm::yaml::Hex16>(char const*, llvm::yaml::Hex16&, llvm::yaml::Hex16 const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 135 | Context &Ctx) { | 893 | 135 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 135 | "Default type must be implicitly convertible to value type!"); | 895 | 135 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 135 | false, Ctx); | 897 | 135 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::mach_o::normalized::SymbolDesc, llvm::yaml::EmptyContext, lld::mach_o::normalized::SymbolDesc>(char const*, lld::mach_o::normalized::SymbolDesc&, lld::mach_o::normalized::SymbolDesc const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 344 | Context &Ctx) { | 893 | 344 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 344 | "Default type must be implicitly convertible to value type!"); | 895 | 344 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 344 | false, Ctx); | 897 | 344 | } |
void llvm::yaml::IO::mapOptionalWithContext<llvm::yaml::Hex32, llvm::yaml::EmptyContext, llvm::yaml::Hex32>(char const*, llvm::yaml::Hex32&, llvm::yaml::Hex32 const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 526 | Context &Ctx) { | 893 | 526 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 526 | "Default type must be implicitly convertible to value type!"); | 895 | 526 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 526 | false, Ctx); | 897 | 526 | } |
Unexecuted instantiation: void llvm::yaml::IO::mapOptionalWithContext<llvm::MachO::RebaseType, llvm::yaml::EmptyContext, llvm::MachO::RebaseType>(char const*, llvm::MachO::RebaseType&, llvm::MachO::RebaseType const&, llvm::yaml::EmptyContext&) Unexecuted instantiation: void llvm::yaml::IO::mapOptionalWithContext<llvm::MachO::BindType, llvm::yaml::EmptyContext, llvm::MachO::BindType>(char const*, llvm::MachO::BindType&, llvm::MachO::BindType const&, llvm::yaml::EmptyContext&) void llvm::yaml::IO::mapOptionalWithContext<llvm::MachO::ExportSymbolKind, llvm::yaml::EmptyContext, llvm::MachO::ExportSymbolKind>(char const*, llvm::MachO::ExportSymbolKind&, llvm::MachO::ExportSymbolKind const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 143 | Context &Ctx) { | 893 | 143 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 143 | "Default type must be implicitly convertible to value type!"); | 895 | 143 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 143 | false, Ctx); | 897 | 143 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::Atom::Scope, llvm::yaml::EmptyContext, lld::Atom::Scope>(char const*, lld::Atom::Scope&, lld::Atom::Scope const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::ContentType, llvm::yaml::EmptyContext, lld::DefinedAtom::ContentType>(char const*, lld::DefinedAtom::ContentType&, lld::DefinedAtom::ContentType const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::Interposable, llvm::yaml::EmptyContext, lld::DefinedAtom::Interposable>(char const*, lld::DefinedAtom::Interposable&, lld::DefinedAtom::Interposable const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::Merge, llvm::yaml::EmptyContext, lld::DefinedAtom::Merge>(char const*, lld::DefinedAtom::Merge&, lld::DefinedAtom::Merge const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::Alignment, llvm::yaml::EmptyContext, lld::DefinedAtom::Alignment>(char const*, lld::DefinedAtom::Alignment&, lld::DefinedAtom::Alignment const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::SectionChoice, llvm::yaml::EmptyContext, lld::DefinedAtom::SectionChoice>(char const*, lld::DefinedAtom::SectionChoice&, lld::DefinedAtom::SectionChoice const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::DeadStripKind, llvm::yaml::EmptyContext, lld::DefinedAtom::DeadStripKind>(char const*, lld::DefinedAtom::DeadStripKind&, lld::DefinedAtom::DeadStripKind const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::DynamicExport, llvm::yaml::EmptyContext, lld::DefinedAtom::DynamicExport>(char const*, lld::DefinedAtom::DynamicExport&, lld::DefinedAtom::DynamicExport const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::CodeModel, llvm::yaml::EmptyContext, lld::DefinedAtom::CodeModel>(char const*, lld::DefinedAtom::CodeModel&, lld::DefinedAtom::CodeModel const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::DefinedAtom::ContentPermissions, llvm::yaml::EmptyContext, lld::DefinedAtom::ContentPermissions>(char const*, lld::DefinedAtom::ContentPermissions&, lld::DefinedAtom::ContentPermissions const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 332 | Context &Ctx) { | 893 | 332 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 332 | "Default type must be implicitly convertible to value type!"); | 895 | 332 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 332 | false, Ctx); | 897 | 332 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::UndefinedAtom::CanBeNull, llvm::yaml::EmptyContext, lld::UndefinedAtom::CanBeNull>(char const*, lld::UndefinedAtom::CanBeNull&, lld::UndefinedAtom::CanBeNull const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 48 | Context &Ctx) { | 893 | 48 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 48 | "Default type must be implicitly convertible to value type!"); | 895 | 48 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 48 | false, Ctx); | 897 | 48 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::ShlibCanBeNull, llvm::yaml::EmptyContext, (anonymous namespace)::ShlibCanBeNull>(char const*, (anonymous namespace)::ShlibCanBeNull&, (anonymous namespace)::ShlibCanBeNull const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 17 | Context &Ctx) { | 893 | 17 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 17 | "Default type must be implicitly convertible to value type!"); | 895 | 17 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 17 | false, Ctx); | 897 | 17 | } |
void llvm::yaml::IO::mapOptionalWithContext<lld::SharedLibraryAtom::Type, llvm::yaml::EmptyContext, lld::SharedLibraryAtom::Type>(char const*, lld::SharedLibraryAtom::Type&, lld::SharedLibraryAtom::Type const&, llvm::yaml::EmptyContext&) Line | Count | Source | 892 | 17 | Context &Ctx) { | 893 | 17 | static_assert(std::is_convertible<DefaultT, T>::value, | 894 | 17 | "Default type must be implicitly convertible to value type!"); | 895 | 17 | this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default), | 896 | 17 | false, Ctx); | 897 | 17 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::mapOptionalWithContext<(anonymous namespace)::FileKinds, llvm::yaml::EmptyContext, (anonymous namespace)::FileKinds>(char const*, (anonymous namespace)::FileKinds&, (anonymous namespace)::FileKinds const&, llvm::yaml::EmptyContext&) |
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 | 940k | bool Required, Context &Ctx) { |
925 | 940k | void *SaveInfo; |
926 | 940k | bool UseDefault; |
927 | 940k | const bool sameAsDefault = outputting() && Val == DefaultValue666k ; |
928 | 940k | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, |
929 | 940k | SaveInfo) ) { |
930 | 663k | yamlize(*this, Val, Required, Ctx); |
931 | 663k | this->postflightKey(SaveInfo); |
932 | 663k | } |
933 | 276k | else { |
934 | 276k | if ( UseDefault ) |
935 | 197k | Val = DefaultValue; |
936 | 276k | } |
937 | 940k | } 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 | } |
void llvm::yaml::IO::processKeyWithDefault<llvm::StringRef, llvm::yaml::EmptyContext>(char const*, llvm::StringRef&, llvm::StringRef const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 9.09k | bool Required, Context &Ctx) { | 925 | 9.09k | void *SaveInfo; | 926 | 9.09k | bool UseDefault; | 927 | 9.09k | const bool sameAsDefault = outputting() && Val == DefaultValue1.65k ; | 928 | 9.09k | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 9.09k | SaveInfo) ) { | 930 | 4.73k | yamlize(*this, Val, Required, Ctx); | 931 | 4.73k | this->postflightKey(SaveInfo); | 932 | 4.73k | } | 933 | 4.36k | else { | 934 | 4.36k | if ( UseDefault ) | 935 | 3.46k | Val = DefaultValue; | 936 | 4.36k | } | 937 | 9.09k | } |
void llvm::yaml::IO::processKeyWithDefault<lld::mach_o::normalized::PackedVersion, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::PackedVersion&, lld::mach_o::normalized::PackedVersion const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 1.11k | bool Required, Context &Ctx) { | 925 | 1.11k | void *SaveInfo; | 926 | 1.11k | bool UseDefault; | 927 | 1.11k | const bool sameAsDefault = outputting() && Val == DefaultValue4 ; | 928 | 1.11k | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 1.11k | SaveInfo) ) { | 930 | 53 | yamlize(*this, Val, Required, Ctx); | 931 | 53 | this->postflightKey(SaveInfo); | 932 | 53 | } | 933 | 1.06k | else { | 934 | 1.06k | if ( UseDefault ) | 935 | 1.06k | Val = DefaultValue; | 936 | 1.06k | } | 937 | 1.11k | } |
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::Hex64, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex64&, llvm::yaml::Hex64 const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 7.02k | bool Required, Context &Ctx) { | 925 | 7.02k | void *SaveInfo; | 926 | 7.02k | bool UseDefault; | 927 | 7.02k | const bool sameAsDefault = outputting() && Val == DefaultValue569 ; | 928 | 7.02k | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 7.02k | SaveInfo) ) { | 930 | 1.66k | yamlize(*this, Val, Required, Ctx); | 931 | 1.66k | this->postflightKey(SaveInfo); | 932 | 1.66k | } | 933 | 5.36k | else { | 934 | 5.36k | if ( UseDefault ) | 935 | 4.92k | Val = DefaultValue; | 936 | 5.36k | } | 937 | 7.02k | } |
void llvm::yaml::IO::processKeyWithDefault<llvm::MachO::LoadCommandType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::LoadCommandType&, llvm::MachO::LoadCommandType const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 280 | bool Required, Context &Ctx) { | 925 | 280 | void *SaveInfo; | 926 | 280 | bool UseDefault; | 927 | 280 | const bool sameAsDefault = outputting() && Val == DefaultValue1 ; | 928 | 280 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 280 | SaveInfo) ) { | 930 | 5 | yamlize(*this, Val, Required, Ctx); | 931 | 5 | this->postflightKey(SaveInfo); | 932 | 5 | } | 933 | 275 | else { | 934 | 275 | if ( UseDefault ) | 935 | 274 | Val = DefaultValue; | 936 | 275 | } | 937 | 280 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::mach_o::normalized::SectionAlignment, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::SectionAlignment&, lld::mach_o::normalized::SectionAlignment const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 274 | bool Required, Context &Ctx) { | 925 | 274 | void *SaveInfo; | 926 | 274 | bool UseDefault; | 927 | 274 | const bool sameAsDefault = outputting() && Val == DefaultValue0 ; | 928 | 274 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 274 | SaveInfo) ) { | 930 | 121 | yamlize(*this, Val, Required, Ctx); | 931 | 121 | this->postflightKey(SaveInfo); | 932 | 121 | } | 933 | 153 | else { | 934 | 153 | if ( UseDefault ) | 935 | 153 | Val = DefaultValue; | 936 | 153 | } | 937 | 274 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::mach_o::normalized::SymbolScope, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::SymbolScope&, lld::mach_o::normalized::SymbolScope const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 447 | bool Required, Context &Ctx) { | 925 | 447 | void *SaveInfo; | 926 | 447 | bool UseDefault; | 927 | 447 | const bool sameAsDefault = outputting() && Val == DefaultValue0 ; | 928 | 447 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 447 | SaveInfo) ) { | 930 | 349 | yamlize(*this, Val, Required, Ctx); | 931 | 349 | this->postflightKey(SaveInfo); | 932 | 349 | } | 933 | 98 | else { | 934 | 98 | if ( UseDefault ) | 935 | 98 | Val = DefaultValue; | 936 | 98 | } | 937 | 447 | } |
void llvm::yaml::IO::processKeyWithDefault<unsigned char, llvm::yaml::EmptyContext>(char const*, unsigned char&, unsigned char const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 475 | bool Required, Context &Ctx) { | 925 | 475 | void *SaveInfo; | 926 | 475 | bool UseDefault; | 927 | 475 | const bool sameAsDefault = outputting() && Val == DefaultValue5 ; | 928 | 475 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 475 | SaveInfo) ) { | 930 | 348 | yamlize(*this, Val, Required, Ctx); | 931 | 348 | this->postflightKey(SaveInfo); | 932 | 348 | } | 933 | 127 | else { | 934 | 127 | if ( UseDefault ) | 935 | 124 | Val = DefaultValue; | 936 | 127 | } | 937 | 475 | } |
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::Hex16, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex16&, llvm::yaml::Hex16 const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 135 | bool Required, Context &Ctx) { | 925 | 135 | void *SaveInfo; | 926 | 135 | bool UseDefault; | 927 | 135 | const bool sameAsDefault = outputting() && Val == DefaultValue5 ; | 928 | 135 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 135 | SaveInfo) ) { | 930 | 6 | yamlize(*this, Val, Required, Ctx); | 931 | 6 | this->postflightKey(SaveInfo); | 932 | 6 | } | 933 | 129 | else { | 934 | 129 | if ( UseDefault ) | 935 | 124 | Val = DefaultValue; | 936 | 129 | } | 937 | 135 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::mach_o::normalized::SymbolDesc, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::SymbolDesc&, lld::mach_o::normalized::SymbolDesc const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 344 | bool Required, Context &Ctx) { | 925 | 344 | void *SaveInfo; | 926 | 344 | bool UseDefault; | 927 | 344 | const bool sameAsDefault = outputting() && Val == DefaultValue0 ; | 928 | 344 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 344 | SaveInfo) ) { | 930 | 33 | yamlize(*this, Val, Required, Ctx); | 931 | 33 | this->postflightKey(SaveInfo); | 932 | 33 | } | 933 | 311 | else { | 934 | 311 | if ( UseDefault ) | 935 | 311 | Val = DefaultValue; | 936 | 311 | } | 937 | 344 | } |
void llvm::yaml::IO::processKeyWithDefault<llvm::yaml::Hex32, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex32&, llvm::yaml::Hex32 const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 531 | bool Required, Context &Ctx) { | 925 | 531 | void *SaveInfo; | 926 | 531 | bool UseDefault; | 927 | 531 | const bool sameAsDefault = outputting() && Val == DefaultValue28 ; | 928 | 531 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 531 | SaveInfo) ) { | 930 | 48 | yamlize(*this, Val, Required, Ctx); | 931 | 48 | this->postflightKey(SaveInfo); | 932 | 48 | } | 933 | 483 | else { | 934 | 483 | if ( UseDefault ) | 935 | 468 | Val = DefaultValue; | 936 | 483 | } | 937 | 531 | } |
Unexecuted instantiation: void llvm::yaml::IO::processKeyWithDefault<llvm::MachO::RebaseType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::RebaseType&, llvm::MachO::RebaseType const&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: void llvm::yaml::IO::processKeyWithDefault<llvm::MachO::BindType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::BindType&, llvm::MachO::BindType const&, bool, llvm::yaml::EmptyContext&) void llvm::yaml::IO::processKeyWithDefault<llvm::MachO::ExportSymbolKind, llvm::yaml::EmptyContext>(char const*, llvm::MachO::ExportSymbolKind&, llvm::MachO::ExportSymbolKind const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 143 | bool Required, Context &Ctx) { | 925 | 143 | void *SaveInfo; | 926 | 143 | bool UseDefault; | 927 | 143 | const bool sameAsDefault = outputting() && Val == DefaultValue0 ; | 928 | 143 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 143 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 143 | else { | 934 | 143 | if ( UseDefault ) | 935 | 143 | Val = DefaultValue; | 936 | 143 | } | 937 | 143 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::Atom::Scope, llvm::yaml::EmptyContext>(char const*, lld::Atom::Scope&, lld::Atom::Scope const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 169 | yamlize(*this, Val, Required, Ctx); | 931 | 169 | this->postflightKey(SaveInfo); | 932 | 169 | } | 933 | 163 | else { | 934 | 163 | if ( UseDefault ) | 935 | 27 | Val = DefaultValue; | 936 | 163 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::ContentType, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::ContentType&, lld::DefinedAtom::ContentType const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 186 | yamlize(*this, Val, Required, Ctx); | 931 | 186 | this->postflightKey(SaveInfo); | 932 | 186 | } | 933 | 146 | else { | 934 | 146 | if ( UseDefault ) | 935 | 24 | Val = DefaultValue; | 936 | 146 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::Interposable, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::Interposable&, lld::DefinedAtom::Interposable const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 332 | else { | 934 | 332 | if ( UseDefault ) | 935 | 60 | Val = DefaultValue; | 936 | 332 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::Merge, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::Merge&, lld::DefinedAtom::Merge const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 47 | yamlize(*this, Val, Required, Ctx); | 931 | 47 | this->postflightKey(SaveInfo); | 932 | 47 | } | 933 | 285 | else { | 934 | 285 | if ( UseDefault ) | 935 | 56 | Val = DefaultValue; | 936 | 285 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::Alignment, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::Alignment&, lld::DefinedAtom::Alignment const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 177 | yamlize(*this, Val, Required, Ctx); | 931 | 177 | this->postflightKey(SaveInfo); | 932 | 177 | } | 933 | 155 | else { | 934 | 155 | if ( UseDefault ) | 935 | 53 | Val = DefaultValue; | 936 | 155 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::SectionChoice, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::SectionChoice&, lld::DefinedAtom::SectionChoice const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 17 | yamlize(*this, Val, Required, Ctx); | 931 | 17 | this->postflightKey(SaveInfo); | 932 | 17 | } | 933 | 315 | else { | 934 | 315 | if ( UseDefault ) | 935 | 58 | Val = DefaultValue; | 936 | 315 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::DeadStripKind, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::DeadStripKind&, lld::DefinedAtom::DeadStripKind const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 47 | yamlize(*this, Val, Required, Ctx); | 931 | 47 | this->postflightKey(SaveInfo); | 932 | 47 | } | 933 | 285 | else { | 934 | 285 | if ( UseDefault ) | 935 | 56 | Val = DefaultValue; | 936 | 285 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::DynamicExport, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::DynamicExport&, lld::DefinedAtom::DynamicExport const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 332 | else { | 934 | 332 | if ( UseDefault ) | 935 | 60 | Val = DefaultValue; | 936 | 332 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::CodeModel, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::CodeModel&, lld::DefinedAtom::CodeModel const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 332 | else { | 934 | 332 | if ( UseDefault ) | 935 | 60 | Val = DefaultValue; | 936 | 332 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::DefinedAtom::ContentPermissions, llvm::yaml::EmptyContext>(char const*, lld::DefinedAtom::ContentPermissions&, lld::DefinedAtom::ContentPermissions const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 332 | bool Required, Context &Ctx) { | 925 | 332 | void *SaveInfo; | 926 | 332 | bool UseDefault; | 927 | 332 | const bool sameAsDefault = outputting() && Val == DefaultValue272 ; | 928 | 332 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 332 | SaveInfo) ) { | 930 | 1 | yamlize(*this, Val, Required, Ctx); | 931 | 1 | this->postflightKey(SaveInfo); | 932 | 1 | } | 933 | 331 | else { | 934 | 331 | if ( UseDefault ) | 935 | 60 | Val = DefaultValue; | 936 | 331 | } | 937 | 332 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::UndefinedAtom::CanBeNull, llvm::yaml::EmptyContext>(char const*, lld::UndefinedAtom::CanBeNull&, lld::UndefinedAtom::CanBeNull const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 48 | bool Required, Context &Ctx) { | 925 | 48 | void *SaveInfo; | 926 | 48 | bool UseDefault; | 927 | 48 | const bool sameAsDefault = outputting() && Val == DefaultValue41 ; | 928 | 48 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 48 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 48 | else { | 934 | 48 | if ( UseDefault ) | 935 | 7 | Val = DefaultValue; | 936 | 48 | } | 937 | 48 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKeyWithDefault<(anonymous namespace)::ShlibCanBeNull, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::ShlibCanBeNull&, (anonymous namespace)::ShlibCanBeNull const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 17 | bool Required, Context &Ctx) { | 925 | 17 | void *SaveInfo; | 926 | 17 | bool UseDefault; | 927 | 17 | const bool sameAsDefault = outputting() && Val == DefaultValue11 ; | 928 | 17 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 17 | SaveInfo) ) { | 930 | 0 | yamlize(*this, Val, Required, Ctx); | 931 | 0 | this->postflightKey(SaveInfo); | 932 | 0 | } | 933 | 17 | else { | 934 | 17 | if ( UseDefault ) | 935 | 6 | Val = DefaultValue; | 936 | 17 | } | 937 | 17 | } |
void llvm::yaml::IO::processKeyWithDefault<lld::SharedLibraryAtom::Type, llvm::yaml::EmptyContext>(char const*, lld::SharedLibraryAtom::Type&, lld::SharedLibraryAtom::Type const&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 924 | 17 | bool Required, Context &Ctx) { | 925 | 17 | void *SaveInfo; | 926 | 17 | bool UseDefault; | 927 | 17 | const bool sameAsDefault = outputting() && Val == DefaultValue11 ; | 928 | 17 | if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault, | 929 | 17 | SaveInfo) ) { | 930 | 17 | yamlize(*this, Val, Required, Ctx); | 931 | 17 | this->postflightKey(SaveInfo); | 932 | 17 | } | 933 | 0 | else { | 934 | 0 | if ( UseDefault ) | 935 | 0 | Val = DefaultValue; | 936 | 0 | } | 937 | 17 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::processKeyWithDefault<(anonymous namespace)::FileKinds, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::FileKinds&, (anonymous namespace)::FileKinds const&, bool, llvm::yaml::EmptyContext&) |
938 | | |
939 | | template <typename T, typename Context> |
940 | 588k | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { |
941 | 588k | void *SaveInfo; |
942 | 588k | bool UseDefault; |
943 | 588k | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { |
944 | 545k | yamlize(*this, Val, Required, Ctx); |
945 | 545k | this->postflightKey(SaveInfo); |
946 | 545k | } |
947 | 588k | } 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 | } |
void llvm::yaml::IO::processKey<lld::MachOLinkingContext::Arch, llvm::yaml::EmptyContext>(char const*, lld::MachOLinkingContext::Arch&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 279 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 279 | void *SaveInfo; | 942 | 279 | bool UseDefault; | 943 | 279 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 279 | yamlize(*this, Val, Required, Ctx); | 945 | 279 | this->postflightKey(SaveInfo); | 946 | 279 | } | 947 | 279 | } |
void llvm::yaml::IO::processKey<llvm::MachO::HeaderFileType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::HeaderFileType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 279 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 279 | void *SaveInfo; | 942 | 279 | bool UseDefault; | 943 | 279 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 279 | yamlize(*this, Val, Required, Ctx); | 945 | 279 | this->postflightKey(SaveInfo); | 946 | 279 | } | 947 | 279 | } |
void llvm::yaml::IO::processKey<lld::mach_o::normalized::FileFlags, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::FileFlags&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 279 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 279 | void *SaveInfo; | 942 | 279 | bool UseDefault; | 943 | 279 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 170 | yamlize(*this, Val, Required, Ctx); | 945 | 170 | this->postflightKey(SaveInfo); | 946 | 170 | } | 947 | 279 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 1 | yamlize(*this, Val, Required, Ctx); | 945 | 1 | this->postflightKey(SaveInfo); | 946 | 1 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 524 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 524 | void *SaveInfo; | 942 | 524 | bool UseDefault; | 943 | 524 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 218 | yamlize(*this, Val, Required, Ctx); | 945 | 218 | this->postflightKey(SaveInfo); | 946 | 218 | } | 947 | 524 | } |
void llvm::yaml::IO::processKey<lld::MachOLinkingContext::OS, llvm::yaml::EmptyContext>(char const*, lld::MachOLinkingContext::OS&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 279 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 279 | void *SaveInfo; | 942 | 279 | bool UseDefault; | 943 | 279 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 71 | yamlize(*this, Val, Required, Ctx); | 945 | 71 | this->postflightKey(SaveInfo); | 946 | 71 | } | 947 | 279 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 0 | yamlize(*this, Val, Required, Ctx); | 945 | 0 | this->postflightKey(SaveInfo); | 946 | 0 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<llvm::yaml::Hex64, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex64&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 5.01k | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 5.01k | void *SaveInfo; | 942 | 5.01k | bool UseDefault; | 943 | 5.01k | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 4.86k | yamlize(*this, Val, Required, Ctx); | 945 | 4.86k | this->postflightKey(SaveInfo); | 946 | 4.86k | } | 947 | 5.01k | } |
Unexecuted instantiation: void llvm::yaml::IO::processKey<lld::mach_o::normalized::VMProtect, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::VMProtect&, bool, llvm::yaml::EmptyContext&) void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 164 | yamlize(*this, Val, Required, Ctx); | 945 | 164 | this->postflightKey(SaveInfo); | 946 | 164 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<llvm::MachO::SectionType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::SectionType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 274 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 274 | void *SaveInfo; | 942 | 274 | bool UseDefault; | 943 | 274 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 274 | yamlize(*this, Val, Required, Ctx); | 945 | 274 | this->postflightKey(SaveInfo); | 946 | 274 | } | 947 | 274 | } |
void llvm::yaml::IO::processKey<lld::mach_o::normalized::SectionAttr, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::SectionAttr&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 274 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 274 | void *SaveInfo; | 942 | 274 | bool UseDefault; | 943 | 274 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 274 | yamlize(*this, Val, Required, Ctx); | 945 | 274 | this->postflightKey(SaveInfo); | 946 | 274 | } | 947 | 274 | } |
void llvm::yaml::IO::processKey<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 873 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 873 | void *SaveInfo; | 942 | 873 | bool UseDefault; | 943 | 873 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 295 | yamlize(*this, Val, Required, Ctx); | 945 | 295 | this->postflightKey(SaveInfo); | 946 | 295 | } | 947 | 873 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 274 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 274 | void *SaveInfo; | 942 | 274 | bool UseDefault; | 943 | 274 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 87 | yamlize(*this, Val, Required, Ctx); | 945 | 87 | this->postflightKey(SaveInfo); | 946 | 87 | } | 947 | 274 | } |
void llvm::yaml::IO::processKey<llvm::yaml::Hex32, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex32&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 6.08k | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 6.08k | void *SaveInfo; | 942 | 6.08k | bool UseDefault; | 943 | 6.08k | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 6.06k | yamlize(*this, Val, Required, Ctx); | 945 | 6.06k | this->postflightKey(SaveInfo); | 946 | 6.06k | } | 947 | 6.08k | } |
void llvm::yaml::IO::processKey<llvm::MachO::RelocationInfoType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::RelocationInfoType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 410 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 410 | void *SaveInfo; | 942 | 410 | bool UseDefault; | 943 | 410 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 410 | yamlize(*this, Val, Required, Ctx); | 945 | 410 | this->postflightKey(SaveInfo); | 946 | 410 | } | 947 | 410 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 834 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 834 | void *SaveInfo; | 942 | 834 | bool UseDefault; | 943 | 834 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 232 | yamlize(*this, Val, Required, Ctx); | 945 | 232 | this->postflightKey(SaveInfo); | 946 | 232 | } | 947 | 834 | } |
void llvm::yaml::IO::processKey<llvm::MachO::NListType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::NListType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 447 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 447 | void *SaveInfo; | 942 | 447 | bool UseDefault; | 943 | 447 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 447 | yamlize(*this, Val, Required, Ctx); | 945 | 447 | this->postflightKey(SaveInfo); | 946 | 447 | } | 947 | 447 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 0 | yamlize(*this, Val, Required, Ctx); | 945 | 0 | this->postflightKey(SaveInfo); | 946 | 0 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 834 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 834 | void *SaveInfo; | 942 | 834 | bool UseDefault; | 943 | 834 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 0 | yamlize(*this, Val, Required, Ctx); | 945 | 0 | this->postflightKey(SaveInfo); | 946 | 0 | } | 947 | 834 | } |
void llvm::yaml::IO::processKey<int, llvm::yaml::EmptyContext>(char const*, int&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 4.99k | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 4.99k | void *SaveInfo; | 942 | 4.99k | bool UseDefault; | 943 | 4.99k | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 4.68k | yamlize(*this, Val, Required, Ctx); | 945 | 4.68k | this->postflightKey(SaveInfo); | 946 | 4.68k | } | 947 | 4.99k | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 106 | yamlize(*this, Val, Required, Ctx); | 945 | 106 | this->postflightKey(SaveInfo); | 946 | 106 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<lld::mach_o::normalized::ExportFlags, llvm::yaml::EmptyContext>(char const*, lld::mach_o::normalized::ExportFlags&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 143 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 143 | void *SaveInfo; | 942 | 143 | bool UseDefault; | 943 | 143 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 0 | yamlize(*this, Val, Required, Ctx); | 945 | 0 | this->postflightKey(SaveInfo); | 946 | 0 | } | 947 | 143 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 278 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 278 | void *SaveInfo; | 942 | 278 | bool UseDefault; | 943 | 278 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 3 | yamlize(*this, Val, Required, Ctx); | 945 | 3 | this->postflightKey(SaveInfo); | 946 | 3 | } | 947 | 278 | } |
void llvm::yaml::IO::processKey<llvm::yaml::Hex16, llvm::yaml::EmptyContext>(char const*, llvm::yaml::Hex16&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 34 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 34 | void *SaveInfo; | 942 | 34 | bool UseDefault; | 943 | 34 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 34 | yamlize(*this, Val, Required, Ctx); | 945 | 34 | this->postflightKey(SaveInfo); | 946 | 34 | } | 947 | 34 | } |
void llvm::yaml::IO::processKey<llvm::MachO::DataRegionType, llvm::yaml::EmptyContext>(char const*, llvm::MachO::DataRegionType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 18 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 18 | void *SaveInfo; | 942 | 18 | bool UseDefault; | 943 | 18 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 18 | yamlize(*this, Val, Required, Ctx); | 945 | 18 | this->postflightKey(SaveInfo); | 946 | 18 | } | 947 | 18 | } |
void llvm::yaml::IO::processKey<lld::File::AtomRange<lld::DefinedAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::DefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 60 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 60 | void *SaveInfo; | 942 | 60 | bool UseDefault; | 943 | 60 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 60 | yamlize(*this, Val, Required, Ctx); | 945 | 60 | this->postflightKey(SaveInfo); | 946 | 60 | } | 947 | 60 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 300 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 300 | void *SaveInfo; | 942 | 300 | bool UseDefault; | 943 | 300 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 288 | yamlize(*this, Val, Required, Ctx); | 945 | 288 | this->postflightKey(SaveInfo); | 946 | 288 | } | 947 | 300 | } |
void llvm::yaml::IO::processKey<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 173 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 173 | void *SaveInfo; | 942 | 173 | bool UseDefault; | 943 | 173 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 125 | yamlize(*this, Val, Required, Ctx); | 945 | 125 | this->postflightKey(SaveInfo); | 946 | 125 | } | 947 | 173 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<(anonymous namespace)::RefKind, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::RefKind&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 460 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 460 | void *SaveInfo; | 942 | 460 | bool UseDefault; | 943 | 460 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 460 | yamlize(*this, Val, Required, Ctx); | 945 | 460 | this->postflightKey(SaveInfo); | 946 | 460 | } | 947 | 460 | } |
void llvm::yaml::IO::processKey<lld::File::AtomRange<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::UndefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 23 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 23 | void *SaveInfo; | 942 | 23 | bool UseDefault; | 943 | 23 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 23 | yamlize(*this, Val, Required, Ctx); | 945 | 23 | this->postflightKey(SaveInfo); | 946 | 23 | } | 947 | 23 | } |
void llvm::yaml::IO::processKey<lld::File::AtomRange<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::SharedLibraryAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 7 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 7 | void *SaveInfo; | 942 | 7 | bool UseDefault; | 943 | 7 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 7 | yamlize(*this, Val, Required, Ctx); | 945 | 7 | this->postflightKey(SaveInfo); | 946 | 7 | } | 947 | 7 | } |
Unexecuted instantiation: void llvm::yaml::IO::processKey<lld::File::AtomRange<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(char const*, lld::File::AtomRange<lld::AbsoluteAtom>&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: void llvm::yaml::IO::processKey<lld::Atom::Scope, llvm::yaml::EmptyContext>(char const*, lld::Atom::Scope&, bool, llvm::yaml::EmptyContext&) ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<(anonymous namespace)::AtomList<lld::DefinedAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::DefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 19 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 19 | void *SaveInfo; | 942 | 19 | bool UseDefault; | 943 | 19 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 18 | yamlize(*this, Val, Required, Ctx); | 945 | 18 | this->postflightKey(SaveInfo); | 946 | 18 | } | 947 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<(anonymous namespace)::AtomList<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::UndefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 19 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 19 | void *SaveInfo; | 942 | 19 | bool UseDefault; | 943 | 19 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 5 | yamlize(*this, Val, Required, Ctx); | 945 | 5 | this->postflightKey(SaveInfo); | 946 | 5 | } | 947 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<(anonymous namespace)::AtomList<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::SharedLibraryAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 19 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 19 | void *SaveInfo; | 942 | 19 | bool UseDefault; | 943 | 19 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 6 | yamlize(*this, Val, Required, Ctx); | 945 | 6 | this->postflightKey(SaveInfo); | 946 | 6 | } | 947 | 19 | } |
ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<(anonymous namespace)::AtomList<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(char const*, (anonymous namespace)::AtomList<lld::AbsoluteAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 940 | 19 | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) { | 941 | 19 | void *SaveInfo; | 942 | 19 | bool UseDefault; | 943 | 19 | if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) { | 944 | 0 | yamlize(*this, Val, Required, Ctx); | 945 | 0 | this->postflightKey(SaveInfo); | 946 | 0 | } | 947 | 19 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::IO::processKey<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >, llvm::yaml::EmptyContext>(char const*, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: void llvm::yaml::IO::processKey<lld::File const*, llvm::yaml::EmptyContext>(char const*, lld::File const*&, bool, llvm::yaml::EmptyContext&) |
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 | 182k | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { |
961 | 182k | MappingTraits<T>::mapping(io, Val); |
962 | 182k | } 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 | } |
void llvm::yaml::detail::doMapping<lld::mach_o::normalized::DependentDylib>(llvm::yaml::IO&, lld::mach_o::normalized::DependentDylib&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 1 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 1 | MappingTraits<T>::mapping(io, Val); | 962 | 1 | } |
Unexecuted instantiation: void llvm::yaml::detail::doMapping<lld::mach_o::normalized::Segment>(llvm::yaml::IO&, lld::mach_o::normalized::Segment&, llvm::yaml::EmptyContext&) void llvm::yaml::detail::doMapping<lld::mach_o::normalized::Section>(llvm::yaml::IO&, lld::mach_o::normalized::Section&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 274 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 274 | MappingTraits<T>::mapping(io, Val); | 962 | 274 | } |
void llvm::yaml::detail::doMapping<lld::mach_o::normalized::Relocation>(llvm::yaml::IO&, lld::mach_o::normalized::Relocation&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 410 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 410 | MappingTraits<T>::mapping(io, Val); | 962 | 410 | } |
void llvm::yaml::detail::doMapping<lld::mach_o::normalized::Symbol>(llvm::yaml::IO&, lld::mach_o::normalized::Symbol&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 447 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 447 | MappingTraits<T>::mapping(io, Val); | 962 | 447 | } |
Unexecuted instantiation: void llvm::yaml::detail::doMapping<lld::mach_o::normalized::RebaseLocation>(llvm::yaml::IO&, lld::mach_o::normalized::RebaseLocation&, llvm::yaml::EmptyContext&) Unexecuted instantiation: void llvm::yaml::detail::doMapping<lld::mach_o::normalized::BindLocation>(llvm::yaml::IO&, lld::mach_o::normalized::BindLocation&, llvm::yaml::EmptyContext&) void llvm::yaml::detail::doMapping<lld::mach_o::normalized::Export>(llvm::yaml::IO&, lld::mach_o::normalized::Export&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 143 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 143 | MappingTraits<T>::mapping(io, Val); | 962 | 143 | } |
void llvm::yaml::detail::doMapping<lld::mach_o::normalized::DataInCode>(llvm::yaml::IO&, lld::mach_o::normalized::DataInCode&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 18 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 18 | MappingTraits<T>::mapping(io, Val); | 962 | 18 | } |
void llvm::yaml::detail::doMapping<lld::mach_o::normalized::NormalizedFile>(llvm::yaml::IO&, lld::mach_o::normalized::NormalizedFile&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 14 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 14 | MappingTraits<T>::mapping(io, Val); | 962 | 14 | } |
void llvm::yaml::detail::doMapping<lld::File const*>(llvm::yaml::IO&, lld::File const*&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 344 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 344 | MappingTraits<T>::mapping(io, Val); | 962 | 344 | } |
void llvm::yaml::detail::doMapping<lld::DefinedAtom*>(llvm::yaml::IO&, lld::DefinedAtom*&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 332 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 332 | MappingTraits<T>::mapping(io, Val); | 962 | 332 | } |
void llvm::yaml::detail::doMapping<lld::Reference const*>(llvm::yaml::IO&, lld::Reference const*&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 460 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 460 | MappingTraits<T>::mapping(io, Val); | 962 | 460 | } |
void llvm::yaml::detail::doMapping<lld::UndefinedAtom*>(llvm::yaml::IO&, lld::UndefinedAtom*&, 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<lld::SharedLibraryAtom*>(llvm::yaml::IO&, lld::SharedLibraryAtom*&, llvm::yaml::EmptyContext&) Line | Count | Source | 960 | 17 | template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) { | 961 | 17 | MappingTraits<T>::mapping(io, Val); | 962 | 17 | } |
Unexecuted instantiation: void llvm::yaml::detail::doMapping<lld::AbsoluteAtom*>(llvm::yaml::IO&, lld::AbsoluteAtom*&, llvm::yaml::EmptyContext&) Unexecuted instantiation: ReaderWriterYAML.cpp:void llvm::yaml::detail::doMapping<(anonymous namespace)::ArchMember>(llvm::yaml::IO&, (anonymous namespace)::ArchMember&, llvm::yaml::EmptyContext&) |
963 | | |
964 | | } // end namespace detail |
965 | | |
966 | | template <typename T> |
967 | | typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type |
968 | 28.0k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { |
969 | 28.0k | io.beginEnumScalar(); |
970 | 28.0k | ScalarEnumerationTraits<T>::enumeration(io, Val); |
971 | 28.0k | io.endEnumScalar(); |
972 | 28.0k | } 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 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::MachOLinkingContext::Arch>::value, void>::type llvm::yaml::yamlize<lld::MachOLinkingContext::Arch>(llvm::yaml::IO&, lld::MachOLinkingContext::Arch&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 279 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 279 | io.beginEnumScalar(); | 970 | 279 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 279 | io.endEnumScalar(); | 972 | 279 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::HeaderFileType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::HeaderFileType>(llvm::yaml::IO&, llvm::MachO::HeaderFileType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 279 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 279 | io.beginEnumScalar(); | 970 | 279 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 279 | io.endEnumScalar(); | 972 | 279 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::MachOLinkingContext::OS>::value, void>::type llvm::yaml::yamlize<lld::MachOLinkingContext::OS>(llvm::yaml::IO&, lld::MachOLinkingContext::OS&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 71 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 71 | io.beginEnumScalar(); | 970 | 71 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 71 | io.endEnumScalar(); | 972 | 71 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::LoadCommandType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::LoadCommandType>(llvm::yaml::IO&, llvm::MachO::LoadCommandType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 556 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 556 | io.beginEnumScalar(); | 970 | 556 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 556 | io.endEnumScalar(); | 972 | 556 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::SectionType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::SectionType>(llvm::yaml::IO&, llvm::MachO::SectionType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 274 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 274 | io.beginEnumScalar(); | 970 | 274 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 274 | io.endEnumScalar(); | 972 | 274 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::RelocationInfoType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::RelocationInfoType>(llvm::yaml::IO&, llvm::MachO::RelocationInfoType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 410 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 410 | io.beginEnumScalar(); | 970 | 410 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 410 | io.endEnumScalar(); | 972 | 410 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::NListType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::NListType>(llvm::yaml::IO&, llvm::MachO::NListType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 447 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 447 | io.beginEnumScalar(); | 970 | 447 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 447 | io.endEnumScalar(); | 972 | 447 | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::RebaseType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::RebaseType>(llvm::yaml::IO&, llvm::MachO::RebaseType&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::BindType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::BindType>(llvm::yaml::IO&, llvm::MachO::BindType&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::ExportSymbolKind>::value, void>::type llvm::yaml::yamlize<llvm::MachO::ExportSymbolKind>(llvm::yaml::IO&, llvm::MachO::ExportSymbolKind&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_ScalarEnumerationTraits<llvm::MachO::DataRegionType>::value, void>::type llvm::yaml::yamlize<llvm::MachO::DataRegionType>(llvm::yaml::IO&, llvm::MachO::DataRegionType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 18 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 18 | io.beginEnumScalar(); | 970 | 18 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 18 | io.endEnumScalar(); | 972 | 18 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::Atom::Scope>::value, void>::type llvm::yaml::yamlize<lld::Atom::Scope>(llvm::yaml::IO&, lld::Atom::Scope&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 169 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 169 | io.beginEnumScalar(); | 970 | 169 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 169 | io.endEnumScalar(); | 972 | 169 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::ContentType>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::ContentType>(llvm::yaml::IO&, lld::DefinedAtom::ContentType&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 186 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 186 | io.beginEnumScalar(); | 970 | 186 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 186 | io.endEnumScalar(); | 972 | 186 | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::Interposable>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::Interposable>(llvm::yaml::IO&, lld::DefinedAtom::Interposable&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::Merge>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::Merge>(llvm::yaml::IO&, lld::DefinedAtom::Merge&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 47 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 47 | io.beginEnumScalar(); | 970 | 47 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 47 | io.endEnumScalar(); | 972 | 47 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::SectionChoice>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::SectionChoice>(llvm::yaml::IO&, lld::DefinedAtom::SectionChoice&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 17 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 17 | io.beginEnumScalar(); | 970 | 17 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 17 | io.endEnumScalar(); | 972 | 17 | } |
std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::DeadStripKind>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::DeadStripKind>(llvm::yaml::IO&, lld::DefinedAtom::DeadStripKind&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 47 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 47 | io.beginEnumScalar(); | 970 | 47 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 47 | io.endEnumScalar(); | 972 | 47 | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::DynamicExport>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::DynamicExport>(llvm::yaml::IO&, lld::DefinedAtom::DynamicExport&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::CodeModel>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::CodeModel>(llvm::yaml::IO&, lld::DefinedAtom::CodeModel&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_ScalarEnumerationTraits<lld::DefinedAtom::ContentPermissions>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::ContentPermissions>(llvm::yaml::IO&, lld::DefinedAtom::ContentPermissions&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 1 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 1 | io.beginEnumScalar(); | 970 | 1 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 1 | io.endEnumScalar(); | 972 | 1 | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarEnumerationTraits<lld::UndefinedAtom::CanBeNull>::value, void>::type llvm::yaml::yamlize<lld::UndefinedAtom::CanBeNull>(llvm::yaml::IO&, lld::UndefinedAtom::CanBeNull&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<has_ScalarEnumerationTraits<(anonymous namespace)::ShlibCanBeNull>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::ShlibCanBeNull>(llvm::yaml::IO&, (anonymous namespace)::ShlibCanBeNull&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_ScalarEnumerationTraits<lld::SharedLibraryAtom::Type>::value, void>::type llvm::yaml::yamlize<lld::SharedLibraryAtom::Type>(llvm::yaml::IO&, lld::SharedLibraryAtom::Type&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 968 | 17 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 969 | 17 | io.beginEnumScalar(); | 970 | 17 | ScalarEnumerationTraits<T>::enumeration(io, Val); | 971 | 17 | io.endEnumScalar(); | 972 | 17 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<has_ScalarEnumerationTraits<(anonymous namespace)::FileKinds>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::FileKinds>(llvm::yaml::IO&, (anonymous namespace)::FileKinds&, bool, llvm::yaml::EmptyContext&) |
973 | | |
974 | | template <typename T> |
975 | | typename std::enable_if<has_ScalarBitSetTraits<T>::value, void>::type |
976 | 826 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { |
977 | 826 | bool DoClear; |
978 | 826 | if ( io.beginBitSetScalar(DoClear) ) { |
979 | 826 | if ( DoClear ) |
980 | 825 | Val = T(); |
981 | 826 | ScalarBitSetTraits<T>::bitset(io, Val); |
982 | 826 | io.endBitSetScalar(); |
983 | 826 | } |
984 | 826 | } std::__1::enable_if<has_ScalarBitSetTraits<lld::mach_o::normalized::FileFlags>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::FileFlags>(llvm::yaml::IO&, lld::mach_o::normalized::FileFlags&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 976 | 170 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 977 | 170 | bool DoClear; | 978 | 170 | if ( io.beginBitSetScalar(DoClear) ) { | 979 | 170 | if ( DoClear ) | 980 | 169 | Val = T(); | 981 | 170 | ScalarBitSetTraits<T>::bitset(io, Val); | 982 | 170 | io.endBitSetScalar(); | 983 | 170 | } | 984 | 170 | } |
std::__1::enable_if<has_ScalarBitSetTraits<lld::mach_o::normalized::SectionAttr>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::SectionAttr>(llvm::yaml::IO&, lld::mach_o::normalized::SectionAttr&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 976 | 274 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 977 | 274 | bool DoClear; | 978 | 274 | if ( io.beginBitSetScalar(DoClear) ) { | 979 | 274 | if ( DoClear ) | 980 | 274 | Val = T(); | 981 | 274 | ScalarBitSetTraits<T>::bitset(io, Val); | 982 | 274 | io.endBitSetScalar(); | 983 | 274 | } | 984 | 274 | } |
std::__1::enable_if<has_ScalarBitSetTraits<lld::mach_o::normalized::SymbolScope>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::SymbolScope>(llvm::yaml::IO&, lld::mach_o::normalized::SymbolScope&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 976 | 349 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 977 | 349 | bool DoClear; | 978 | 349 | if ( io.beginBitSetScalar(DoClear) ) { | 979 | 349 | if ( DoClear ) | 980 | 349 | Val = T(); | 981 | 349 | ScalarBitSetTraits<T>::bitset(io, Val); | 982 | 349 | io.endBitSetScalar(); | 983 | 349 | } | 984 | 349 | } |
std::__1::enable_if<has_ScalarBitSetTraits<lld::mach_o::normalized::SymbolDesc>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::SymbolDesc>(llvm::yaml::IO&, lld::mach_o::normalized::SymbolDesc&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 976 | 33 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 977 | 33 | bool DoClear; | 978 | 33 | if ( io.beginBitSetScalar(DoClear) ) { | 979 | 33 | if ( DoClear ) | 980 | 33 | Val = T(); | 981 | 33 | ScalarBitSetTraits<T>::bitset(io, Val); | 982 | 33 | io.endBitSetScalar(); | 983 | 33 | } | 984 | 33 | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarBitSetTraits<lld::mach_o::normalized::ExportFlags>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::ExportFlags>(llvm::yaml::IO&, lld::mach_o::normalized::ExportFlags&, bool, llvm::yaml::EmptyContext&) |
985 | | |
986 | | template <typename T> |
987 | | typename std::enable_if<has_ScalarTraits<T>::value, void>::type |
988 | 888k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { |
989 | 888k | if ( io.outputting() ) { |
990 | 728k | std::string Storage; |
991 | 728k | raw_string_ostream Buffer(Storage); |
992 | 728k | ScalarTraits<T>::output(Val, io.getContext(), Buffer); |
993 | 728k | StringRef Str = Buffer.str(); |
994 | 728k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); |
995 | 728k | } |
996 | 160k | else { |
997 | 160k | StringRef Str; |
998 | 160k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); |
999 | 160k | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); |
1000 | 160k | if ( !Result.empty() ) { |
1001 | 14 | io.setError(Twine(Result)); |
1002 | 14 | } |
1003 | 160k | } |
1004 | 888k | } 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 | } |
std::__1::enable_if<has_ScalarTraits<lld::mach_o::normalized::PackedVersion>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::PackedVersion>(llvm::yaml::IO&, lld::mach_o::normalized::PackedVersion&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 53 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 53 | if ( io.outputting() ) { | 990 | 2 | std::string Storage; | 991 | 2 | raw_string_ostream Buffer(Storage); | 992 | 2 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 2 | StringRef Str = Buffer.str(); | 994 | 2 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 2 | } | 996 | 51 | else { | 997 | 51 | StringRef Str; | 998 | 51 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 51 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 51 | if ( !Result.empty() ) { | 1001 | 0 | io.setError(Twine(Result)); | 1002 | 0 | } | 1003 | 51 | } | 1004 | 53 | } |
std::__1::enable_if<has_ScalarTraits<llvm::yaml::Hex64>::value, void>::type llvm::yaml::yamlize<llvm::yaml::Hex64>(llvm::yaml::IO&, llvm::yaml::Hex64&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 7.25k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 7.25k | if ( io.outputting() ) { | 990 | 1.11k | std::string Storage; | 991 | 1.11k | raw_string_ostream Buffer(Storage); | 992 | 1.11k | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 1.11k | StringRef Str = Buffer.str(); | 994 | 1.11k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 1.11k | } | 996 | 6.14k | else { | 997 | 6.14k | StringRef Str; | 998 | 6.14k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 6.14k | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 6.14k | if ( !Result.empty() ) { | 1001 | 2 | io.setError(Twine(Result)); | 1002 | 2 | } | 1003 | 6.14k | } | 1004 | 7.25k | } |
Unexecuted instantiation: std::__1::enable_if<has_ScalarTraits<lld::mach_o::normalized::VMProtect>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::VMProtect>(llvm::yaml::IO&, lld::mach_o::normalized::VMProtect&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_ScalarTraits<lld::mach_o::normalized::SectionAlignment>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::SectionAlignment>(llvm::yaml::IO&, lld::mach_o::normalized::SectionAlignment&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 121 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 121 | if ( io.outputting() ) { | 990 | 0 | std::string Storage; | 991 | 0 | raw_string_ostream Buffer(Storage); | 992 | 0 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 0 | StringRef Str = Buffer.str(); | 994 | 0 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 0 | } | 996 | 121 | else { | 997 | 121 | StringRef Str; | 998 | 121 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 121 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 121 | if ( !Result.empty() ) { | 1001 | 1 | io.setError(Twine(Result)); | 1002 | 1 | } | 1003 | 121 | } | 1004 | 121 | } |
std::__1::enable_if<has_ScalarTraits<llvm::yaml::Hex8>::value, void>::type llvm::yaml::yamlize<llvm::yaml::Hex8>(llvm::yaml::IO&, llvm::yaml::Hex8&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 6.74k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 6.74k | if ( io.outputting() ) { | 990 | 409 | std::string Storage; | 991 | 409 | raw_string_ostream Buffer(Storage); | 992 | 409 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 409 | StringRef Str = Buffer.str(); | 994 | 409 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 409 | } | 996 | 6.33k | else { | 997 | 6.33k | StringRef Str; | 998 | 6.33k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 6.33k | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 6.33k | if ( !Result.empty() ) { | 1001 | 1 | io.setError(Twine(Result)); | 1002 | 1 | } | 1003 | 6.33k | } | 1004 | 6.74k | } |
std::__1::enable_if<has_ScalarTraits<llvm::yaml::Hex32>::value, void>::type llvm::yaml::yamlize<llvm::yaml::Hex32>(llvm::yaml::IO&, llvm::yaml::Hex32&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 6.22k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 6.22k | if ( io.outputting() ) { | 990 | 2.98k | std::string Storage; | 991 | 2.98k | raw_string_ostream Buffer(Storage); | 992 | 2.98k | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 2.98k | StringRef Str = Buffer.str(); | 994 | 2.98k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 2.98k | } | 996 | 3.24k | else { | 997 | 3.24k | StringRef Str; | 998 | 3.24k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 3.24k | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 3.24k | if ( !Result.empty() ) { | 1001 | 1 | io.setError(Twine(Result)); | 1002 | 1 | } | 1003 | 3.24k | } | 1004 | 6.22k | } |
std::__1::enable_if<has_ScalarTraits<llvm::yaml::Hex16>::value, void>::type llvm::yaml::yamlize<llvm::yaml::Hex16>(llvm::yaml::IO&, llvm::yaml::Hex16&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 84 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 84 | if ( io.outputting() ) { | 990 | 25 | std::string Storage; | 991 | 25 | raw_string_ostream Buffer(Storage); | 992 | 25 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 25 | StringRef Str = Buffer.str(); | 994 | 25 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 25 | } | 996 | 59 | else { | 997 | 59 | StringRef Str; | 998 | 59 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 59 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 59 | if ( !Result.empty() ) { | 1001 | 1 | io.setError(Twine(Result)); | 1002 | 1 | } | 1003 | 59 | } | 1004 | 84 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_ScalarTraits<(anonymous namespace)::ImplicitHex8>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::ImplicitHex8>(llvm::yaml::IO&, (anonymous namespace)::ImplicitHex8&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 8.36k | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 8.36k | if ( io.outputting() ) { | 990 | 4.26k | std::string Storage; | 991 | 4.26k | raw_string_ostream Buffer(Storage); | 992 | 4.26k | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 4.26k | StringRef Str = Buffer.str(); | 994 | 4.26k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 4.26k | } | 996 | 4.10k | else { | 997 | 4.10k | StringRef Str; | 998 | 4.10k | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 4.10k | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 4.10k | if ( !Result.empty() ) { | 1001 | 0 | io.setError(Twine(Result)); | 1002 | 0 | } | 1003 | 4.10k | } | 1004 | 8.36k | } |
std::__1::enable_if<has_ScalarTraits<lld::DefinedAtom::Alignment>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom::Alignment>(llvm::yaml::IO&, lld::DefinedAtom::Alignment&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 177 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 177 | if ( io.outputting() ) { | 990 | 170 | std::string Storage; | 991 | 170 | raw_string_ostream Buffer(Storage); | 992 | 170 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 170 | StringRef Str = Buffer.str(); | 994 | 170 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 170 | } | 996 | 7 | else { | 997 | 7 | StringRef Str; | 998 | 7 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 7 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 7 | if ( !Result.empty() ) { | 1001 | 0 | io.setError(Twine(Result)); | 1002 | 0 | } | 1003 | 7 | } | 1004 | 177 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_ScalarTraits<(anonymous namespace)::RefKind>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::RefKind>(llvm::yaml::IO&, (anonymous namespace)::RefKind&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 988 | 460 | yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) { | 989 | 460 | if ( io.outputting() ) { | 990 | 442 | std::string Storage; | 991 | 442 | raw_string_ostream Buffer(Storage); | 992 | 442 | ScalarTraits<T>::output(Val, io.getContext(), Buffer); | 993 | 442 | StringRef Str = Buffer.str(); | 994 | 442 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 995 | 442 | } | 996 | 18 | else { | 997 | 18 | StringRef Str; | 998 | 18 | io.scalarString(Str, ScalarTraits<T>::mustQuote(Str)); | 999 | 18 | StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val); | 1000 | 18 | if ( !Result.empty() ) { | 1001 | 0 | io.setError(Twine(Result)); | 1002 | 0 | } | 1003 | 18 | } | 1004 | 460 | } |
|
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 | 14 | yamlize(IO &io, T &Val, bool, Context &Ctx) { |
1053 | 14 | if (has_FlowTraits<MappingTraits<T>>::value) |
1054 | 0 | io.beginFlowMapping(); |
1055 | 14 | else |
1056 | 14 | io.beginMapping(); |
1057 | 14 | if (io.outputting()) { |
1058 | 1 | StringRef Err = MappingTraits<T>::validate(io, Val); |
1059 | 1 | if (!Err.empty()) { |
1060 | 0 | errs() << Err << "\n"; |
1061 | 0 | assert(Err.empty() && "invalid struct trying to be written as yaml"); |
1062 | 0 | } |
1063 | 1 | } |
1064 | 14 | detail::doMapping(io, Val, Ctx); |
1065 | 14 | if (!io.outputting()) { |
1066 | 13 | StringRef Err = MappingTraits<T>::validate(io, Val); |
1067 | 13 | if (!Err.empty()) |
1068 | 0 | io.setError(Err); |
1069 | 13 | } |
1070 | 14 | if (has_FlowTraits<MappingTraits<T>>::value) |
1071 | 0 | io.endFlowMapping(); |
1072 | 14 | else |
1073 | 14 | io.endMapping(); |
1074 | 14 | } |
1075 | | |
1076 | | template <typename T, typename Context> |
1077 | | typename std::enable_if<unvalidatedMappingTraits<T, Context>::value, void>::type |
1078 | 182k | yamlize(IO &io, T &Val, bool, Context &Ctx) { |
1079 | 182k | 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 | 77.0k | io.beginMapping(); |
1085 | 77.0k | detail::doMapping(io, Val, Ctx); |
1086 | 77.0k | io.endMapping(); |
1087 | 77.0k | } |
1088 | 182k | } 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 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::DependentDylib, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::DependentDylib, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::DependentDylib&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 1 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 1 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 1 | } else { | 1084 | 1 | io.beginMapping(); | 1085 | 1 | detail::doMapping(io, Val, Ctx); | 1086 | 1 | io.endMapping(); | 1087 | 1 | } | 1088 | 1 | } |
Unexecuted instantiation: std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::Segment, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::Segment, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::Segment&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::Section, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::Section, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::Section&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 274 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 274 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 274 | } else { | 1084 | 274 | io.beginMapping(); | 1085 | 274 | detail::doMapping(io, Val, Ctx); | 1086 | 274 | io.endMapping(); | 1087 | 274 | } | 1088 | 274 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::Relocation, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::Relocation, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::Relocation&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 410 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 410 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 410 | } else { | 1084 | 410 | io.beginMapping(); | 1085 | 410 | detail::doMapping(io, Val, Ctx); | 1086 | 410 | io.endMapping(); | 1087 | 410 | } | 1088 | 410 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::Symbol, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::Symbol, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::Symbol&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 447 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 447 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 447 | } else { | 1084 | 447 | io.beginMapping(); | 1085 | 447 | detail::doMapping(io, Val, Ctx); | 1086 | 447 | io.endMapping(); | 1087 | 447 | } | 1088 | 447 | } |
Unexecuted instantiation: std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::RebaseLocation, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::RebaseLocation, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::RebaseLocation&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::BindLocation, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::BindLocation, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::BindLocation&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::Export, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::Export, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::Export&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 143 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 143 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 143 | } else { | 1084 | 143 | io.beginMapping(); | 1085 | 143 | detail::doMapping(io, Val, Ctx); | 1086 | 143 | io.endMapping(); | 1087 | 143 | } | 1088 | 143 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::mach_o::normalized::DataInCode, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::mach_o::normalized::DataInCode, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::mach_o::normalized::DataInCode&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 18 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 18 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 18 | } else { | 1084 | 18 | io.beginMapping(); | 1085 | 18 | detail::doMapping(io, Val, Ctx); | 1086 | 18 | io.endMapping(); | 1087 | 18 | } | 1088 | 18 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::File const*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::File const*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::File const*&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 344 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 344 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 344 | } else { | 1084 | 344 | io.beginMapping(); | 1085 | 344 | detail::doMapping(io, Val, Ctx); | 1086 | 344 | io.endMapping(); | 1087 | 344 | } | 1088 | 344 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::DefinedAtom*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::DefinedAtom*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::DefinedAtom*&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 332 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 332 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 332 | } else { | 1084 | 332 | io.beginMapping(); | 1085 | 332 | detail::doMapping(io, Val, Ctx); | 1086 | 332 | io.endMapping(); | 1087 | 332 | } | 1088 | 332 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::Reference const*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::Reference const*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::Reference const*&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 460 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 460 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 460 | } else { | 1084 | 460 | io.beginMapping(); | 1085 | 460 | detail::doMapping(io, Val, Ctx); | 1086 | 460 | io.endMapping(); | 1087 | 460 | } | 1088 | 460 | } |
std::__1::enable_if<unvalidatedMappingTraits<lld::UndefinedAtom*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::UndefinedAtom*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::UndefinedAtom*&, 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<lld::SharedLibraryAtom*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::SharedLibraryAtom*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::SharedLibraryAtom*&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1078 | 17 | yamlize(IO &io, T &Val, bool, Context &Ctx) { | 1079 | 17 | if (has_FlowTraits<MappingTraits<T>>::value) { | 1080 | 0 | io.beginFlowMapping(); | 1081 | 0 | detail::doMapping(io, Val, Ctx); | 1082 | 0 | io.endFlowMapping(); | 1083 | 17 | } else { | 1084 | 17 | io.beginMapping(); | 1085 | 17 | detail::doMapping(io, Val, Ctx); | 1086 | 17 | io.endMapping(); | 1087 | 17 | } | 1088 | 17 | } |
Unexecuted instantiation: std::__1::enable_if<unvalidatedMappingTraits<lld::AbsoluteAtom*, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<lld::AbsoluteAtom*, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::AbsoluteAtom*&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<unvalidatedMappingTraits<(anonymous namespace)::ArchMember, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::ArchMember, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::ArchMember&, bool, llvm::yaml::EmptyContext&) |
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 | 92.8k | yamlize(IO &io, T &Seq, bool, Context &Ctx) { |
1128 | 92.8k | if ( has_FlowTraits< SequenceTraits<T>>::value ) { |
1129 | 2.15k | unsigned incnt = io.beginFlowSequence(); |
1130 | 2.15k | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)1.52k : incnt622 ; |
1131 | 21.5k | for(unsigned i=0; i < count; ++i19.3k ) { |
1132 | 19.3k | void *SaveInfo; |
1133 | 19.3k | if ( io.preflightFlowElement(i, SaveInfo) ) { |
1134 | 19.3k | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); |
1135 | 19.3k | io.postflightFlowElement(SaveInfo); |
1136 | 19.3k | } |
1137 | 19.3k | } |
1138 | 2.15k | io.endFlowSequence(); |
1139 | 2.15k | } |
1140 | 90.7k | else { |
1141 | 90.7k | unsigned incnt = io.beginSequence(); |
1142 | 90.7k | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)81.4k : incnt9.28k ; |
1143 | 234k | for(unsigned i=0; i < count; ++i143k ) { |
1144 | 143k | void *SaveInfo; |
1145 | 143k | if ( io.preflightElement(i, SaveInfo) ) { |
1146 | 143k | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); |
1147 | 143k | io.postflightElement(SaveInfo); |
1148 | 143k | } |
1149 | 143k | } |
1150 | 90.7k | io.endSequence(); |
1151 | 90.7k | } |
1152 | 92.8k | } 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 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 1 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 1 | 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 | else { | 1141 | 1 | unsigned incnt = io.beginSequence(); | 1142 | 1 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 2 | for(unsigned i=0; i < count; ++i1 ) { | 1144 | 1 | void *SaveInfo; | 1145 | 1 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 1 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 1 | io.postflightElement(SaveInfo); | 1148 | 1 | } | 1149 | 1 | } | 1150 | 1 | io.endSequence(); | 1151 | 1 | } | 1152 | 1 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 228 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 228 | 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 | 228 | else { | 1141 | 228 | unsigned incnt = io.beginSequence(); | 1142 | 228 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)75 : incnt153 ; | 1143 | 10.5k | for(unsigned i=0; i < count; ++i10.2k ) { | 1144 | 10.2k | void *SaveInfo; | 1145 | 10.2k | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 10.2k | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 10.2k | io.postflightElement(SaveInfo); | 1148 | 10.2k | } | 1149 | 10.2k | } | 1150 | 228 | io.endSequence(); | 1151 | 228 | } | 1152 | 228 | } |
Unexecuted instantiation: std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Section, std::__1::allocator<lld::mach_o::normalized::Section> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 164 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 164 | 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 | 164 | else { | 1141 | 164 | unsigned incnt = io.beginSequence(); | 1142 | 164 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 438 | for(unsigned i=0; i < count; ++i274 ) { | 1144 | 274 | void *SaveInfo; | 1145 | 274 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 274 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 274 | io.postflightElement(SaveInfo); | 1148 | 274 | } | 1149 | 274 | } | 1150 | 164 | io.endSequence(); | 1151 | 164 | } | 1152 | 164 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<llvm::yaml::Hex8, std::__1::allocator<llvm::yaml::Hex8> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 296 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 296 | if ( has_FlowTraits< SequenceTraits<T>>::value ) { | 1129 | 267 | unsigned incnt = io.beginFlowSequence(); | 1130 | 267 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1131 | 6.40k | for(unsigned i=0; i < count; ++i6.14k ) { | 1132 | 6.14k | void *SaveInfo; | 1133 | 6.14k | if ( io.preflightFlowElement(i, SaveInfo) ) { | 1134 | 6.14k | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1135 | 6.14k | io.postflightFlowElement(SaveInfo); | 1136 | 6.14k | } | 1137 | 6.14k | } | 1138 | 267 | io.endFlowSequence(); | 1139 | 267 | } | 1140 | 29 | else { | 1141 | 29 | unsigned incnt = io.beginSequence(); | 1142 | 29 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)14 : incnt15 ; | 1143 | 170 | for(unsigned i=0; i < count; ++i141 ) { | 1144 | 141 | void *SaveInfo; | 1145 | 141 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 141 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 141 | io.postflightElement(SaveInfo); | 1148 | 141 | } | 1149 | 141 | } | 1150 | 29 | io.endSequence(); | 1151 | 29 | } | 1152 | 296 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Relocation, std::__1::allocator<lld::mach_o::normalized::Relocation> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 87 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 87 | 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 | 87 | else { | 1141 | 87 | unsigned incnt = io.beginSequence(); | 1142 | 87 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 497 | for(unsigned i=0; i < count; ++i410 ) { | 1144 | 410 | void *SaveInfo; | 1145 | 410 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 410 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 410 | io.postflightElement(SaveInfo); | 1148 | 410 | } | 1149 | 410 | } | 1150 | 87 | io.endSequence(); | 1151 | 87 | } | 1152 | 87 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Symbol, std::__1::allocator<lld::mach_o::normalized::Symbol> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 232 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 232 | 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 | 232 | else { | 1141 | 232 | unsigned incnt = io.beginSequence(); | 1142 | 232 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 679 | for(unsigned i=0; i < count; ++i447 ) { | 1144 | 447 | void *SaveInfo; | 1145 | 447 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 447 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 447 | io.postflightElement(SaveInfo); | 1148 | 447 | } | 1149 | 447 | } | 1150 | 232 | io.endSequence(); | 1151 | 232 | } | 1152 | 232 | } |
Unexecuted instantiation: std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&, bool, llvm::yaml::EmptyContext&) std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 106 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 106 | 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 | 106 | else { | 1141 | 106 | unsigned incnt = io.beginSequence(); | 1142 | 106 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 249 | for(unsigned i=0; i < count; ++i143 ) { | 1144 | 143 | void *SaveInfo; | 1145 | 143 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 143 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 143 | io.postflightElement(SaveInfo); | 1148 | 143 | } | 1149 | 143 | } | 1150 | 106 | io.endSequence(); | 1151 | 106 | } | 1152 | 106 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 3 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 3 | 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 | 3 | else { | 1141 | 3 | unsigned incnt = io.beginSequence(); | 1142 | 3 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 21 | for(unsigned i=0; i < count; ++i18 ) { | 1144 | 18 | void *SaveInfo; | 1145 | 18 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 18 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 18 | io.postflightElement(SaveInfo); | 1148 | 18 | } | 1149 | 18 | } | 1150 | 3 | io.endSequence(); | 1151 | 3 | } | 1152 | 3 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::DefinedAtom> >::value, void>::type llvm::yaml::yamlize<lld::File::AtomRange<lld::DefinedAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::File::AtomRange<lld::DefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 60 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 60 | 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 | 60 | else { | 1141 | 60 | unsigned incnt = io.beginSequence(); | 1142 | 60 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt0 ; | 1143 | 332 | for(unsigned i=0; i < count; ++i272 ) { | 1144 | 272 | void *SaveInfo; | 1145 | 272 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 272 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 272 | io.postflightElement(SaveInfo); | 1148 | 272 | } | 1149 | 272 | } | 1150 | 60 | io.endSequence(); | 1151 | 60 | } | 1152 | 60 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 288 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 288 | if ( has_FlowTraits< SequenceTraits<T>>::value ) { | 1129 | 288 | unsigned incnt = io.beginFlowSequence(); | 1130 | 288 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)240 : incnt48 ; | 1131 | 8.65k | for(unsigned i=0; i < count; ++i8.36k ) { | 1132 | 8.36k | void *SaveInfo; | 1133 | 8.36k | if ( io.preflightFlowElement(i, SaveInfo) ) { | 1134 | 8.36k | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1135 | 8.36k | io.postflightFlowElement(SaveInfo); | 1136 | 8.36k | } | 1137 | 8.36k | } | 1138 | 288 | io.endFlowSequence(); | 1139 | 288 | } | 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 | 288 | } |
std::__1::enable_if<has_SequenceTraits<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 125 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 125 | 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 | 125 | else { | 1141 | 125 | unsigned incnt = io.beginSequence(); | 1142 | 125 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)113 : incnt12 ; | 1143 | 585 | for(unsigned i=0; i < count; ++i460 ) { | 1144 | 460 | void *SaveInfo; | 1145 | 460 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 460 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 460 | io.postflightElement(SaveInfo); | 1148 | 460 | } | 1149 | 460 | } | 1150 | 125 | io.endSequence(); | 1151 | 125 | } | 1152 | 125 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::UndefinedAtom> >::value, void>::type llvm::yaml::yamlize<lld::File::AtomRange<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::File::AtomRange<lld::UndefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 23 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 23 | 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 | 23 | else { | 1141 | 23 | unsigned incnt = io.beginSequence(); | 1142 | 23 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt0 ; | 1143 | 64 | for(unsigned i=0; i < count; ++i41 ) { | 1144 | 41 | void *SaveInfo; | 1145 | 41 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 41 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 41 | io.postflightElement(SaveInfo); | 1148 | 41 | } | 1149 | 41 | } | 1150 | 23 | io.endSequence(); | 1151 | 23 | } | 1152 | 23 | } |
std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::SharedLibraryAtom> >::value, void>::type llvm::yaml::yamlize<lld::File::AtomRange<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::File::AtomRange<lld::SharedLibraryAtom>&, 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) : incnt0 ; | 1143 | 18 | for(unsigned i=0; i < count; ++i11 ) { | 1144 | 11 | void *SaveInfo; | 1145 | 11 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 11 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 11 | io.postflightElement(SaveInfo); | 1148 | 11 | } | 1149 | 11 | } | 1150 | 7 | io.endSequence(); | 1151 | 7 | } | 1152 | 7 | } |
Unexecuted instantiation: std::__1::enable_if<has_SequenceTraits<lld::File::AtomRange<lld::AbsoluteAtom> >::value, void>::type llvm::yaml::yamlize<lld::File::AtomRange<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, lld::File::AtomRange<lld::AbsoluteAtom>&, bool, llvm::yaml::EmptyContext&) ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::DefinedAtom> >::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::AtomList<lld::DefinedAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::AtomList<lld::DefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 18 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 18 | 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 | 18 | else { | 1141 | 18 | unsigned incnt = io.beginSequence(); | 1142 | 18 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 78 | for(unsigned i=0; i < count; ++i60 ) { | 1144 | 60 | void *SaveInfo; | 1145 | 60 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 60 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 60 | io.postflightElement(SaveInfo); | 1148 | 60 | } | 1149 | 60 | } | 1150 | 18 | io.endSequence(); | 1151 | 18 | } | 1152 | 18 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::UndefinedAtom> >::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::AtomList<lld::UndefinedAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::AtomList<lld::UndefinedAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 5 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 5 | 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 | 5 | else { | 1141 | 5 | unsigned incnt = io.beginSequence(); | 1142 | 5 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 12 | 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 | 5 | io.endSequence(); | 1151 | 5 | } | 1152 | 5 | } |
ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::SharedLibraryAtom> >::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::AtomList<lld::SharedLibraryAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::AtomList<lld::SharedLibraryAtom>&, bool, llvm::yaml::EmptyContext&) Line | Count | Source | 1127 | 6 | yamlize(IO &io, T &Seq, bool, Context &Ctx) { | 1128 | 6 | 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 | 6 | else { | 1141 | 6 | unsigned incnt = io.beginSequence(); | 1142 | 6 | unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq)0 : incnt; | 1143 | 12 | for(unsigned i=0; i < count; ++i6 ) { | 1144 | 6 | void *SaveInfo; | 1145 | 6 | if ( io.preflightElement(i, SaveInfo) ) { | 1146 | 6 | yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx); | 1147 | 6 | io.postflightElement(SaveInfo); | 1148 | 6 | } | 1149 | 6 | } | 1150 | 6 | io.endSequence(); | 1151 | 6 | } | 1152 | 6 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<(anonymous namespace)::AtomList<lld::AbsoluteAtom> >::value, void>::type llvm::yaml::yamlize<(anonymous namespace)::AtomList<lld::AbsoluteAtom>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, (anonymous namespace)::AtomList<lld::AbsoluteAtom>&, bool, llvm::yaml::EmptyContext&) Unexecuted instantiation: ReaderWriterYAML.cpp:std::__1::enable_if<has_SequenceTraits<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> > >::value, void>::type llvm::yaml::yamlize<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&, bool, llvm::yaml::EmptyContext&) |
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 | 271 | : io(i_o), BufPtr(nullptr), Result(Obj) { |
1311 | 271 | if ( io.outputting() ) { |
1312 | 0 | BufPtr = new (&Buffer) TNorm(io, Obj); |
1313 | 0 | } |
1314 | 271 | else { |
1315 | 271 | BufPtr = new (&Buffer) TNorm(io); |
1316 | 271 | } |
1317 | 271 | } |
1318 | | |
1319 | 271 | ~MappingNormalization() { |
1320 | 271 | if ( ! io.outputting() ) { |
1321 | 271 | Result = BufPtr->denormalize(io); |
1322 | 271 | } |
1323 | 271 | BufPtr->~TNorm(); |
1324 | 271 | } |
1325 | | |
1326 | 271 | 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 | 936 | : io(i_o), Result(Obj) { |
1343 | 936 | if ( io.outputting() ) { |
1344 | 826 | BufPtr = new (&Buffer) TNorm(io, Obj); |
1345 | 826 | } |
1346 | 110 | else if (allocator) { |
1347 | 91 | BufPtr = allocator->Allocate<TNorm>(); |
1348 | 91 | new (BufPtr) TNorm(io); |
1349 | 91 | } else { |
1350 | 19 | BufPtr = new TNorm(io); |
1351 | 19 | } |
1352 | 936 | } llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormalizedFile, lld::File const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::File const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Line | Count | Source | 1342 | 79 | : io(i_o), Result(Obj) { | 1343 | 79 | if ( io.outputting() ) { | 1344 | 60 | BufPtr = new (&Buffer) TNorm(io, Obj); | 1345 | 60 | } | 1346 | 19 | else if (allocator) { | 1347 | 0 | BufPtr = allocator->Allocate<TNorm>(); | 1348 | 0 | new (BufPtr) TNorm(io); | 1349 | 19 | } else { | 1350 | 19 | BufPtr = new TNorm(io); | 1351 | 19 | } | 1352 | 79 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::DefinedAtom const*>::NormalizedAtom, lld::DefinedAtom const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::DefinedAtom const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Line | Count | Source | 1342 | 332 | : io(i_o), Result(Obj) { | 1343 | 332 | if ( io.outputting() ) { | 1344 | 272 | BufPtr = new (&Buffer) TNorm(io, Obj); | 1345 | 272 | } | 1346 | 60 | else if (allocator) { | 1347 | 60 | BufPtr = allocator->Allocate<TNorm>(); | 1348 | 60 | new (BufPtr) TNorm(io); | 1349 | 60 | } else { | 1350 | 0 | BufPtr = new TNorm(io); | 1351 | 0 | } | 1352 | 332 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::Reference const*>::NormalizedReference, lld::Reference const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::Reference const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Line | Count | Source | 1342 | 460 | : io(i_o), Result(Obj) { | 1343 | 460 | if ( io.outputting() ) { | 1344 | 442 | BufPtr = new (&Buffer) TNorm(io, Obj); | 1345 | 442 | } | 1346 | 18 | else if (allocator) { | 1347 | 18 | BufPtr = allocator->Allocate<TNorm>(); | 1348 | 18 | new (BufPtr) TNorm(io); | 1349 | 18 | } else { | 1350 | 0 | BufPtr = new TNorm(io); | 1351 | 0 | } | 1352 | 460 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::UndefinedAtom const*>::NormalizedAtom, lld::UndefinedAtom const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::UndefinedAtom const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Line | Count | Source | 1342 | 48 | : io(i_o), Result(Obj) { | 1343 | 48 | if ( io.outputting() ) { | 1344 | 41 | BufPtr = new (&Buffer) TNorm(io, Obj); | 1345 | 41 | } | 1346 | 7 | else if (allocator) { | 1347 | 7 | BufPtr = allocator->Allocate<TNorm>(); | 1348 | 7 | new (BufPtr) TNorm(io); | 1349 | 7 | } else { | 1350 | 0 | BufPtr = new TNorm(io); | 1351 | 0 | } | 1352 | 48 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::SharedLibraryAtom const*>::NormalizedAtom, lld::SharedLibraryAtom const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::SharedLibraryAtom const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Line | Count | Source | 1342 | 17 | : io(i_o), Result(Obj) { | 1343 | 17 | if ( io.outputting() ) { | 1344 | 11 | BufPtr = new (&Buffer) TNorm(io, Obj); | 1345 | 11 | } | 1346 | 6 | else if (allocator) { | 1347 | 6 | BufPtr = allocator->Allocate<TNorm>(); | 1348 | 6 | new (BufPtr) TNorm(io); | 1349 | 6 | } else { | 1350 | 0 | BufPtr = new TNorm(io); | 1351 | 0 | } | 1352 | 17 | } |
Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::AbsoluteAtom const*>::NormalizedAtom, lld::AbsoluteAtom const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::AbsoluteAtom const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormArchiveFile, lld::File const*>::MappingNormalizationHeap(llvm::yaml::IO&, lld::File const*&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul>*) |
1353 | | |
1354 | 936 | ~MappingNormalizationHeap() { |
1355 | 936 | if ( io.outputting() ) { |
1356 | 826 | BufPtr->~TNorm(); |
1357 | 826 | } |
1358 | 110 | else { |
1359 | 110 | Result = BufPtr->denormalize(io); |
1360 | 110 | } |
1361 | 936 | } llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::Reference const*>::NormalizedReference, lld::Reference const*>::~MappingNormalizationHeap() Line | Count | Source | 1354 | 460 | ~MappingNormalizationHeap() { | 1355 | 460 | if ( io.outputting() ) { | 1356 | 442 | BufPtr->~TNorm(); | 1357 | 442 | } | 1358 | 18 | else { | 1359 | 18 | Result = BufPtr->denormalize(io); | 1360 | 18 | } | 1361 | 460 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::DefinedAtom const*>::NormalizedAtom, lld::DefinedAtom const*>::~MappingNormalizationHeap() Line | Count | Source | 1354 | 332 | ~MappingNormalizationHeap() { | 1355 | 332 | if ( io.outputting() ) { | 1356 | 272 | BufPtr->~TNorm(); | 1357 | 272 | } | 1358 | 60 | else { | 1359 | 60 | Result = BufPtr->denormalize(io); | 1360 | 60 | } | 1361 | 332 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::UndefinedAtom const*>::NormalizedAtom, lld::UndefinedAtom const*>::~MappingNormalizationHeap() Line | Count | Source | 1354 | 48 | ~MappingNormalizationHeap() { | 1355 | 48 | if ( io.outputting() ) { | 1356 | 41 | BufPtr->~TNorm(); | 1357 | 41 | } | 1358 | 7 | else { | 1359 | 7 | Result = BufPtr->denormalize(io); | 1360 | 7 | } | 1361 | 48 | } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::SharedLibraryAtom const*>::NormalizedAtom, lld::SharedLibraryAtom const*>::~MappingNormalizationHeap() Line | Count | Source | 1354 | 17 | ~MappingNormalizationHeap() { | 1355 | 17 | if ( io.outputting() ) { | 1356 | 11 | BufPtr->~TNorm(); | 1357 | 11 | } | 1358 | 6 | else { | 1359 | 6 | Result = BufPtr->denormalize(io); | 1360 | 6 | } | 1361 | 17 | } |
Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::AbsoluteAtom const*>::NormalizedAtom, lld::AbsoluteAtom const*>::~MappingNormalizationHeap() llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormalizedFile, lld::File const*>::~MappingNormalizationHeap() Line | Count | Source | 1354 | 79 | ~MappingNormalizationHeap() { | 1355 | 79 | if ( io.outputting() ) { | 1356 | 60 | BufPtr->~TNorm(); | 1357 | 60 | } | 1358 | 19 | else { | 1359 | 19 | Result = BufPtr->denormalize(io); | 1360 | 19 | } | 1361 | 79 | } |
Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormArchiveFile, lld::File const*>::~MappingNormalizationHeap() |
1362 | | |
1363 | 9.29k | TNorm* operator->() { return BufPtr; } llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormalizedFile, lld::File const*>::operator->() Line | Count | Source | 1363 | 474 | TNorm* operator->() { return BufPtr; } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::DefinedAtom const*>::NormalizedAtom, lld::DefinedAtom const*>::operator->() Line | Count | Source | 1363 | 6.33k | TNorm* operator->() { return BufPtr; } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::Reference const*>::NormalizedReference, lld::Reference const*>::operator->() Line | Count | Source | 1363 | 2.30k | TNorm* operator->() { return BufPtr; } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::UndefinedAtom const*>::NormalizedAtom, lld::UndefinedAtom const*>::operator->() Line | Count | Source | 1363 | 96 | TNorm* operator->() { return BufPtr; } |
llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::SharedLibraryAtom const*>::NormalizedAtom, lld::SharedLibraryAtom const*>::operator->() Line | Count | Source | 1363 | 85 | TNorm* operator->() { return BufPtr; } |
Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::AbsoluteAtom const*>::NormalizedAtom, lld::AbsoluteAtom const*>::operator->() Unexecuted instantiation: llvm::yaml::MappingNormalizationHeap<llvm::yaml::MappingTraits<lld::File const*>::NormArchiveFile, lld::File const*>::operator->() |
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 | | ~Input() override; |
1400 | | |
1401 | | // Check if there was an syntax or semantic error during parsing. |
1402 | | std::error_code error(); |
1403 | | |
1404 | | private: |
1405 | | bool outputting() override; |
1406 | | bool mapTag(StringRef, bool) override; |
1407 | | void beginMapping() override; |
1408 | | void endMapping() override; |
1409 | | bool preflightKey(const char *, bool, bool, bool &, void *&) override; |
1410 | | void postflightKey(void *) override; |
1411 | | std::vector<StringRef> keys() override; |
1412 | | void beginFlowMapping() override; |
1413 | | void endFlowMapping() override; |
1414 | | unsigned beginSequence() override; |
1415 | | void endSequence() override; |
1416 | | bool preflightElement(unsigned index, void *&) override; |
1417 | | void postflightElement(void *) override; |
1418 | | unsigned beginFlowSequence() override; |
1419 | | bool preflightFlowElement(unsigned , void *&) override; |
1420 | | void postflightFlowElement(void *) override; |
1421 | | void endFlowSequence() override; |
1422 | | void beginEnumScalar() override; |
1423 | | bool matchEnumScalar(const char*, bool) override; |
1424 | | bool matchEnumFallback() override; |
1425 | | void endEnumScalar() override; |
1426 | | bool beginBitSetScalar(bool &) override; |
1427 | | bool bitSetMatch(const char *, bool ) override; |
1428 | | void endBitSetScalar() override; |
1429 | | void scalarString(StringRef &, QuotingType) override; |
1430 | | void blockScalarString(StringRef &) override; |
1431 | | void scalarTag(std::string &) override; |
1432 | | NodeKind getNodeKind() override; |
1433 | | void setError(const Twine &message) override; |
1434 | | bool canElideEmptySequence() override; |
1435 | | |
1436 | | class HNode { |
1437 | | virtual void anchor(); |
1438 | | |
1439 | | public: |
1440 | 301k | HNode(Node *n) : _node(n) { } |
1441 | 299k | virtual ~HNode() = default; |
1442 | | |
1443 | 0 | static bool classof(const HNode *) { return true; } |
1444 | | |
1445 | | Node *_node; |
1446 | | }; |
1447 | | |
1448 | | class EmptyHNode : public HNode { |
1449 | | void anchor() override; |
1450 | | |
1451 | | public: |
1452 | 2.65k | EmptyHNode(Node *n) : HNode(n) { } |
1453 | | |
1454 | 2.60k | static bool classof(const HNode *n) { return NullNode::classof(n->_node); } |
1455 | | |
1456 | 0 | static bool classof(const EmptyHNode *) { return true; } |
1457 | | }; |
1458 | | |
1459 | | class ScalarHNode : public HNode { |
1460 | | void anchor() override; |
1461 | | |
1462 | | public: |
1463 | 220k | ScalarHNode(Node *n, StringRef s) : HNode(n), _value(s) { } |
1464 | | |
1465 | 640k | StringRef value() const { return _value; } |
1466 | | |
1467 | 648k | static bool classof(const HNode *n) { |
1468 | 648k | return ScalarNode::classof(n->_node) || |
1469 | 648k | BlockScalarNode::classof(n->_node)12.6k ; |
1470 | 648k | } |
1471 | | |
1472 | 0 | static bool classof(const ScalarHNode *) { return true; } |
1473 | | |
1474 | | protected: |
1475 | | StringRef _value; |
1476 | | }; |
1477 | | |
1478 | | class MapHNode : public HNode { |
1479 | | void anchor() override; |
1480 | | |
1481 | | public: |
1482 | 61.7k | MapHNode(Node *n) : HNode(n) { } |
1483 | | |
1484 | 645k | static bool classof(const HNode *n) { |
1485 | 645k | return MappingNode::classof(n->_node); |
1486 | 645k | } |
1487 | | |
1488 | 0 | static bool classof(const MapHNode *) { return true; } |
1489 | | |
1490 | | using NameToNode = StringMap<std::unique_ptr<HNode>>; |
1491 | | |
1492 | | NameToNode Mapping; |
1493 | | SmallVector<std::string, 6> ValidKeys; |
1494 | | }; |
1495 | | |
1496 | | class SequenceHNode : public HNode { |
1497 | | void anchor() override; |
1498 | | |
1499 | | public: |
1500 | 16.0k | SequenceHNode(Node *n) : HNode(n) { } |
1501 | | |
1502 | 123k | static bool classof(const HNode *n) { |
1503 | 123k | return SequenceNode::classof(n->_node); |
1504 | 123k | } |
1505 | | |
1506 | 0 | static bool classof(const SequenceHNode *) { return true; } |
1507 | | |
1508 | | std::vector<std::unique_ptr<HNode>> Entries; |
1509 | | }; |
1510 | | |
1511 | | std::unique_ptr<Input::HNode> createHNodes(Node *node); |
1512 | | void setError(HNode *hnode, const Twine &message); |
1513 | | void setError(Node *node, const Twine &message); |
1514 | | |
1515 | | public: |
1516 | | // These are only used by operator>>. They could be private |
1517 | | // if those templated things could be made friends. |
1518 | | bool setCurrentDocument(); |
1519 | | bool nextDocument(); |
1520 | | |
1521 | | /// Returns the current node that's being parsed by the YAML Parser. |
1522 | | const Node *getCurrentNode() const; |
1523 | | |
1524 | | private: |
1525 | | SourceMgr SrcMgr; // must be before Strm |
1526 | | std::unique_ptr<llvm::yaml::Stream> Strm; |
1527 | | std::unique_ptr<HNode> TopNode; |
1528 | | std::error_code EC; |
1529 | | BumpPtrAllocator StringAllocator; |
1530 | | document_iterator DocIterator; |
1531 | | std::vector<bool> BitValuesUsed; |
1532 | | HNode *CurrentNode = nullptr; |
1533 | | bool ScalarMatchFound; |
1534 | | }; |
1535 | | |
1536 | | /// |
1537 | | /// The Output class is used to generate a yaml document from in-memory structs |
1538 | | /// and vectors. |
1539 | | /// |
1540 | | class Output : public IO { |
1541 | | public: |
1542 | | Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70); |
1543 | | ~Output() override; |
1544 | | |
1545 | | /// Set whether or not to output optional values which are equal |
1546 | | /// to the default value. By default, when outputting if you attempt |
1547 | | /// to write a value that is equal to the default, the value gets ignored. |
1548 | | /// Sometimes, it is useful to be able to see these in the resulting YAML |
1549 | | /// anyway. |
1550 | 11.7k | void setWriteDefaultValues(bool Write) { WriteDefaultValues = Write; } |
1551 | | |
1552 | | bool outputting() override; |
1553 | | bool mapTag(StringRef, bool) override; |
1554 | | void beginMapping() override; |
1555 | | void endMapping() override; |
1556 | | bool preflightKey(const char *key, bool, bool, bool &, void *&) override; |
1557 | | void postflightKey(void *) override; |
1558 | | std::vector<StringRef> keys() override; |
1559 | | void beginFlowMapping() override; |
1560 | | void endFlowMapping() override; |
1561 | | unsigned beginSequence() override; |
1562 | | void endSequence() override; |
1563 | | bool preflightElement(unsigned, void *&) override; |
1564 | | void postflightElement(void *) override; |
1565 | | unsigned beginFlowSequence() override; |
1566 | | bool preflightFlowElement(unsigned, void *&) override; |
1567 | | void postflightFlowElement(void *) override; |
1568 | | void endFlowSequence() override; |
1569 | | void beginEnumScalar() override; |
1570 | | bool matchEnumScalar(const char*, bool) override; |
1571 | | bool matchEnumFallback() override; |
1572 | | void endEnumScalar() override; |
1573 | | bool beginBitSetScalar(bool &) override; |
1574 | | bool bitSetMatch(const char *, bool ) override; |
1575 | | void endBitSetScalar() override; |
1576 | | void scalarString(StringRef &, QuotingType) override; |
1577 | | void blockScalarString(StringRef &) override; |
1578 | | void scalarTag(std::string &) override; |
1579 | | NodeKind getNodeKind() override; |
1580 | | void setError(const Twine &message) override; |
1581 | | bool canElideEmptySequence() override; |
1582 | | |
1583 | | // These are only used by operator<<. They could be private |
1584 | | // if that templated operator could be made a friend. |
1585 | | void beginDocuments(); |
1586 | | bool preflightDocument(unsigned); |
1587 | | void postflightDocument(); |
1588 | | void endDocuments(); |
1589 | | |
1590 | | private: |
1591 | | void output(StringRef s); |
1592 | | void outputUpToEndOfLine(StringRef s); |
1593 | | void newLineCheck(); |
1594 | | void outputNewLine(); |
1595 | | void paddedKey(StringRef key); |
1596 | | void flowKey(StringRef Key); |
1597 | | |
1598 | | enum InState { |
1599 | | inSeqFirstElement, |
1600 | | inSeqOtherElement, |
1601 | | inFlowSeqFirstElement, |
1602 | | inFlowSeqOtherElement, |
1603 | | inMapFirstKey, |
1604 | | inMapOtherKey, |
1605 | | inFlowMapFirstKey, |
1606 | | inFlowMapOtherKey |
1607 | | }; |
1608 | | |
1609 | | static bool inSeqAnyElement(InState State); |
1610 | | static bool inFlowSeqAnyElement(InState State); |
1611 | | static bool inMapAnyKey(InState State); |
1612 | | static bool inFlowMapAnyKey(InState State); |
1613 | | |
1614 | | raw_ostream &Out; |
1615 | | int WrapColumn; |
1616 | | SmallVector<InState, 8> StateStack; |
1617 | | int Column = 0; |
1618 | | int ColumnAtFlowStart = 0; |
1619 | | int ColumnAtMapFlowStart = 0; |
1620 | | bool NeedBitValueComma = false; |
1621 | | bool NeedFlowSequenceComma = false; |
1622 | | bool EnumerationMatchFound = false; |
1623 | | bool WriteDefaultValues = false; |
1624 | | StringRef Padding; |
1625 | | StringRef PaddingBeforeContainer; |
1626 | | }; |
1627 | | |
1628 | | /// YAML I/O does conversion based on types. But often native data types |
1629 | | /// are just a typedef of built in intergral types (e.g. int). But the C++ |
1630 | | /// type matching system sees through the typedef and all the typedefed types |
1631 | | /// look like a built in type. This will cause the generic YAML I/O conversion |
1632 | | /// to be used. To provide better control over the YAML conversion, you can |
1633 | | /// use this macro instead of typedef. It will create a class with one field |
1634 | | /// and automatic conversion operators to and from the base type. |
1635 | | /// Based on BOOST_STRONG_TYPEDEF |
1636 | | #define LLVM_YAML_STRONG_TYPEDEF(_base, _type) \ |
1637 | | struct _type { \ |
1638 | | _type() = default; \ |
1639 | 32.9k | _type(const _base v) : value(v) {} \ llvm::yaml::Hex8::Hex8(unsigned char) Line | Count | Source | 1639 | 949 | _type(const _base v) : value(v) {} \ |
llvm::yaml::Hex16::Hex16(unsigned short) Line | Count | Source | 1639 | 286 | _type(const _base v) : value(v) {} \ |
llvm::yaml::Hex32::Hex32(unsigned int) Line | Count | Source | 1639 | 4.39k | _type(const _base v) : value(v) {} \ |
llvm::yaml::Hex64::Hex64(unsigned long long) Line | Count | Source | 1639 | 12.3k | _type(const _base v) : value(v) {} \ |
lld::mach_o::normalized::SectionAttr::SectionAttr(unsigned int) Line | Count | Source | 1639 | 1.44k | _type(const _base v) : value(v) {} \ |
lld::mach_o::normalized::SectionAlignment::SectionAlignment(unsigned short) Line | Count | Source | 1639 | 1.01k | _type(const _base v) : value(v) {} \ |
lld::mach_o::normalized::SymbolScope::SymbolScope(unsigned char) Line | Count | Source | 1639 | 2.29k | _type(const _base v) : value(v) {} \ |
lld::mach_o::normalized::SymbolDesc::SymbolDesc(unsigned short) Line | Count | Source | 1639 | 1.61k | _type(const _base v) : value(v) {} \ |
Unexecuted instantiation: lld::mach_o::normalized::VMProtect::VMProtect(unsigned int) lld::mach_o::normalized::PackedVersion::PackedVersion(unsigned int) Line | Count | Source | 1639 | 3.11k | _type(const _base v) : value(v) {} \ |
Unexecuted instantiation: lld::mach_o::normalized::ExportFlags::ExportFlags(unsigned int) lld::mach_o::normalized::FileFlags::FileFlags(unsigned int) Line | Count | Source | 1639 | 1.21k | _type(const _base v) : value(v) {} \ |
ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::ImplicitHex8(unsigned char) Line | Count | Source | 1639 | 4.26k | _type(const _base v) : value(v) {} \ |
ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::ShlibCanBeNull(bool) Line | Count | Source | 1639 | 34 | _type(const _base v) : value(v) {} \ |
|
1640 | | _type(const _type &v) = default; \ |
1641 | | _type &operator=(const _type &rhs) = default; \ |
1642 | 37.3k | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ llvm::yaml::Hex8::operator=(unsigned char const&) Line | Count | Source | 1642 | 6.75k | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
llvm::yaml::Hex16::operator=(unsigned short const&) Line | Count | Source | 1642 | 113 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
llvm::yaml::Hex32::operator=(unsigned int const&) Line | Count | Source | 1642 | 9.47k | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
llvm::yaml::Hex64::operator=(unsigned long long const&) Line | Count | Source | 1642 | 11.5k | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::SectionAttr::operator=(unsigned int const&) Line | Count | Source | 1642 | 940 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::SectionAlignment::operator=(unsigned short const&) Line | Count | Source | 1642 | 587 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::SymbolScope::operator=(unsigned char const&) Line | Count | Source | 1642 | 612 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::SymbolDesc::operator=(unsigned short const&) Line | Count | Source | 1642 | 895 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::VMProtect::operator=(unsigned int const&) Line | Count | Source | 1642 | 938 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::PackedVersion::operator=(unsigned int const&) Line | Count | Source | 1642 | 965 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::ExportFlags::operator=(unsigned int const&) Line | Count | Source | 1642 | 201 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
lld::mach_o::normalized::FileFlags::operator=(unsigned int const&) Line | Count | Source | 1642 | 219 | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::operator=(unsigned char const&) Line | Count | Source | 1642 | 4.10k | _type &operator=(const _base &rhs) { value = rhs; return *this; } \ |
Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::operator=(bool const&) |
1643 | 67.4k | operator const _base & () const { return value; } \ llvm::yaml::Hex8::operator unsigned char const&() const Line | Count | Source | 1643 | 7.41k | operator const _base & () const { return value; } \ |
llvm::yaml::Hex16::operator unsigned short const&() const Line | Count | Source | 1643 | 295 | operator const _base & () const { return value; } \ |
llvm::yaml::Hex32::operator unsigned int const&() const Line | Count | Source | 1643 | 11.0k | operator const _base & () const { return value; } \ |
llvm::yaml::Hex64::operator unsigned long long const&() const Line | Count | Source | 1643 | 33.8k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::SectionAttr::operator unsigned int const&() const Line | Count | Source | 1643 | 1.71k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::SectionAlignment::operator unsigned short const&() const Line | Count | Source | 1643 | 1.68k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::SymbolScope::operator unsigned char const&() const Line | Count | Source | 1643 | 1.50k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::SymbolDesc::operator unsigned short const&() const Line | Count | Source | 1643 | 1.19k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::VMProtect::operator unsigned int const&() const Line | Count | Source | 1643 | 1.42k | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::PackedVersion::operator unsigned int const&() const Line | Count | Source | 1643 | 935 | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::ExportFlags::operator unsigned int const&() const Line | Count | Source | 1643 | 935 | operator const _base & () const { return value; } \ |
lld::mach_o::normalized::FileFlags::operator unsigned int const&() const Line | Count | Source | 1643 | 1.13k | operator const _base & () const { return value; } \ |
ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::operator unsigned char const&() const Line | Count | Source | 1643 | 4.26k | operator const _base & () const { return value; } \ |
ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::operator bool const&() const Line | Count | Source | 1643 | 4 | operator const _base & () const { return value; } \ |
|
1644 | 864 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ llvm::yaml::Hex16::operator==(llvm::yaml::Hex16 const&) const Line | Count | Source | 1644 | 7 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
llvm::yaml::Hex32::operator==(llvm::yaml::Hex32 const&) const Line | Count | Source | 1644 | 91 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
llvm::yaml::Hex64::operator==(llvm::yaml::Hex64 const&) const Line | Count | Source | 1644 | 703 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
Unexecuted instantiation: lld::mach_o::normalized::SectionAlignment::operator==(lld::mach_o::normalized::SectionAlignment const&) const lld::mach_o::normalized::SymbolScope::operator==(lld::mach_o::normalized::SymbolScope const&) const Line | Count | Source | 1644 | 48 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
Unexecuted instantiation: lld::mach_o::normalized::SymbolDesc::operator==(lld::mach_o::normalized::SymbolDesc const&) const Unexecuted instantiation: lld::mach_o::normalized::VMProtect::operator==(lld::mach_o::normalized::VMProtect const&) const lld::mach_o::normalized::PackedVersion::operator==(lld::mach_o::normalized::PackedVersion const&) const Line | Count | Source | 1644 | 4 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
Unexecuted instantiation: lld::mach_o::normalized::ExportFlags::operator==(lld::mach_o::normalized::ExportFlags const&) const ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::operator==((anonymous namespace)::ShlibCanBeNull const&) const Line | Count | Source | 1644 | 11 | bool operator==(const _type &rhs) const { return value == rhs.value; } \ |
Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::operator==((anonymous namespace)::ImplicitHex8 const&) const |
1645 | 430 | bool operator==(const _base &rhs) const { return value == rhs; } \ Unexecuted instantiation: llvm::yaml::Hex8::operator==(unsigned char const&) const Unexecuted instantiation: llvm::yaml::Hex16::operator==(unsigned short const&) const Unexecuted instantiation: llvm::yaml::Hex64::operator==(unsigned long long const&) const llvm::yaml::Hex32::operator==(unsigned int const&) const Line | Count | Source | 1645 | 430 | bool operator==(const _base &rhs) const { return value == rhs; } \ |
Unexecuted instantiation: lld::mach_o::normalized::SectionAttr::operator==(unsigned int const&) const Unexecuted instantiation: lld::mach_o::normalized::SectionAlignment::operator==(unsigned short const&) const Unexecuted instantiation: lld::mach_o::normalized::SymbolScope::operator==(unsigned char const&) const Unexecuted instantiation: lld::mach_o::normalized::SymbolDesc::operator==(unsigned short const&) const Unexecuted instantiation: lld::mach_o::normalized::VMProtect::operator==(unsigned int const&) const Unexecuted instantiation: lld::mach_o::normalized::PackedVersion::operator==(unsigned int const&) const Unexecuted instantiation: lld::mach_o::normalized::ExportFlags::operator==(unsigned int const&) const Unexecuted instantiation: lld::mach_o::normalized::FileFlags::operator==(unsigned int const&) const Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::operator==(unsigned char const&) const Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::operator==(bool const&) const |
1646 | 0 | bool operator<(const _type &rhs) const { return value < rhs.value; } \ Unexecuted instantiation: llvm::yaml::Hex8::operator<(llvm::yaml::Hex8 const&) const Unexecuted instantiation: llvm::yaml::Hex16::operator<(llvm::yaml::Hex16 const&) const Unexecuted instantiation: llvm::yaml::Hex32::operator<(llvm::yaml::Hex32 const&) const Unexecuted instantiation: llvm::yaml::Hex64::operator<(llvm::yaml::Hex64 const&) const Unexecuted instantiation: lld::mach_o::normalized::SectionAttr::operator<(lld::mach_o::normalized::SectionAttr const&) const Unexecuted instantiation: lld::mach_o::normalized::SectionAlignment::operator<(lld::mach_o::normalized::SectionAlignment const&) const Unexecuted instantiation: lld::mach_o::normalized::SymbolScope::operator<(lld::mach_o::normalized::SymbolScope const&) const Unexecuted instantiation: lld::mach_o::normalized::SymbolDesc::operator<(lld::mach_o::normalized::SymbolDesc const&) const Unexecuted instantiation: lld::mach_o::normalized::VMProtect::operator<(lld::mach_o::normalized::VMProtect const&) const Unexecuted instantiation: lld::mach_o::normalized::PackedVersion::operator<(lld::mach_o::normalized::PackedVersion const&) const Unexecuted instantiation: lld::mach_o::normalized::ExportFlags::operator<(lld::mach_o::normalized::ExportFlags const&) const Unexecuted instantiation: lld::mach_o::normalized::FileFlags::operator<(lld::mach_o::normalized::FileFlags const&) const Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ImplicitHex8::operator<((anonymous namespace)::ImplicitHex8 const&) const Unexecuted instantiation: ReaderWriterYAML.cpp:(anonymous namespace)::ShlibCanBeNull::operator<((anonymous namespace)::ShlibCanBeNull const&) const |
1647 | | _base value; \ |
1648 | | using BaseType = _base; \ |
1649 | | }; |
1650 | | |
1651 | | /// |
1652 | | /// Use these types instead of uintXX_t in any mapping to have |
1653 | | /// its yaml output formatted as hexadecimal. |
1654 | | /// |
1655 | | LLVM_YAML_STRONG_TYPEDEF(uint8_t, Hex8) |
1656 | | LLVM_YAML_STRONG_TYPEDEF(uint16_t, Hex16) |
1657 | | LLVM_YAML_STRONG_TYPEDEF(uint32_t, Hex32) |
1658 | | LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64) |
1659 | | |
1660 | | template<> |
1661 | | struct ScalarTraits<Hex8> { |
1662 | | static void output(const Hex8 &, void *, raw_ostream &); |
1663 | | static StringRef input(StringRef, void *, Hex8 &); |
1664 | 6.74k | static QuotingType mustQuote(StringRef) { return QuotingType::None; } |
1665 | | }; |
1666 | | |
1667 | | template<> |
1668 | | struct ScalarTraits<Hex16> { |
1669 | | static void output(const Hex16 &, void *, raw_ostream &); |
1670 | | static StringRef input(StringRef, void *, Hex16 &); |
1671 | 84 | static QuotingType mustQuote(StringRef) { return QuotingType::None; } |
1672 | | }; |
1673 | | |
1674 | | template<> |
1675 | | struct ScalarTraits<Hex32> { |
1676 | | static void output(const Hex32 &, void *, raw_ostream &); |
1677 | | static StringRef input(StringRef, void *, Hex32 &); |
1678 | 6.22k | static QuotingType mustQuote(StringRef) { return QuotingType::None; } |
1679 | | }; |
1680 | | |
1681 | | template<> |
1682 | | struct ScalarTraits<Hex64> { |
1683 | | static void output(const Hex64 &, void *, raw_ostream &); |
1684 | | static StringRef input(StringRef, void *, Hex64 &); |
1685 | 7.25k | static QuotingType mustQuote(StringRef) { return QuotingType::None; } |
1686 | | }; |
1687 | | |
1688 | | // Define non-member operator>> so that Input can stream in a document list. |
1689 | | template <typename T> |
1690 | | inline |
1691 | | typename std::enable_if<has_DocumentListTraits<T>::value, Input &>::type |
1692 | 284 | operator>>(Input &yin, T &docList) { |
1693 | 284 | int i = 0; |
1694 | 284 | EmptyContext Ctx; |
1695 | 562 | while ( yin.setCurrentDocument() ) { |
1696 | 284 | yamlize(yin, DocumentListTraits<T>::element(yin, docList, i), true, Ctx); |
1697 | 284 | if ( yin.error() ) |
1698 | 6 | return yin; |
1699 | 278 | yin.nextDocument(); |
1700 | 278 | ++i; |
1701 | 278 | } |
1702 | 284 | return yin278 ; |
1703 | 284 | } |
1704 | | |
1705 | | // Define non-member operator>> so that Input can stream in a map as a document. |
1706 | | template <typename T> |
1707 | | inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value, |
1708 | | Input &>::type |
1709 | 91 | operator>>(Input &yin, T &docMap) { |
1710 | 91 | EmptyContext Ctx; |
1711 | 91 | yin.setCurrentDocument(); |
1712 | 91 | yamlize(yin, docMap, true, Ctx); |
1713 | 91 | return yin; |
1714 | 91 | } cc1gen_reproducer_main.cpp:std::__1::enable_if<has_MappingTraits<(anonymous namespace)::ClangInvocationInfo, llvm::yaml::EmptyContext>::value, llvm::yaml::Input&>::type llvm::yaml::operator>><(anonymous namespace)::ClangInvocationInfo>(llvm::yaml::Input&, (anonymous namespace)::ClangInvocationInfo&) Line | Count | Source | 1709 | 3 | operator>>(Input &yin, T &docMap) { | 1710 | 3 | EmptyContext Ctx; | 1711 | 3 | yin.setCurrentDocument(); | 1712 | 3 | yamlize(yin, docMap, true, Ctx); | 1713 | 3 | return yin; | 1714 | 3 | } |
std::__1::enable_if<has_MappingTraits<llvm::ModuleSummaryIndex, llvm::yaml::EmptyContext>::value, llvm::yaml::Input&>::type llvm::yaml::operator>><llvm::ModuleSummaryIndex>(llvm::yaml::Input&, llvm::ModuleSummaryIndex&) Line | Count | Source | 1709 | 47 | operator>>(Input &yin, T &docMap) { | 1710 | 47 | EmptyContext Ctx; | 1711 | 47 | yin.setCurrentDocument(); | 1712 | 47 | yamlize(yin, docMap, true, Ctx); | 1713 | 47 | return yin; | 1714 | 47 | } |
std::__1::enable_if<has_MappingTraits<llvm::AMDGPU::HSAMD::Metadata, llvm::yaml::EmptyContext>::value, llvm::yaml::Input&>::type llvm::yaml::operator>><llvm::AMDGPU::HSAMD::Metadata>(llvm::yaml::Input&, llvm::AMDGPU::HSAMD::Metadata&) Line | Count | Source | 1709 | 28 | operator>>(Input &yin, T &docMap) { | 1710 | 28 | EmptyContext Ctx; | 1711 | 28 | yin.setCurrentDocument(); | 1712 | 28 | yamlize(yin, docMap, true, Ctx); | 1713 | 28 | return yin; | 1714 | 28 | } |
std::__1::enable_if<has_MappingTraits<lld::mach_o::normalized::NormalizedFile, llvm::yaml::EmptyContext>::value, llvm::yaml::Input&>::type llvm::yaml::operator>><lld::mach_o::normalized::NormalizedFile>(llvm::yaml::Input&, lld::mach_o::normalized::NormalizedFile&) Line | Count | Source | 1709 | 13 | operator>>(Input &yin, T &docMap) { | 1710 | 13 | EmptyContext Ctx; | 1711 | 13 | yin.setCurrentDocument(); | 1712 | 13 | yamlize(yin, docMap, true, Ctx); | 1713 | 13 | return yin; | 1714 | 13 | } |
|
1715 | | |
1716 | | // Define non-member operator>> so that Input can stream in a sequence as |
1717 | | // a document. |
1718 | | template <typename T> |
1719 | | inline |
1720 | | typename std::enable_if<has_SequenceTraits<T>::value, Input &>::type |
1721 | | operator>>(Input &yin, T &docSeq) { |
1722 | | EmptyContext Ctx; |
1723 | | if (yin.setCurrentDocument()) |
1724 | | yamlize(yin, docSeq, true, Ctx); |
1725 | | return yin; |
1726 | | } |
1727 | | |
1728 | | // Define non-member operator>> so that Input can stream in a block scalar. |
1729 | | template <typename T> |
1730 | | inline |
1731 | | typename std::enable_if<has_BlockScalarTraits<T>::value, Input &>::type |
1732 | | operator>>(Input &In, T &Val) { |
1733 | | EmptyContext Ctx; |
1734 | | if (In.setCurrentDocument()) |
1735 | | yamlize(In, Val, true, Ctx); |
1736 | | return In; |
1737 | | } |
1738 | | |
1739 | | // Define non-member operator>> so that Input can stream in a string map. |
1740 | | template <typename T> |
1741 | | inline |
1742 | | typename std::enable_if<has_CustomMappingTraits<T>::value, Input &>::type |
1743 | | operator>>(Input &In, T &Val) { |
1744 | | EmptyContext Ctx; |
1745 | | if (In.setCurrentDocument()) |
1746 | | yamlize(In, Val, true, Ctx); |
1747 | | return In; |
1748 | | } |
1749 | | |
1750 | | // Define non-member operator>> so that Input can stream in a polymorphic type. |
1751 | | template <typename T> |
1752 | | inline typename std::enable_if<has_PolymorphicTraits<T>::value, Input &>::type |
1753 | 20 | operator>>(Input &In, T &Val) { |
1754 | 20 | EmptyContext Ctx; |
1755 | 20 | if (In.setCurrentDocument()) |
1756 | 20 | yamlize(In, Val, true, Ctx); |
1757 | 20 | return In; |
1758 | 20 | } |
1759 | | |
1760 | | // Provide better error message about types missing a trait specialization |
1761 | | template <typename T> |
1762 | | inline typename std::enable_if<missingTraits<T, EmptyContext>::value, |
1763 | | Input &>::type |
1764 | | operator>>(Input &yin, T &docSeq) { |
1765 | | char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)]; |
1766 | | return yin; |
1767 | | } |
1768 | | |
1769 | | // Define non-member operator<< so that Output can stream out document list. |
1770 | | template <typename T> |
1771 | | inline |
1772 | | typename std::enable_if<has_DocumentListTraits<T>::value, Output &>::type |
1773 | | operator<<(Output &yout, T &docList) { |
1774 | | EmptyContext Ctx; |
1775 | | yout.beginDocuments(); |
1776 | | const size_t count = DocumentListTraits<T>::size(yout, docList); |
1777 | | for(size_t i=0; i < count; ++i) { |
1778 | | if ( yout.preflightDocument(i) ) { |
1779 | | yamlize(yout, DocumentListTraits<T>::element(yout, docList, i), true, |
1780 | | Ctx); |
1781 | | yout.postflightDocument(); |
1782 | | } |
1783 | | } |
1784 | | yout.endDocuments(); |
1785 | | return yout; |
1786 | | } |
1787 | | |
1788 | | // Define non-member operator<< so that Output can stream out a map. |
1789 | | template <typename T> |
1790 | | inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value, |
1791 | | Output &>::type |
1792 | 12.7k | operator<<(Output &yout, T &map) { |
1793 | 12.7k | EmptyContext Ctx; |
1794 | 12.7k | yout.beginDocuments(); |
1795 | 12.7k | if ( yout.preflightDocument(0) ) { |
1796 | 12.7k | yamlize(yout, map, true, Ctx); |
1797 | 12.7k | yout.postflightDocument(); |
1798 | 12.7k | } |
1799 | 12.7k | yout.endDocuments(); |
1800 | 12.7k | return yout; |
1801 | 12.7k | } std::__1::enable_if<has_MappingTraits<llvm::yaml::MachineFunction, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<llvm::yaml::MachineFunction>(llvm::yaml::Output&, llvm::yaml::MachineFunction&) Line | Count | Source | 1792 | 11.9k | operator<<(Output &yout, T &map) { | 1793 | 11.9k | EmptyContext Ctx; | 1794 | 11.9k | yout.beginDocuments(); | 1795 | 11.9k | if ( yout.preflightDocument(0) ) { | 1796 | 11.9k | yamlize(yout, map, true, Ctx); | 1797 | 11.9k | yout.postflightDocument(); | 1798 | 11.9k | } | 1799 | 11.9k | yout.endDocuments(); | 1800 | 11.9k | return yout; | 1801 | 11.9k | } |
std::__1::enable_if<has_MappingTraits<llvm::ModuleSummaryIndex, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<llvm::ModuleSummaryIndex>(llvm::yaml::Output&, llvm::ModuleSummaryIndex&) Line | Count | Source | 1792 | 26 | operator<<(Output &yout, T &map) { | 1793 | 26 | EmptyContext Ctx; | 1794 | 26 | yout.beginDocuments(); | 1795 | 26 | if ( yout.preflightDocument(0) ) { | 1796 | 26 | yamlize(yout, map, true, Ctx); | 1797 | 26 | yout.postflightDocument(); | 1798 | 26 | } | 1799 | 26 | yout.endDocuments(); | 1800 | 26 | return yout; | 1801 | 26 | } |
std::__1::enable_if<has_MappingTraits<llvm::AMDGPU::HSAMD::Metadata, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<llvm::AMDGPU::HSAMD::Metadata>(llvm::yaml::Output&, llvm::AMDGPU::HSAMD::Metadata&) Line | Count | Source | 1792 | 352 | operator<<(Output &yout, T &map) { | 1793 | 352 | EmptyContext Ctx; | 1794 | 352 | yout.beginDocuments(); | 1795 | 352 | if ( yout.preflightDocument(0) ) { | 1796 | 352 | yamlize(yout, map, true, Ctx); | 1797 | 352 | yout.postflightDocument(); | 1798 | 352 | } | 1799 | 352 | yout.endDocuments(); | 1800 | 352 | return yout; | 1801 | 352 | } |
std::__1::enable_if<has_MappingTraits<llvm::remarks::Remark*, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<llvm::remarks::Remark*>(llvm::yaml::Output&, llvm::remarks::Remark*&) Line | Count | Source | 1792 | 427 | operator<<(Output &yout, T &map) { | 1793 | 427 | EmptyContext Ctx; | 1794 | 427 | yout.beginDocuments(); | 1795 | 427 | if ( yout.preflightDocument(0) ) { | 1796 | 427 | yamlize(yout, map, true, Ctx); | 1797 | 427 | yout.postflightDocument(); | 1798 | 427 | } | 1799 | 427 | yout.endDocuments(); | 1800 | 427 | return yout; | 1801 | 427 | } |
std::__1::enable_if<has_MappingTraits<lld::mach_o::normalized::NormalizedFile, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<lld::mach_o::normalized::NormalizedFile>(llvm::yaml::Output&, lld::mach_o::normalized::NormalizedFile&) Line | Count | Source | 1792 | 1 | operator<<(Output &yout, T &map) { | 1793 | 1 | EmptyContext Ctx; | 1794 | 1 | yout.beginDocuments(); | 1795 | 1 | if ( yout.preflightDocument(0) ) { | 1796 | 1 | yamlize(yout, map, true, Ctx); | 1797 | 1 | yout.postflightDocument(); | 1798 | 1 | } | 1799 | 1 | yout.endDocuments(); | 1800 | 1 | return yout; | 1801 | 1 | } |
std::__1::enable_if<has_MappingTraits<lld::File const*, llvm::yaml::EmptyContext>::value, llvm::yaml::Output&>::type llvm::yaml::operator<<<lld::File const*>(llvm::yaml::Output&, lld::File const*&) Line | Count | Source | 1792 | 60 | operator<<(Output &yout, T &map) { | 1793 | 60 | EmptyContext Ctx; | 1794 | 60 | yout.beginDocuments(); | 1795 | 60 | if ( yout.preflightDocument(0) ) { | 1796 | 60 | yamlize(yout, map, true, Ctx); | 1797 | 60 | yout.postflightDocument(); | 1798 | 60 | } | 1799 | 60 | yout.endDocuments(); | 1800 | 60 | return yout; | 1801 | 60 | } |
|
1802 | | |
1803 | | // Define non-member operator<< so that Output can stream out a sequence. |
1804 | | template <typename T> |
1805 | | inline |
1806 | | typename std::enable_if<has_SequenceTraits<T>::value, Output &>::type |
1807 | | operator<<(Output &yout, T &seq) { |
1808 | | EmptyContext Ctx; |
1809 | | yout.beginDocuments(); |
1810 | | if ( yout.preflightDocument(0) ) { |
1811 | | yamlize(yout, seq, true, Ctx); |
1812 | | yout.postflightDocument(); |
1813 | | } |
1814 | | yout.endDocuments(); |
1815 | | return yout; |
1816 | | } |
1817 | | |
1818 | | // Define non-member operator<< so that Output can stream out a block scalar. |
1819 | | template <typename T> |
1820 | | inline |
1821 | | typename std::enable_if<has_BlockScalarTraits<T>::value, Output &>::type |
1822 | 2.09k | operator<<(Output &Out, T &Val) { |
1823 | 2.09k | EmptyContext Ctx; |
1824 | 2.09k | Out.beginDocuments(); |
1825 | 2.09k | if (Out.preflightDocument(0)) { |
1826 | 2.09k | yamlize(Out, Val, true, Ctx); |
1827 | 2.09k | Out.postflightDocument(); |
1828 | 2.09k | } |
1829 | 2.09k | Out.endDocuments(); |
1830 | 2.09k | return Out; |
1831 | 2.09k | } |
1832 | | |
1833 | | // Define non-member operator<< so that Output can stream out a string map. |
1834 | | template <typename T> |
1835 | | inline |
1836 | | typename std::enable_if<has_CustomMappingTraits<T>::value, Output &>::type |
1837 | | operator<<(Output &Out, T &Val) { |
1838 | | EmptyContext Ctx; |
1839 | | Out.beginDocuments(); |
1840 | | if (Out.preflightDocument(0)) { |
1841 | | yamlize(Out, Val, true, Ctx); |
1842 | | Out.postflightDocument(); |
1843 | | } |
1844 | | Out.endDocuments(); |
1845 | | return Out; |
1846 | | } |
1847 | | |
1848 | | // Define non-member operator<< so that Output can stream out a polymorphic |
1849 | | // type. |
1850 | | template <typename T> |
1851 | | inline typename std::enable_if<has_PolymorphicTraits<T>::value, Output &>::type |
1852 | 602 | operator<<(Output &Out, T &Val) { |
1853 | 602 | EmptyContext Ctx; |
1854 | 602 | Out.beginDocuments(); |
1855 | 602 | if (Out.preflightDocument(0)) { |
1856 | 602 | // FIXME: The parser does not support explicit documents terminated with a |
1857 | 602 | // plain scalar; the end-marker is included as part of the scalar token. |
1858 | 602 | assert(PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && "plain scalar documents are not supported"); |
1859 | 602 | yamlize(Out, Val, true, Ctx); |
1860 | 602 | Out.postflightDocument(); |
1861 | 602 | } |
1862 | 602 | Out.endDocuments(); |
1863 | 602 | return Out; |
1864 | 602 | } |
1865 | | |
1866 | | // Provide better error message about types missing a trait specialization |
1867 | | template <typename T> |
1868 | | inline typename std::enable_if<missingTraits<T, EmptyContext>::value, |
1869 | | Output &>::type |
1870 | | operator<<(Output &yout, T &seq) { |
1871 | | char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)]; |
1872 | | return yout; |
1873 | | } |
1874 | | |
1875 | | template <bool B> struct IsFlowSequenceBase {}; |
1876 | | template <> struct IsFlowSequenceBase<true> { static const bool flow = true; }; |
1877 | | |
1878 | | template <typename T, bool Flow> |
1879 | | struct SequenceTraitsImpl : IsFlowSequenceBase<Flow> { |
1880 | | private: |
1881 | | using type = typename T::value_type; |
1882 | | |
1883 | | public: |
1884 | 74.2k | static size_t size(IO &io, T &seq) { return seq.size(); } llvm::yaml::SequenceTraitsImpl<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> > > >, false>::size(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> > > >&) Line | Count | Source | 1884 | 44 | static size_t size(IO &io, T &seq) { return seq.size(); } |
Unexecuted instantiation: cc1gen_reproducer_main.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >, false>::size(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&) llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&) Line | Count | Source | 1884 | 2 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, true>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&) Line | Count | Source | 1884 | 30 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&) Line | Count | Source | 1884 | 13 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&) Line | Count | Source | 1884 | 11.9k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&) Line | Count | Source | 1884 | 11.8k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&) Line | Count | Source | 1884 | 11.7k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&) Line | Count | Source | 1884 | 11.7k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&) Line | Count | Source | 1884 | 11.7k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&) Line | Count | Source | 1884 | 11.7k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >&) Line | Count | Source | 1884 | 36 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, true>::size(llvm::yaml::IO&, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&) Line | Count | Source | 1884 | 48 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&) Line | Count | Source | 1884 | 24 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&) Line | Count | Source | 1884 | 24 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, true>::size(llvm::yaml::IO&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&) Line | Count | Source | 1884 | 1.20k | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&) Line | Count | Source | 1884 | 259 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&) Line | Count | Source | 1884 | 1.35k | static size_t size(IO &io, T &seq) { return seq.size(); } |
Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&) llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >, false>::size(llvm::yaml::IO&, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&) Line | Count | Source | 1884 | 75 | static size_t size(IO &io, T &seq) { return seq.size(); } |
Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&) ReaderWriterYAML.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >, true>::size(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&) Line | Count | Source | 1884 | 240 | static size_t size(IO &io, T &seq) { return seq.size(); } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >, false>::size(llvm::yaml::IO&, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&) Line | Count | Source | 1884 | 113 | static size_t size(IO &io, T &seq) { return seq.size(); } |
Unexecuted instantiation: ReaderWriterYAML.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >, false>::size(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&) |
1885 | | |
1886 | 127k | static type &element(IO &io, T &seq, size_t index) { |
1887 | 127k | if (index >= seq.size()) |
1888 | 28.0k | seq.resize(index + 1); |
1889 | 127k | return seq[index]; |
1890 | 127k | } llvm::yaml::SequenceTraitsImpl<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> > > >, false>::element(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> > > >&, unsigned long) Line | Count | Source | 1886 | 193 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 193 | if (index >= seq.size()) | 1888 | 101 | seq.resize(index + 1); | 1889 | 193 | return seq[index]; | 1890 | 193 | } |
cc1gen_reproducer_main.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >, false>::element(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::UnsavedFileHash, std::__1::allocator<(anonymous namespace)::UnsavedFileHash> >&, unsigned long) Line | Count | Source | 1886 | 2 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 2 | if (index >= seq.size()) | 1888 | 2 | seq.resize(index + 1); | 1889 | 2 | return seq[index]; | 1890 | 2 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo::ArgRegPair, std::__1::allocator<llvm::yaml::CallSiteInfo::ArgRegPair> >&, unsigned long) Line | Count | Source | 1886 | 13 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 13 | if (index >= seq.size()) | 1888 | 7 | seq.resize(index + 1); | 1889 | 13 | return seq[index]; | 1890 | 13 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >, true>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FlowStringValue, std::__1::allocator<llvm::yaml::FlowStringValue> >&, unsigned long) Line | Count | Source | 1886 | 1.56k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 1.56k | if (index >= seq.size()) | 1888 | 913 | seq.resize(index + 1); | 1889 | 1.56k | return seq[index]; | 1890 | 1.56k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineJumpTable::Entry, std::__1::allocator<llvm::yaml::MachineJumpTable::Entry> >&, unsigned long) Line | Count | Source | 1886 | 39 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 39 | if (index >= seq.size()) | 1888 | 21 | seq.resize(index + 1); | 1889 | 39 | return seq[index]; | 1890 | 39 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::VirtualRegisterDefinition, std::__1::allocator<llvm::yaml::VirtualRegisterDefinition> >&, unsigned long) Line | Count | Source | 1886 | 86.2k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 86.2k | if (index >= seq.size()) | 1888 | 17.4k | seq.resize(index + 1); | 1889 | 86.2k | return seq[index]; | 1890 | 86.2k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineFunctionLiveIn, std::__1::allocator<llvm::yaml::MachineFunctionLiveIn> >&, unsigned long) Line | Count | Source | 1886 | 4.83k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 4.83k | if (index >= seq.size()) | 1888 | 2.19k | seq.resize(index + 1); | 1889 | 4.83k | return seq[index]; | 1890 | 4.83k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FixedMachineStackObject, std::__1::allocator<llvm::yaml::FixedMachineStackObject> >&, unsigned long) Line | Count | Source | 1886 | 859 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 859 | if (index >= seq.size()) | 1888 | 244 | seq.resize(index + 1); | 1889 | 859 | return seq[index]; | 1890 | 859 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineStackObject, std::__1::allocator<llvm::yaml::MachineStackObject> >&, unsigned long) Line | Count | Source | 1886 | 1.64k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 1.64k | if (index >= seq.size()) | 1888 | 598 | seq.resize(index + 1); | 1889 | 1.64k | return seq[index]; | 1890 | 1.64k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::CallSiteInfo, std::__1::allocator<llvm::yaml::CallSiteInfo> >&, unsigned long) Line | Count | Source | 1886 | 7 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 7 | if (index >= seq.size()) | 1888 | 5 | seq.resize(index + 1); | 1889 | 7 | return seq[index]; | 1890 | 7 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::MachineConstantPoolValue, std::__1::allocator<llvm::yaml::MachineConstantPoolValue> >&, unsigned long) Line | Count | Source | 1886 | 124 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 124 | if (index >= seq.size()) | 1888 | 34 | seq.resize(index + 1); | 1889 | 124 | return seq[index]; | 1890 | 124 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >, true>::element(llvm::yaml::IO&, std::__1::vector<unsigned long long, std::__1::allocator<unsigned long long> >&, unsigned long) Line | Count | Source | 1886 | 188 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 188 | if (index >= seq.size()) | 1888 | 98 | seq.resize(index + 1); | 1889 | 188 | return seq[index]; | 1890 | 188 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::VFuncId, std::__1::allocator<llvm::FunctionSummary::VFuncId> >&, unsigned long) Line | Count | Source | 1886 | 52 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 52 | if (index >= seq.size()) | 1888 | 26 | seq.resize(index + 1); | 1889 | 52 | return seq[index]; | 1890 | 52 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::FunctionSummary::ConstVCall, std::__1::allocator<llvm::FunctionSummary::ConstVCall> >&, unsigned long) Line | Count | Source | 1886 | 48 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 48 | if (index >= seq.size()) | 1888 | 24 | seq.resize(index + 1); | 1889 | 48 | return seq[index]; | 1890 | 48 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::yaml::FunctionSummaryYaml, std::__1::allocator<llvm::yaml::FunctionSummaryYaml> >&, unsigned long) Line | Count | Source | 1886 | 96 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 96 | if (index >= seq.size()) | 1888 | 60 | seq.resize(index + 1); | 1889 | 96 | return seq[index]; | 1890 | 96 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >, true>::element(llvm::yaml::IO&, std::__1::vector<unsigned int, std::__1::allocator<unsigned int> >&, unsigned long) Line | Count | Source | 1886 | 3.09k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 3.09k | if (index >= seq.size()) | 1888 | 432 | seq.resize(index + 1); | 1889 | 3.09k | return seq[index]; | 1890 | 3.09k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Arg::Metadata> >&, unsigned long) Line | Count | Source | 1886 | 7.63k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 7.63k | if (index >= seq.size()) | 1888 | 966 | seq.resize(index + 1); | 1889 | 7.63k | return seq[index]; | 1890 | 7.63k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::AMDGPU::HSAMD::Kernel::Metadata, std::__1::allocator<llvm::AMDGPU::HSAMD::Kernel::Metadata> >&, unsigned long) Line | Count | Source | 1886 | 1.79k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 1.79k | if (index >= seq.size()) | 1888 | 135 | seq.resize(index + 1); | 1889 | 1.79k | return seq[index]; | 1890 | 1.79k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DependentDylib, std::__1::allocator<lld::mach_o::normalized::DependentDylib> >&, unsigned long) Line | Count | Source | 1886 | 1 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 1 | if (index >= seq.size()) | 1888 | 1 | seq.resize(index + 1); | 1889 | 1 | return seq[index]; | 1890 | 1 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >, false>::element(llvm::yaml::IO&, std::__1::vector<llvm::StringRef, std::__1::allocator<llvm::StringRef> >&, unsigned long) Line | Count | Source | 1886 | 10.2k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 10.2k | if (index >= seq.size()) | 1888 | 449 | seq.resize(index + 1); | 1889 | 10.2k | return seq[index]; | 1890 | 10.2k | } |
Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Segment, std::__1::allocator<lld::mach_o::normalized::Segment> >&, unsigned long) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::RebaseLocation, std::__1::allocator<lld::mach_o::normalized::RebaseLocation> >&, unsigned long) Unexecuted instantiation: llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::BindLocation, std::__1::allocator<lld::mach_o::normalized::BindLocation> >&, unsigned long) llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::Export, std::__1::allocator<lld::mach_o::normalized::Export> >&, unsigned long) Line | Count | Source | 1886 | 143 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 143 | if (index >= seq.size()) | 1888 | 143 | seq.resize(index + 1); | 1889 | 143 | return seq[index]; | 1890 | 143 | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::mach_o::normalized::DataInCode, std::__1::allocator<lld::mach_o::normalized::DataInCode> >&, unsigned long) Line | Count | Source | 1886 | 18 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 18 | if (index >= seq.size()) | 1888 | 18 | seq.resize(index + 1); | 1889 | 18 | return seq[index]; | 1890 | 18 | } |
ReaderWriterYAML.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >, true>::element(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ImplicitHex8, std::__1::allocator<(anonymous namespace)::ImplicitHex8> >&, unsigned long) Line | Count | Source | 1886 | 8.36k | static type &element(IO &io, T &seq, size_t index) { | 1887 | 8.36k | if (index >= seq.size()) | 1888 | 4.10k | seq.resize(index + 1); | 1889 | 8.36k | return seq[index]; | 1890 | 8.36k | } |
llvm::yaml::SequenceTraitsImpl<std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >, false>::element(llvm::yaml::IO&, std::__1::vector<lld::Reference const*, std::__1::allocator<lld::Reference const*> >&, unsigned long) Line | Count | Source | 1886 | 460 | static type &element(IO &io, T &seq, size_t index) { | 1887 | 460 | if (index >= seq.size()) | 1888 | 18 | seq.resize(index + 1); | 1889 | 460 | return seq[index]; | 1890 | 460 | } |
Unexecuted instantiation: ReaderWriterYAML.cpp:llvm::yaml::SequenceTraitsImpl<std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >, false>::element(llvm::yaml::IO&, std::__1::vector<(anonymous namespace)::ArchMember, std::__1::allocator<(anonymous namespace)::ArchMember> >&, unsigned long) |
1891 | | }; |
1892 | | |
1893 | | // Simple helper to check an expression can be used as a bool-valued template |
1894 | | // argument. |
1895 | | template <bool> struct CheckIsBool { static const bool value = true; }; |
1896 | | |
1897 | | // If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have |
1898 | | // SequenceTraits that do the obvious thing. |
1899 | | template <typename T> |
1900 | | struct SequenceTraits<std::vector<T>, |
1901 | | typename std::enable_if<CheckIsBool< |
1902 | | SequenceElementTraits<T>::flow>::value>::type> |
1903 | | : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {}; |
1904 | | template <typename T, unsigned N> |
1905 | | struct SequenceTraits<SmallVector<T, N>, |
1906 | | typename std::enable_if<CheckIsBool< |
1907 | | SequenceElementTraits<T>::flow>::value>::type> |
1908 | | : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {}; |
1909 | | template <typename T> |
1910 | | struct SequenceTraits<SmallVectorImpl<T>, |
1911 | | typename std::enable_if<CheckIsBool< |
1912 | | SequenceElementTraits<T>::flow>::value>::type> |
1913 | | : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {}; |
1914 | | |
1915 | | // Sequences of fundamental types use flow formatting. |
1916 | | template <typename T> |
1917 | | struct SequenceElementTraits< |
1918 | | T, typename std::enable_if<std::is_fundamental<T>::value>::type> { |
1919 | | static const bool flow = true; |
1920 | | }; |
1921 | | |
1922 | | // Sequences of strings use block formatting. |
1923 | | template<> struct SequenceElementTraits<std::string> { |
1924 | | static const bool flow = false; |
1925 | | }; |
1926 | | template<> struct SequenceElementTraits<StringRef> { |
1927 | | static const bool flow = false; |
1928 | | }; |
1929 | | template<> struct SequenceElementTraits<std::pair<std::string, std::string>> { |
1930 | | static const bool flow = false; |
1931 | | }; |
1932 | | |
1933 | | /// Implementation of CustomMappingTraits for std::map<std::string, T>. |
1934 | | template <typename T> struct StdMapStringCustomMappingTraitsImpl { |
1935 | | using map_type = std::map<std::string, T>; |
1936 | | |
1937 | | static void inputOne(IO &io, StringRef key, map_type &v) { |
1938 | | io.mapRequired(key.str().c_str(), v[key]); |
1939 | | } |
1940 | | |
1941 | | static void output(IO &io, map_type &v) { |
1942 | | for (auto &p : v) |
1943 | | io.mapRequired(p.first.c_str(), p.second); |
1944 | | } |
1945 | | }; |
1946 | | |
1947 | | } // end namespace yaml |
1948 | | } // end namespace llvm |
1949 | | |
1950 | | #define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW) \ |
1951 | | namespace llvm { \ |
1952 | | namespace yaml { \ |
1953 | | static_assert( \ |
1954 | | !std::is_fundamental<TYPE>::value && \ |
1955 | | !std::is_same<TYPE, std::string>::value && \ |
1956 | | !std::is_same<TYPE, llvm::StringRef>::value, \ |
1957 | | "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \ |
1958 | | template <> struct SequenceElementTraits<TYPE> { \ |
1959 | | static const bool flow = FLOW; \ |
1960 | | }; \ |
1961 | | } \ |
1962 | | } |
1963 | | |
1964 | | /// Utility for declaring that a std::vector of a particular type |
1965 | | /// should be considered a YAML sequence. |
1966 | | #define LLVM_YAML_IS_SEQUENCE_VECTOR(type) \ |
1967 | | LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false) |
1968 | | |
1969 | | /// Utility for declaring that a std::vector of a particular type |
1970 | | /// should be considered a YAML flow sequence. |
1971 | | #define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type) \ |
1972 | | LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true) |
1973 | | |
1974 | | #define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type) \ |
1975 | | namespace llvm { \ |
1976 | | namespace yaml { \ |
1977 | | template <> struct MappingTraits<Type> { \ |
1978 | | static void mapping(IO &IO, Type &Obj); \ |
1979 | | }; \ |
1980 | | } \ |
1981 | | } |
1982 | | |
1983 | | #define LLVM_YAML_DECLARE_ENUM_TRAITS(Type) \ |
1984 | | namespace llvm { \ |
1985 | | namespace yaml { \ |
1986 | | template <> struct ScalarEnumerationTraits<Type> { \ |
1987 | | static void enumeration(IO &io, Type &Value); \ |
1988 | | }; \ |
1989 | | } \ |
1990 | | } |
1991 | | |
1992 | | #define LLVM_YAML_DECLARE_BITSET_TRAITS(Type) \ |
1993 | | namespace llvm { \ |
1994 | | namespace yaml { \ |
1995 | | template <> struct ScalarBitSetTraits<Type> { \ |
1996 | | static void bitset(IO &IO, Type &Options); \ |
1997 | | }; \ |
1998 | | } \ |
1999 | | } |
2000 | | |
2001 | | #define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote) \ |
2002 | | namespace llvm { \ |
2003 | | namespace yaml { \ |
2004 | | template <> struct ScalarTraits<Type> { \ |
2005 | | static void output(const Type &Value, void *ctx, raw_ostream &Out); \ |
2006 | | static StringRef input(StringRef Scalar, void *ctxt, Type &Value); \ |
2007 | | static QuotingType mustQuote(StringRef) { return MustQuote; } \ |
2008 | | }; \ |
2009 | | } \ |
2010 | | } |
2011 | | |
2012 | | /// Utility for declaring that a std::vector of a particular type |
2013 | | /// should be considered a YAML document list. |
2014 | | #define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type) \ |
2015 | | namespace llvm { \ |
2016 | | namespace yaml { \ |
2017 | | template <unsigned N> \ |
2018 | | struct DocumentListTraits<SmallVector<_type, N>> \ |
2019 | | : public SequenceTraitsImpl<SmallVector<_type, N>, false> {}; \ |
2020 | | template <> \ |
2021 | | struct DocumentListTraits<std::vector<_type>> \ |
2022 | | : public SequenceTraitsImpl<std::vector<_type>, false> {}; \ |
2023 | | } \ |
2024 | | } |
2025 | | |
2026 | | /// Utility for declaring that std::map<std::string, _type> should be considered |
2027 | | /// a YAML map. |
2028 | | #define LLVM_YAML_IS_STRING_MAP(_type) \ |
2029 | | namespace llvm { \ |
2030 | | namespace yaml { \ |
2031 | | template <> \ |
2032 | | struct CustomMappingTraits<std::map<std::string, _type>> \ |
2033 | | : public StdMapStringCustomMappingTraitsImpl<_type> {}; \ |
2034 | | } \ |
2035 | | } |
2036 | | |
2037 | | #endif // LLVM_SUPPORT_YAMLTRAITS_H |