LLVM 17.0.0git
ScopedPrinter.h
Go to the documentation of this file.
1//===-- ScopedPrinter.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_SCOPEDPRINTER_H
10#define LLVM_SUPPORT_SCOPEDPRINTER_H
11
12#include "llvm/ADT/APSInt.h"
13#include "llvm/ADT/ArrayRef.h"
16#include "llvm/ADT/StringRef.h"
18#include "llvm/Support/Endian.h"
19#include "llvm/Support/JSON.h"
21
22namespace llvm {
23
24template <typename T> struct EnumEntry {
26 // While Name suffices in most of the cases, in certain cases
27 // GNU style and LLVM style of ELFDumper do not
28 // display same string for same enum. The AltName if initialized appropriately
29 // will hold the string that GNU style emits.
30 // Example:
31 // "EM_X86_64" string on LLVM style for Elf_Ehdr->e_machine corresponds to
32 // "Advanced Micro Devices X86-64" on GNU style
36 : Name(N), AltName(A), Value(V) {}
37 constexpr EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
38};
39
40struct HexNumber {
41 // To avoid sign-extension we have to explicitly cast to the appropriate
42 // unsigned type. The overloads are here so that every type that is implicitly
43 // convertible to an integer (including enums and endian helpers) can be used
44 // without requiring type traits or call-site changes.
45 HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {}
46 HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) {}
47 HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) {}
48 HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) {}
49 HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) {}
50 HexNumber(signed long long Value)
51 : Value(static_cast<unsigned long long>(Value)) {}
52 HexNumber(unsigned char Value) : Value(Value) {}
53 HexNumber(unsigned short Value) : Value(Value) {}
54 HexNumber(unsigned int Value) : Value(Value) {}
55 HexNumber(unsigned long Value) : Value(Value) {}
56 HexNumber(unsigned long long Value) : Value(Value) {}
58};
59
60struct FlagEntry {
62 : Name(Name), Value(static_cast<unsigned char>(Value)) {}
64 : Name(Name), Value(static_cast<unsigned char>(Value)) {}
66 : Name(Name), Value(static_cast<unsigned short>(Value)) {}
68 : Name(Name), Value(static_cast<unsigned int>(Value)) {}
70 : Name(Name), Value(static_cast<unsigned long>(Value)) {}
71 FlagEntry(StringRef Name, signed long long Value)
72 : Name(Name), Value(static_cast<unsigned long long>(Value)) {}
73 FlagEntry(StringRef Name, unsigned char Value) : Name(Name), Value(Value) {}
74 FlagEntry(StringRef Name, unsigned short Value) : Name(Name), Value(Value) {}
76 FlagEntry(StringRef Name, unsigned long Value) : Name(Name), Value(Value) {}
77 FlagEntry(StringRef Name, unsigned long long Value)
78 : Name(Name), Value(Value) {}
81};
82
84
85template <class T> std::string to_string(const T &Value) {
86 std::string number;
87 raw_string_ostream stream(number);
88 stream << Value;
89 return stream.str();
90}
91
92template <typename T, typename TEnum>
93std::string enumToString(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
94 for (const EnumEntry<TEnum> &EnumItem : EnumValues)
95 if (EnumItem.Value == Value)
96 return std::string(EnumItem.AltName);
97 return utohexstr(Value, true);
98}
99
101public:
102 enum class ScopedPrinterKind {
103 Base,
104 JSON,
105 };
106
109 : OS(OS), Kind(Kind) {}
110
111 ScopedPrinterKind getKind() const { return Kind; }
112
113 static bool classof(const ScopedPrinter *SP) {
114 return SP->getKind() == ScopedPrinterKind::Base;
115 }
116
117 virtual ~ScopedPrinter() = default;
118
119 void flush() { OS.flush(); }
120
121 void indent(int Levels = 1) { IndentLevel += Levels; }
122
123 void unindent(int Levels = 1) {
124 IndentLevel = IndentLevel > Levels ? IndentLevel - Levels : 0;
125 }
126
127 void resetIndent() { IndentLevel = 0; }
128
129 int getIndentLevel() { return IndentLevel; }
130
131 void setPrefix(StringRef P) { Prefix = P; }
132
133 void printIndent() {
134 OS << Prefix;
135 for (int i = 0; i < IndentLevel; ++i)
136 OS << " ";
137 }
138
139 template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
140
141 template <typename T, typename TEnum>
143 ArrayRef<EnumEntry<TEnum>> EnumValues) {
145 bool Found = false;
146 for (const auto &EnumItem : EnumValues) {
147 if (EnumItem.Value == Value) {
148 Name = EnumItem.Name;
149 Found = true;
150 break;
151 }
152 }
153
154 if (Found)
155 printHex(Label, Name, Value);
156 else
157 printHex(Label, Value);
158 }
159
160 template <typename T, typename TFlag>
162 TFlag EnumMask1 = {}, TFlag EnumMask2 = {},
163 TFlag EnumMask3 = {}) {
164 SmallVector<FlagEntry, 10> SetFlags;
165
166 for (const auto &Flag : Flags) {
167 if (Flag.Value == 0)
168 continue;
169
170 TFlag EnumMask{};
171 if (Flag.Value & EnumMask1)
172 EnumMask = EnumMask1;
173 else if (Flag.Value & EnumMask2)
174 EnumMask = EnumMask2;
175 else if (Flag.Value & EnumMask3)
176 EnumMask = EnumMask3;
177 bool IsEnum = (Flag.Value & EnumMask) != 0;
178 if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
179 (IsEnum && (Value & EnumMask) == Flag.Value)) {
180 SetFlags.emplace_back(Flag.Name, Flag.Value);
181 }
182 }
183
184 llvm::sort(SetFlags, &flagName);
185 printFlagsImpl(Label, hex(Value), SetFlags);
186 }
187
188 template <typename T> void printFlags(StringRef Label, T Value) {
190 uint64_t Flag = 1;
191 uint64_t Curr = Value;
192 while (Curr > 0) {
193 if (Curr & 1)
194 SetFlags.emplace_back(Flag);
195 Curr >>= 1;
196 Flag <<= 1;
197 }
198 printFlagsImpl(Label, hex(Value), SetFlags);
199 }
200
201 virtual void printNumber(StringRef Label, uint64_t Value) {
202 startLine() << Label << ": " << Value << "\n";
203 }
204
205 virtual void printNumber(StringRef Label, uint32_t Value) {
206 startLine() << Label << ": " << Value << "\n";
207 }
208
209 virtual void printNumber(StringRef Label, uint16_t Value) {
210 startLine() << Label << ": " << Value << "\n";
211 }
212
213 virtual void printNumber(StringRef Label, uint8_t Value) {
214 startLine() << Label << ": " << unsigned(Value) << "\n";
215 }
216
217 virtual void printNumber(StringRef Label, int64_t Value) {
218 startLine() << Label << ": " << Value << "\n";
219 }
220
221 virtual void printNumber(StringRef Label, int32_t Value) {
222 startLine() << Label << ": " << Value << "\n";
223 }
224
225 virtual void printNumber(StringRef Label, int16_t Value) {
226 startLine() << Label << ": " << Value << "\n";
227 }
228
229 virtual void printNumber(StringRef Label, int8_t Value) {
230 startLine() << Label << ": " << int(Value) << "\n";
231 }
232
233 virtual void printNumber(StringRef Label, const APSInt &Value) {
234 startLine() << Label << ": " << Value << "\n";
235 }
236
237 template <typename T>
239 printNumberImpl(Label, Str, to_string(Value));
240 }
241
242 virtual void printBoolean(StringRef Label, bool Value) {
243 startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
244 }
245
246 template <typename... T> void printVersion(StringRef Label, T... Version) {
247 startLine() << Label << ": ";
248 printVersionInternal(Version...);
249 getOStream() << "\n";
250 }
251
252 template <typename T>
253 void printList(StringRef Label, const ArrayRef<T> List) {
255 for (const auto &Item : List)
256 StringList.emplace_back(to_string(Item));
257 printList(Label, StringList);
258 }
259
260 virtual void printList(StringRef Label, const ArrayRef<bool> List) {
261 printListImpl(Label, List);
262 }
263
264 virtual void printList(StringRef Label, const ArrayRef<std::string> List) {
265 printListImpl(Label, List);
266 }
267
268 virtual void printList(StringRef Label, const ArrayRef<uint64_t> List) {
269 printListImpl(Label, List);
270 }
271
272 virtual void printList(StringRef Label, const ArrayRef<uint32_t> List) {
273 printListImpl(Label, List);
274 }
275
276 virtual void printList(StringRef Label, const ArrayRef<uint16_t> List) {
277 printListImpl(Label, List);
278 }
279
280 virtual void printList(StringRef Label, const ArrayRef<uint8_t> List) {
281 SmallVector<unsigned> NumberList;
282 for (const uint8_t &Item : List)
283 NumberList.emplace_back(Item);
284 printListImpl(Label, NumberList);
285 }
286
287 virtual void printList(StringRef Label, const ArrayRef<int64_t> List) {
288 printListImpl(Label, List);
289 }
290
291 virtual void printList(StringRef Label, const ArrayRef<int32_t> List) {
292 printListImpl(Label, List);
293 }
294
295 virtual void printList(StringRef Label, const ArrayRef<int16_t> List) {
296 printListImpl(Label, List);
297 }
298
299 virtual void printList(StringRef Label, const ArrayRef<int8_t> List) {
300 SmallVector<int> NumberList;
301 for (const int8_t &Item : List)
302 NumberList.emplace_back(Item);
303 printListImpl(Label, NumberList);
304 }
305
306 virtual void printList(StringRef Label, const ArrayRef<APSInt> List) {
307 printListImpl(Label, List);
308 }
309
310 template <typename T, typename U>
311 void printList(StringRef Label, const T &List, const U &Printer) {
312 startLine() << Label << ": [";
313 ListSeparator LS;
314 for (const auto &Item : List) {
315 OS << LS;
316 Printer(OS, Item);
317 }
318 OS << "]\n";
319 }
320
321 template <typename T> void printHexList(StringRef Label, const T &List) {
323 for (const auto &Item : List)
324 HexList.emplace_back(Item);
325 printHexListImpl(Label, HexList);
326 }
327
328 template <typename T> void printHex(StringRef Label, T Value) {
329 printHexImpl(Label, hex(Value));
330 }
331
332 template <typename T> void printHex(StringRef Label, StringRef Str, T Value) {
333 printHexImpl(Label, Str, hex(Value));
334 }
335
336 template <typename T>
338 printSymbolOffsetImpl(Label, Symbol, hex(Value));
339 }
340
341 virtual void printString(StringRef Value) { startLine() << Value << "\n"; }
342
343 virtual void printString(StringRef Label, StringRef Value) {
344 startLine() << Label << ": " << Value << "\n";
345 }
346
348 printStringEscapedImpl(Label, Value);
349 }
350
352 printBinaryImpl(Label, Str, Value, false);
353 }
354
356 auto V =
357 ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
358 printBinaryImpl(Label, Str, V, false);
359 }
360
362 printBinaryImpl(Label, StringRef(), Value, false);
363 }
364
366 auto V =
367 ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
368 printBinaryImpl(Label, StringRef(), V, false);
369 }
370
372 auto V =
373 ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
374 printBinaryImpl(Label, StringRef(), V, false);
375 }
376
378 uint32_t StartOffset) {
379 printBinaryImpl(Label, StringRef(), Value, true, StartOffset);
380 }
381
383 printBinaryImpl(Label, StringRef(), Value, true);
384 }
385
387 auto V =
388 ArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), Value.size());
389 printBinaryImpl(Label, StringRef(), V, true);
390 }
391
392 template <typename T> void printObject(StringRef Label, const T &Value) {
393 printString(Label, to_string(Value));
394 }
395
396 virtual void objectBegin() { scopedBegin('{'); }
397
398 virtual void objectBegin(StringRef Label) { scopedBegin(Label, '{'); }
399
400 virtual void objectEnd() { scopedEnd('}'); }
401
402 virtual void arrayBegin() { scopedBegin('['); }
403
404 virtual void arrayBegin(StringRef Label) { scopedBegin(Label, '['); }
405
406 virtual void arrayEnd() { scopedEnd(']'); }
407
409 printIndent();
410 return OS;
411 }
412
413 virtual raw_ostream &getOStream() { return OS; }
414
415private:
416 template <typename T> void printVersionInternal(T Value) {
417 getOStream() << Value;
418 }
419
420 template <typename S, typename T, typename... TArgs>
421 void printVersionInternal(S Value, T Value2, TArgs... Args) {
422 getOStream() << Value << ".";
423 printVersionInternal(Value2, Args...);
424 }
425
426 static bool flagName(const FlagEntry &LHS, const FlagEntry &RHS) {
427 return LHS.Name < RHS.Name;
428 }
429
430 virtual void printBinaryImpl(StringRef Label, StringRef Str,
431 ArrayRef<uint8_t> Value, bool Block,
432 uint32_t StartOffset = 0);
433
434 virtual void printFlagsImpl(StringRef Label, HexNumber Value,
435 ArrayRef<FlagEntry> Flags) {
436 startLine() << Label << " [ (" << Value << ")\n";
437 for (const auto &Flag : Flags)
438 startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
439 startLine() << "]\n";
440 }
441
442 virtual void printFlagsImpl(StringRef Label, HexNumber Value,
443 ArrayRef<HexNumber> Flags) {
444 startLine() << Label << " [ (" << Value << ")\n";
445 for (const auto &Flag : Flags)
446 startLine() << " " << Flag << '\n';
447 startLine() << "]\n";
448 }
449
450 template <typename T> void printListImpl(StringRef Label, const T List) {
451 startLine() << Label << ": [";
452 ListSeparator LS;
453 for (const auto &Item : List)
454 OS << LS << Item;
455 OS << "]\n";
456 }
457
458 virtual void printHexListImpl(StringRef Label,
459 const ArrayRef<HexNumber> List) {
460 startLine() << Label << ": [";
461 ListSeparator LS;
462 for (const auto &Item : List)
463 OS << LS << hex(Item);
464 OS << "]\n";
465 }
466
467 virtual void printHexImpl(StringRef Label, HexNumber Value) {
468 startLine() << Label << ": " << Value << "\n";
469 }
470
471 virtual void printHexImpl(StringRef Label, StringRef Str, HexNumber Value) {
472 startLine() << Label << ": " << Str << " (" << Value << ")\n";
473 }
474
475 virtual void printSymbolOffsetImpl(StringRef Label, StringRef Symbol,
476 HexNumber Value) {
477 startLine() << Label << ": " << Symbol << '+' << Value << '\n';
478 }
479
480 virtual void printNumberImpl(StringRef Label, StringRef Str,
481 StringRef Value) {
482 startLine() << Label << ": " << Str << " (" << Value << ")\n";
483 }
484
485 virtual void printStringEscapedImpl(StringRef Label, StringRef Value) {
486 startLine() << Label << ": ";
487 OS.write_escaped(Value);
488 OS << '\n';
489 }
490
491 void scopedBegin(char Symbol) {
492 startLine() << Symbol << '\n';
493 indent();
494 }
495
496 void scopedBegin(StringRef Label, char Symbol) {
497 startLine() << Label;
498 if (!Label.empty())
499 OS << ' ';
500 OS << Symbol << '\n';
501 indent();
502 }
503
504 void scopedEnd(char Symbol) {
505 unindent();
506 startLine() << Symbol << '\n';
507 }
508
509 raw_ostream &OS;
510 int IndentLevel = 0;
511 StringRef Prefix;
513};
514
515template <>
516inline void
517ScopedPrinter::printHex<support::ulittle16_t>(StringRef Label,
519 startLine() << Label << ": " << hex(Value) << "\n";
520}
521
522struct DelimitedScope;
523
525private:
526 enum class Scope {
527 Array,
528 Object,
529 };
530
531 enum class ScopeKind {
532 NoAttribute,
533 Attribute,
534 NestedAttribute,
535 };
536
537 struct ScopeContext {
538 Scope Context;
539 ScopeKind Kind;
540 ScopeContext(Scope Context, ScopeKind Kind = ScopeKind::NoAttribute)
541 : Context(Context), Kind(Kind) {}
542 };
543
544 SmallVector<ScopeContext, 8> ScopeHistory;
545 json::OStream JOS;
546 std::unique_ptr<DelimitedScope> OuterScope;
547
548public:
549 JSONScopedPrinter(raw_ostream &OS, bool PrettyPrint = false,
550 std::unique_ptr<DelimitedScope> &&OuterScope =
551 std::unique_ptr<DelimitedScope>{});
552
553 static bool classof(const ScopedPrinter *SP) {
555 }
556
557 void printNumber(StringRef Label, uint64_t Value) override {
558 JOS.attribute(Label, Value);
559 }
560
561 void printNumber(StringRef Label, uint32_t Value) override {
562 JOS.attribute(Label, Value);
563 }
564
565 void printNumber(StringRef Label, uint16_t Value) override {
566 JOS.attribute(Label, Value);
567 }
568
569 void printNumber(StringRef Label, uint8_t Value) override {
570 JOS.attribute(Label, Value);
571 }
572
573 void printNumber(StringRef Label, int64_t Value) override {
574 JOS.attribute(Label, Value);
575 }
576
577 void printNumber(StringRef Label, int32_t Value) override {
578 JOS.attribute(Label, Value);
579 }
580
581 void printNumber(StringRef Label, int16_t Value) override {
582 JOS.attribute(Label, Value);
583 }
584
585 void printNumber(StringRef Label, int8_t Value) override {
586 JOS.attribute(Label, Value);
587 }
588
589 void printNumber(StringRef Label, const APSInt &Value) override {
590 JOS.attributeBegin(Label);
591 printAPSInt(Value);
592 JOS.attributeEnd();
593 }
594
595 void printBoolean(StringRef Label, bool Value) override {
596 JOS.attribute(Label, Value);
597 }
598
599 void printList(StringRef Label, const ArrayRef<bool> List) override {
600 printListImpl(Label, List);
601 }
602
603 void printList(StringRef Label, const ArrayRef<std::string> List) override {
604 printListImpl(Label, List);
605 }
606
607 void printList(StringRef Label, const ArrayRef<uint64_t> List) override {
608 printListImpl(Label, List);
609 }
610
611 void printList(StringRef Label, const ArrayRef<uint32_t> List) override {
612 printListImpl(Label, List);
613 }
614
615 void printList(StringRef Label, const ArrayRef<uint16_t> List) override {
616 printListImpl(Label, List);
617 }
618
619 void printList(StringRef Label, const ArrayRef<uint8_t> List) override {
620 printListImpl(Label, List);
621 }
622
623 void printList(StringRef Label, const ArrayRef<int64_t> List) override {
624 printListImpl(Label, List);
625 }
626
627 void printList(StringRef Label, const ArrayRef<int32_t> List) override {
628 printListImpl(Label, List);
629 }
630
631 void printList(StringRef Label, const ArrayRef<int16_t> List) override {
632 printListImpl(Label, List);
633 }
634
635 void printList(StringRef Label, const ArrayRef<int8_t> List) override {
636 printListImpl(Label, List);
637 }
638
639 void printList(StringRef Label, const ArrayRef<APSInt> List) override {
640 JOS.attributeArray(Label, [&]() {
641 for (const APSInt &Item : List) {
642 printAPSInt(Item);
643 }
644 });
645 }
646
647 void printString(StringRef Value) override { JOS.value(Value); }
648
649 void printString(StringRef Label, StringRef Value) override {
650 JOS.attribute(Label, Value);
651 }
652
653 void objectBegin() override {
654 scopedBegin({Scope::Object, ScopeKind::NoAttribute});
655 }
656
657 void objectBegin(StringRef Label) override {
658 scopedBegin(Label, Scope::Object);
659 }
660
661 void objectEnd() override { scopedEnd(); }
662
663 void arrayBegin() override {
664 scopedBegin({Scope::Array, ScopeKind::NoAttribute});
665 }
666
667 void arrayBegin(StringRef Label) override {
668 scopedBegin(Label, Scope::Array);
669 }
670
671 void arrayEnd() override { scopedEnd(); }
672
673private:
674 // Output HexNumbers as decimals so that they're easier to parse.
675 uint64_t hexNumberToInt(HexNumber Hex) { return Hex.Value; }
676
677 void printAPSInt(const APSInt &Value) {
678 JOS.rawValueBegin() << Value;
679 JOS.rawValueEnd();
680 }
681
682 void printFlagsImpl(StringRef Label, HexNumber Value,
683 ArrayRef<FlagEntry> Flags) override {
684 JOS.attributeObject(Label, [&]() {
685 JOS.attribute("RawFlags", hexNumberToInt(Value));
686 JOS.attributeArray("Flags", [&]() {
687 for (const FlagEntry &Flag : Flags) {
688 JOS.objectBegin();
689 JOS.attribute("Name", Flag.Name);
690 JOS.attribute("Value", Flag.Value);
691 JOS.objectEnd();
692 }
693 });
694 });
695 }
696
697 void printFlagsImpl(StringRef Label, HexNumber Value,
698 ArrayRef<HexNumber> Flags) override {
699 JOS.attributeObject(Label, [&]() {
700 JOS.attribute("RawFlags", hexNumberToInt(Value));
701 JOS.attributeArray("Flags", [&]() {
702 for (const HexNumber &Flag : Flags) {
703 JOS.value(Flag.Value);
704 }
705 });
706 });
707 }
708
709 template <typename T> void printListImpl(StringRef Label, const T &List) {
710 JOS.attributeArray(Label, [&]() {
711 for (const auto &Item : List)
712 JOS.value(Item);
713 });
714 }
715
716 void printHexListImpl(StringRef Label,
717 const ArrayRef<HexNumber> List) override {
718 JOS.attributeArray(Label, [&]() {
719 for (const HexNumber &Item : List) {
720 JOS.value(hexNumberToInt(Item));
721 }
722 });
723 }
724
725 void printHexImpl(StringRef Label, HexNumber Value) override {
726 JOS.attribute(Label, hexNumberToInt(Value));
727 }
728
729 void printHexImpl(StringRef Label, StringRef Str, HexNumber Value) override {
730 JOS.attributeObject(Label, [&]() {
731 JOS.attribute("Value", Str);
732 JOS.attribute("RawValue", hexNumberToInt(Value));
733 });
734 }
735
736 void printSymbolOffsetImpl(StringRef Label, StringRef Symbol,
737 HexNumber Value) override {
738 JOS.attributeObject(Label, [&]() {
739 JOS.attribute("SymName", Symbol);
740 JOS.attribute("Offset", hexNumberToInt(Value));
741 });
742 }
743
744 void printNumberImpl(StringRef Label, StringRef Str,
745 StringRef Value) override {
746 JOS.attributeObject(Label, [&]() {
747 JOS.attribute("Value", Str);
748 JOS.attributeBegin("RawValue");
749 JOS.rawValueBegin() << Value;
750 JOS.rawValueEnd();
751 JOS.attributeEnd();
752 });
753 }
754
755 void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
756 bool Block, uint32_t StartOffset = 0) override {
757 JOS.attributeObject(Label, [&]() {
758 if (!Str.empty())
759 JOS.attribute("Value", Str);
760 JOS.attribute("Offset", StartOffset);
761 JOS.attributeArray("Bytes", [&]() {
762 for (uint8_t Val : Value)
763 JOS.value(Val);
764 });
765 });
766 }
767
768 void scopedBegin(ScopeContext ScopeCtx) {
769 if (ScopeCtx.Context == Scope::Object)
770 JOS.objectBegin();
771 else if (ScopeCtx.Context == Scope::Array)
772 JOS.arrayBegin();
773 ScopeHistory.push_back(ScopeCtx);
774 }
775
776 void scopedBegin(StringRef Label, Scope Ctx) {
777 ScopeKind Kind = ScopeKind::Attribute;
778 if (ScopeHistory.empty() || ScopeHistory.back().Context != Scope::Object) {
779 JOS.objectBegin();
780 Kind = ScopeKind::NestedAttribute;
781 }
782 JOS.attributeBegin(Label);
783 scopedBegin({Ctx, Kind});
784 }
785
786 void scopedEnd() {
787 ScopeContext ScopeCtx = ScopeHistory.back();
788 if (ScopeCtx.Context == Scope::Object)
789 JOS.objectEnd();
790 else if (ScopeCtx.Context == Scope::Array)
791 JOS.arrayEnd();
792 if (ScopeCtx.Kind == ScopeKind::Attribute ||
793 ScopeCtx.Kind == ScopeKind::NestedAttribute)
794 JOS.attributeEnd();
795 if (ScopeCtx.Kind == ScopeKind::NestedAttribute)
796 JOS.objectEnd();
797 ScopeHistory.pop_back();
798 }
799};
800
803 DelimitedScope() : W(nullptr) {}
804 virtual ~DelimitedScope() = default;
805 virtual void setPrinter(ScopedPrinter &W) = 0;
807};
808
810 explicit DictScope() = default;
812
814 W.objectBegin(N);
815 }
816
817 void setPrinter(ScopedPrinter &W) override {
818 this->W = &W;
819 W.objectBegin();
820 }
821
823 if (W)
824 W->objectEnd();
825 }
826};
827
829 explicit ListScope() = default;
831
833 W.arrayBegin(N);
834 }
835
836 void setPrinter(ScopedPrinter &W) override {
837 this->W = &W;
838 W.arrayBegin();
839 }
840
842 if (W)
843 W->arrayEnd();
844 }
845};
846
847} // namespace llvm
848
849#endif
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
std::string Name
This file supports working with JSON data.
Memory true print Memory SSA Printer
Definition: MemorySSA.cpp:78
#define T
LLVMContext & Context
#define P(N)
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
Value * RHS
Value * LHS
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:23
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
void printList(StringRef Label, const ArrayRef< std::string > List) override
void printNumber(StringRef Label, int32_t Value) override
void printList(StringRef Label, const ArrayRef< uint8_t > List) override
void printNumber(StringRef Label, int8_t Value) override
void printList(StringRef Label, const ArrayRef< int32_t > List) override
void printNumber(StringRef Label, uint64_t Value) override
void printBoolean(StringRef Label, bool Value) override
void printList(StringRef Label, const ArrayRef< int64_t > List) override
void printList(StringRef Label, const ArrayRef< bool > List) override
void arrayBegin() override
void printList(StringRef Label, const ArrayRef< APSInt > List) override
void printNumber(StringRef Label, int64_t Value) override
void printList(StringRef Label, const ArrayRef< uint64_t > List) override
void printList(StringRef Label, const ArrayRef< uint16_t > List) override
void printList(StringRef Label, const ArrayRef< int16_t > List) override
void printNumber(StringRef Label, uint8_t Value) override
void objectEnd() override
void printNumber(StringRef Label, uint16_t Value) override
void printNumber(StringRef Label, int16_t Value) override
static bool classof(const ScopedPrinter *SP)
void printNumber(StringRef Label, const APSInt &Value) override
void printList(StringRef Label, const ArrayRef< uint32_t > List) override
void arrayBegin(StringRef Label) override
void arrayEnd() override
void printNumber(StringRef Label, uint32_t Value) override
void printString(StringRef Value) override
void objectBegin(StringRef Label) override
void printString(StringRef Label, StringRef Value) override
void printList(StringRef Label, const ArrayRef< int8_t > List) override
void objectBegin() override
virtual void printList(StringRef Label, const ArrayRef< int32_t > List)
void printHexList(StringRef Label, const T &List)
virtual void printNumber(StringRef Label, int32_t Value)
virtual void printList(StringRef Label, const ArrayRef< uint32_t > List)
virtual void printNumber(StringRef Label, uint8_t Value)
void printBinary(StringRef Label, StringRef Str, ArrayRef< char > Value)
virtual void printString(StringRef Value)
void printBinaryBlock(StringRef Label, ArrayRef< uint8_t > Value, uint32_t StartOffset)
void printStringEscaped(StringRef Label, StringRef Value)
void printBinaryBlock(StringRef Label, StringRef Value)
virtual void arrayEnd()
virtual void printList(StringRef Label, const ArrayRef< int64_t > List)
void indent(int Levels=1)
virtual void printList(StringRef Label, const ArrayRef< int16_t > List)
void printFlags(StringRef Label, T Value)
virtual void printList(StringRef Label, const ArrayRef< std::string > List)
virtual void printNumber(StringRef Label, uint16_t Value)
virtual void printNumber(StringRef Label, int8_t Value)
void unindent(int Levels=1)
void printBinaryBlock(StringRef Label, ArrayRef< uint8_t > Value)
virtual void arrayBegin(StringRef Label)
void printEnum(StringRef Label, T Value, ArrayRef< EnumEntry< TEnum > > EnumValues)
virtual void printList(StringRef Label, const ArrayRef< bool > List)
virtual void printList(StringRef Label, const ArrayRef< APSInt > List)
void printVersion(StringRef Label, T... Version)
ScopedPrinterKind getKind() const
virtual void printNumber(StringRef Label, const APSInt &Value)
ScopedPrinter(raw_ostream &OS, ScopedPrinterKind Kind=ScopedPrinterKind::Base)
HexNumber hex(T Value)
void printFlags(StringRef Label, T Value, ArrayRef< EnumEntry< TFlag > > Flags, TFlag EnumMask1={}, TFlag EnumMask2={}, TFlag EnumMask3={})
void printList(StringRef Label, const T &List, const U &Printer)
void printBinary(StringRef Label, StringRef Value)
virtual raw_ostream & getOStream()
virtual void printList(StringRef Label, const ArrayRef< int8_t > List)
static bool classof(const ScopedPrinter *SP)
virtual raw_ostream & startLine()
void printBinary(StringRef Label, StringRef Str, ArrayRef< uint8_t > Value)
virtual void printList(StringRef Label, const ArrayRef< uint64_t > List)
void printHex(StringRef Label, T Value)
virtual void objectBegin(StringRef Label)
virtual void printNumber(StringRef Label, int64_t Value)
void setPrefix(StringRef P)
virtual void objectEnd()
virtual ~ScopedPrinter()=default
virtual void arrayBegin()
virtual void printBoolean(StringRef Label, bool Value)
void printHex(StringRef Label, StringRef Str, T Value)
void printNumber(StringRef Label, StringRef Str, T Value)
virtual void objectBegin()
virtual void printList(StringRef Label, const ArrayRef< uint16_t > List)
virtual void printString(StringRef Label, StringRef Value)
virtual void printList(StringRef Label, const ArrayRef< uint8_t > List)
void printSymbolOffset(StringRef Label, StringRef Symbol, T Value)
virtual void printNumber(StringRef Label, int16_t Value)
void printBinary(StringRef Label, ArrayRef< char > Value)
virtual void printNumber(StringRef Label, uint32_t Value)
void printList(StringRef Label, const ArrayRef< T > List)
void printBinary(StringRef Label, ArrayRef< uint8_t > Value)
virtual void printNumber(StringRef Label, uint64_t Value)
void printObject(StringRef Label, const T &Value)
bool empty() const
Definition: SmallVector.h:94
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:941
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
LLVM Value Representation.
Definition: Value.h:74
json::OStream allows writing well-formed JSON without materializing all structures as json::Value ahe...
Definition: JSON.h:956
void attributeObject(llvm::StringRef Key, Block Contents)
Emit an attribute whose value is an object with attributes from the Block.
Definition: JSON.h:1019
void attributeBegin(llvm::StringRef Key)
Definition: JSON.cpp:880
void attribute(llvm::StringRef Key, const Value &Contents)
Emit an attribute whose value is self-contained (number, vector<int> etc).
Definition: JSON.h:1011
void arrayBegin()
Definition: JSON.cpp:842
void objectBegin()
Definition: JSON.cpp:861
raw_ostream & rawValueBegin()
Definition: JSON.cpp:908
void attributeArray(llvm::StringRef Key, Block Contents)
Emit an attribute whose value is an array with elements from the Block.
Definition: JSON.h:1015
void attributeEnd()
Definition: JSON.cpp:900
void value(const Value &V)
Emit a self-contained value (number, string, vector<string> etc).
Definition: JSON.cpp:756
void rawValueEnd()
Definition: JSON.cpp:915
void objectEnd()
Definition: JSON.cpp:869
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
std::string & str()
Returns the string's reference.
Definition: raw_ostream.h:660
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:148
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:85
std::string enumToString(T Value, ArrayRef< EnumEntry< TEnum > > EnumValues)
Definition: ScopedPrinter.h:93
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1683
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292
#define N
virtual void setPrinter(ScopedPrinter &W)=0
DelimitedScope(ScopedPrinter &W)
ScopedPrinter * W
virtual ~DelimitedScope()=default
DictScope(ScopedPrinter &W)
DictScope()=default
DictScope(ScopedPrinter &W, StringRef N)
void setPrinter(ScopedPrinter &W) override
constexpr EnumEntry(StringRef N, StringRef A, T V)
Definition: ScopedPrinter.h:35
StringRef AltName
Definition: ScopedPrinter.h:33
StringRef Name
Definition: ScopedPrinter.h:25
constexpr EnumEntry(StringRef N, T V)
Definition: ScopedPrinter.h:37
FlagEntry(StringRef Name, signed long Value)
Definition: ScopedPrinter.h:69
FlagEntry(StringRef Name, signed int Value)
Definition: ScopedPrinter.h:67
FlagEntry(StringRef Name, unsigned short Value)
Definition: ScopedPrinter.h:74
FlagEntry(StringRef Name, unsigned long long Value)
Definition: ScopedPrinter.h:77
FlagEntry(StringRef Name, unsigned long Value)
Definition: ScopedPrinter.h:76
FlagEntry(StringRef Name, signed long long Value)
Definition: ScopedPrinter.h:71
FlagEntry(StringRef Name, char Value)
Definition: ScopedPrinter.h:61
FlagEntry(StringRef Name, signed char Value)
Definition: ScopedPrinter.h:63
FlagEntry(StringRef Name, signed short Value)
Definition: ScopedPrinter.h:65
FlagEntry(StringRef Name, unsigned int Value)
Definition: ScopedPrinter.h:75
FlagEntry(StringRef Name, unsigned char Value)
Definition: ScopedPrinter.h:73
StringRef Name
Definition: ScopedPrinter.h:79
HexNumber(unsigned char Value)
Definition: ScopedPrinter.h:52
HexNumber(signed int Value)
Definition: ScopedPrinter.h:48
HexNumber(signed long long Value)
Definition: ScopedPrinter.h:50
HexNumber(char Value)
Definition: ScopedPrinter.h:45
HexNumber(signed long Value)
Definition: ScopedPrinter.h:49
HexNumber(unsigned int Value)
Definition: ScopedPrinter.h:54
HexNumber(unsigned long long Value)
Definition: ScopedPrinter.h:56
HexNumber(signed char Value)
Definition: ScopedPrinter.h:46
HexNumber(signed short Value)
Definition: ScopedPrinter.h:47
HexNumber(unsigned long Value)
Definition: ScopedPrinter.h:55
HexNumber(unsigned short Value)
Definition: ScopedPrinter.h:53
ListScope(ScopedPrinter &W)
ListScope()=default
void setPrinter(ScopedPrinter &W) override
ListScope(ScopedPrinter &W, StringRef N)