/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/ScopedPrinter.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- ScopedPrinter.h ---------------------------------------------------===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | |
10 | | #ifndef LLVM_SUPPORT_SCOPEDPRINTER_H |
11 | | #define LLVM_SUPPORT_SCOPEDPRINTER_H |
12 | | |
13 | | #include "llvm/ADT/APSInt.h" |
14 | | #include "llvm/ADT/ArrayRef.h" |
15 | | #include "llvm/ADT/SmallVector.h" |
16 | | #include "llvm/ADT/StringRef.h" |
17 | | #include "llvm/Support/DataTypes.h" |
18 | | #include "llvm/Support/Endian.h" |
19 | | #include "llvm/Support/raw_ostream.h" |
20 | | #include <algorithm> |
21 | | |
22 | | namespace llvm { |
23 | | |
24 | | template <typename T> struct EnumEntry { |
25 | | StringRef Name; |
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 |
33 | | StringRef AltName; |
34 | | T Value; |
35 | | EnumEntry(StringRef N, StringRef A, T V) : Name(N), AltName(A), Value(V) {} |
36 | 24.6M | EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {} llvm::EnumEntry<llvm::codeview::TypeLeafKind>::EnumEntry(llvm::StringRef, llvm::codeview::TypeLeafKind) Line | Count | Source | 36 | 16.3M | EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {} |
llvm::EnumEntry<unsigned short>::EnumEntry(llvm::StringRef, unsigned short) Line | Count | Source | 36 | 3.70M | EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {} |
llvm::EnumEntry<unsigned char>::EnumEntry(llvm::StringRef, unsigned char) Line | Count | Source | 36 | 4.60M | EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {} |
|
37 | | }; |
38 | | |
39 | | struct HexNumber { |
40 | | // To avoid sign-extension we have to explicitly cast to the appropriate |
41 | | // unsigned type. The overloads are here so that every type that is implicitly |
42 | | // convertible to an integer (including enums and endian helpers) can be used |
43 | | // without requiring type traits or call-site changes. |
44 | 0 | HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {} |
45 | 0 | HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) {} |
46 | 0 | HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) {} |
47 | 1.39k | HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) {} |
48 | 0 | HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) {} |
49 | | HexNumber(signed long long Value) |
50 | 0 | : Value(static_cast<unsigned long long>(Value)) {} |
51 | 15.3k | HexNumber(unsigned char Value) : Value(Value) {} |
52 | 3.47k | HexNumber(unsigned short Value) : Value(Value) {} |
53 | 182k | HexNumber(unsigned int Value) : Value(Value) {} |
54 | 0 | HexNumber(unsigned long Value) : Value(Value) {} |
55 | 407k | HexNumber(unsigned long long Value) : Value(Value) {} |
56 | | uint64_t Value; |
57 | | }; |
58 | | |
59 | | raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value); |
60 | | const std::string to_hexString(uint64_t Value, bool UpperCase = true); |
61 | | |
62 | 7.40k | template <class T> const std::string to_string(const T &Value) { |
63 | 7.40k | std::string number; |
64 | 7.40k | llvm::raw_string_ostream stream(number); |
65 | 7.40k | stream << Value; |
66 | 7.40k | return stream.str(); |
67 | 7.40k | } |
68 | | |
69 | | class ScopedPrinter { |
70 | | public: |
71 | 2.43k | ScopedPrinter(raw_ostream &OS) : OS(OS), IndentLevel(0) {} |
72 | | |
73 | 0 | void flush() { OS.flush(); } |
74 | | |
75 | 158k | void indent(int Levels = 1) { IndentLevel += Levels; } |
76 | | |
77 | 158k | void unindent(int Levels = 1) { |
78 | 158k | IndentLevel = std::max(0, IndentLevel - Levels); |
79 | 158k | } |
80 | | |
81 | 0 | void resetIndent() { IndentLevel = 0; } |
82 | | |
83 | 215 | void setPrefix(StringRef P) { Prefix = P; } |
84 | | |
85 | 2.06M | void printIndent() { |
86 | 2.06M | OS << Prefix; |
87 | 5.93M | for (int i = 0; i < IndentLevel5.93M ; ++i3.87M ) |
88 | 3.87M | OS << " "; |
89 | 2.06M | } |
90 | | |
91 | 49.9k | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } llvm::HexNumber llvm::ScopedPrinter::hex<unsigned char>(unsigned char) Line | Count | Source | 91 | 15.3k | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } |
Unexecuted instantiation: llvm::HexNumber llvm::ScopedPrinter::hex<llvm::support::detail::packed_endian_specific_integral<unsigned short, (llvm::support::endianness)1, 1ul> >(llvm::support::detail::packed_endian_specific_integral<unsigned short, (llvm::support::endianness)1, 1ul>) llvm::HexNumber llvm::ScopedPrinter::hex<unsigned long long>(unsigned long long) Line | Count | Source | 91 | 2.40k | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } |
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned short>(unsigned short) Line | Count | Source | 91 | 2.51k | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } |
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned int>(unsigned int) Line | Count | Source | 91 | 29.6k | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } |
llvm::HexNumber llvm::ScopedPrinter::hex<int>(int) Line | Count | Source | 91 | 15 | template <typename T> HexNumber hex(T Value) { return HexNumber(Value); } |
|
92 | | |
93 | | template <typename T, typename TEnum> |
94 | | void printEnum(StringRef Label, T Value, |
95 | 16.0k | ArrayRef<EnumEntry<TEnum>> EnumValues) { |
96 | 16.0k | StringRef Name; |
97 | 16.0k | bool Found = false; |
98 | 243k | for (const auto &EnumItem : EnumValues) { |
99 | 243k | if (EnumItem.Value == Value243k ) { |
100 | 16.0k | Name = EnumItem.Name; |
101 | 16.0k | Found = true; |
102 | 16.0k | break; |
103 | 16.0k | } |
104 | 243k | } |
105 | 16.0k | |
106 | 16.0k | if (Found16.0k ) { |
107 | 16.0k | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; |
108 | 16.0k | } else { |
109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; |
110 | 0 | } |
111 | 16.0k | } void llvm::ScopedPrinter::printEnum<unsigned int, llvm::codeview::TypeLeafKind>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<llvm::codeview::TypeLeafKind> >) Line | Count | Source | 95 | 8.65k | ArrayRef<EnumEntry<TEnum>> EnumValues) { | 96 | 8.65k | StringRef Name; | 97 | 8.65k | bool Found = false; | 98 | 212k | for (const auto &EnumItem : EnumValues) { | 99 | 212k | if (EnumItem.Value == Value212k ) { | 100 | 8.65k | Name = EnumItem.Name; | 101 | 8.65k | Found = true; | 102 | 8.65k | break; | 103 | 8.65k | } | 104 | 212k | } | 105 | 8.65k | | 106 | 8.65k | if (Found8.65k ) { | 107 | 8.65k | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; | 108 | 8.65k | } else { | 109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; | 110 | 0 | } | 111 | 8.65k | } |
Unexecuted instantiation: void llvm::ScopedPrinter::printEnum<unsigned short, llvm::codeview::TypeLeafKind>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<llvm::codeview::TypeLeafKind> >) void llvm::ScopedPrinter::printEnum<unsigned int, unsigned short>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >) Line | Count | Source | 95 | 32 | ArrayRef<EnumEntry<TEnum>> EnumValues) { | 96 | 32 | StringRef Name; | 97 | 32 | bool Found = false; | 98 | 119 | for (const auto &EnumItem : EnumValues) { | 99 | 119 | if (EnumItem.Value == Value119 ) { | 100 | 32 | Name = EnumItem.Name; | 101 | 32 | Found = true; | 102 | 32 | break; | 103 | 32 | } | 104 | 119 | } | 105 | 32 | | 106 | 32 | if (Found32 ) { | 107 | 32 | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; | 108 | 32 | } else { | 109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; | 110 | 0 | } | 111 | 32 | } |
void llvm::ScopedPrinter::printEnum<unsigned short, unsigned short>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >) Line | Count | Source | 95 | 18 | ArrayRef<EnumEntry<TEnum>> EnumValues) { | 96 | 18 | StringRef Name; | 97 | 18 | bool Found = false; | 98 | 266 | for (const auto &EnumItem : EnumValues) { | 99 | 266 | if (EnumItem.Value == Value266 ) { | 100 | 18 | Name = EnumItem.Name; | 101 | 18 | Found = true; | 102 | 18 | break; | 103 | 18 | } | 104 | 266 | } | 105 | 18 | | 106 | 18 | if (Found18 ) { | 107 | 18 | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; | 108 | 18 | } else { | 109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; | 110 | 0 | } | 111 | 18 | } |
void llvm::ScopedPrinter::printEnum<unsigned char, unsigned char>(llvm::StringRef, unsigned char, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >) Line | Count | Source | 95 | 6.94k | ArrayRef<EnumEntry<TEnum>> EnumValues) { | 96 | 6.94k | StringRef Name; | 97 | 6.94k | bool Found = false; | 98 | 27.4k | for (const auto &EnumItem : EnumValues) { | 99 | 27.4k | if (EnumItem.Value == Value27.4k ) { | 100 | 6.94k | Name = EnumItem.Name; | 101 | 6.94k | Found = true; | 102 | 6.94k | break; | 103 | 6.94k | } | 104 | 27.4k | } | 105 | 6.94k | | 106 | 6.94k | if (Found6.94k ) { | 107 | 6.94k | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; | 108 | 6.94k | } else { | 109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; | 110 | 0 | } | 111 | 6.94k | } |
void llvm::ScopedPrinter::printEnum<unsigned int, unsigned char>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >) Line | Count | Source | 95 | 438 | ArrayRef<EnumEntry<TEnum>> EnumValues) { | 96 | 438 | StringRef Name; | 97 | 438 | bool Found = false; | 98 | 2.95k | for (const auto &EnumItem : EnumValues) { | 99 | 2.95k | if (EnumItem.Value == Value2.95k ) { | 100 | 438 | Name = EnumItem.Name; | 101 | 438 | Found = true; | 102 | 438 | break; | 103 | 438 | } | 104 | 2.95k | } | 105 | 438 | | 106 | 438 | if (Found438 ) { | 107 | 438 | startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n"; | 108 | 438 | } else { | 109 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; | 110 | 0 | } | 111 | 438 | } |
|
112 | | |
113 | | template <typename T, typename TFlag> |
114 | | void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag>> Flags, |
115 | | TFlag EnumMask1 = {}, TFlag EnumMask2 = {}, |
116 | 1.00k | TFlag EnumMask3 = {}) { |
117 | 1.00k | typedef EnumEntry<TFlag> FlagEntry; |
118 | 1.00k | typedef SmallVector<FlagEntry, 10> FlagVector; |
119 | 1.00k | FlagVector SetFlags; |
120 | 1.00k | |
121 | 7.73k | for (const auto &Flag : Flags) { |
122 | 7.73k | if (Flag.Value == 0) |
123 | 0 | continue; |
124 | 7.73k | |
125 | 7.73k | TFlag EnumMask{}; |
126 | 7.73k | if (Flag.Value & EnumMask1) |
127 | 0 | EnumMask = EnumMask1; |
128 | 7.73k | else if (7.73k Flag.Value & EnumMask27.73k ) |
129 | 0 | EnumMask = EnumMask2; |
130 | 7.73k | else if (7.73k Flag.Value & EnumMask37.73k ) |
131 | 0 | EnumMask = EnumMask3; |
132 | 7.73k | bool IsEnum = (Flag.Value & EnumMask) != 0; |
133 | 7.73k | if ((!IsEnum && 7.73k (Value & Flag.Value) == Flag.Value7.73k ) || |
134 | 7.73k | (IsEnum && 6.79k (Value & EnumMask) == Flag.Value0 )) { |
135 | 938 | SetFlags.push_back(Flag); |
136 | 938 | } |
137 | 7.73k | } |
138 | 1.00k | |
139 | 1.00k | std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>); |
140 | 1.00k | |
141 | 1.00k | startLine() << Label << " [ (" << hex(Value) << ")\n"; |
142 | 938 | for (const auto &Flag : SetFlags) { |
143 | 938 | startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n"; |
144 | 938 | } |
145 | 1.00k | startLine() << "]\n"; |
146 | 1.00k | } void llvm::ScopedPrinter::printFlags<unsigned int, unsigned short>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >, unsigned short, unsigned short, unsigned short) Line | Count | Source | 116 | 45 | TFlag EnumMask3 = {}) { | 117 | 45 | typedef EnumEntry<TFlag> FlagEntry; | 118 | 45 | typedef SmallVector<FlagEntry, 10> FlagVector; | 119 | 45 | FlagVector SetFlags; | 120 | 45 | | 121 | 225 | for (const auto &Flag : Flags) { | 122 | 225 | if (Flag.Value == 0) | 123 | 0 | continue; | 124 | 225 | | 125 | 225 | TFlag EnumMask{}; | 126 | 225 | if (Flag.Value & EnumMask1) | 127 | 0 | EnumMask = EnumMask1; | 128 | 225 | else if (225 Flag.Value & EnumMask2225 ) | 129 | 0 | EnumMask = EnumMask2; | 130 | 225 | else if (225 Flag.Value & EnumMask3225 ) | 131 | 0 | EnumMask = EnumMask3; | 132 | 225 | bool IsEnum = (Flag.Value & EnumMask) != 0; | 133 | 225 | if ((!IsEnum && 225 (Value & Flag.Value) == Flag.Value225 ) || | 134 | 225 | (IsEnum && 180 (Value & EnumMask) == Flag.Value0 )) { | 135 | 45 | SetFlags.push_back(Flag); | 136 | 45 | } | 137 | 225 | } | 138 | 45 | | 139 | 45 | std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>); | 140 | 45 | | 141 | 45 | startLine() << Label << " [ (" << hex(Value) << ")\n"; | 142 | 45 | for (const auto &Flag : SetFlags) { | 143 | 45 | startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n"; | 144 | 45 | } | 145 | 45 | startLine() << "]\n"; | 146 | 45 | } |
void llvm::ScopedPrinter::printFlags<unsigned short, unsigned short>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >, unsigned short, unsigned short, unsigned short) Line | Count | Source | 116 | 500 | TFlag EnumMask3 = {}) { | 117 | 500 | typedef EnumEntry<TFlag> FlagEntry; | 118 | 500 | typedef SmallVector<FlagEntry, 10> FlagVector; | 119 | 500 | FlagVector SetFlags; | 120 | 500 | | 121 | 5.47k | for (const auto &Flag : Flags) { | 122 | 5.47k | if (Flag.Value == 0) | 123 | 0 | continue; | 124 | 5.47k | | 125 | 5.47k | TFlag EnumMask{}; | 126 | 5.47k | if (Flag.Value & EnumMask1) | 127 | 0 | EnumMask = EnumMask1; | 128 | 5.47k | else if (5.47k Flag.Value & EnumMask25.47k ) | 129 | 0 | EnumMask = EnumMask2; | 130 | 5.47k | else if (5.47k Flag.Value & EnumMask35.47k ) | 131 | 0 | EnumMask = EnumMask3; | 132 | 5.47k | bool IsEnum = (Flag.Value & EnumMask) != 0; | 133 | 5.47k | if ((!IsEnum && 5.47k (Value & Flag.Value) == Flag.Value5.47k ) || | 134 | 5.47k | (IsEnum && 4.72k (Value & EnumMask) == Flag.Value0 )) { | 135 | 748 | SetFlags.push_back(Flag); | 136 | 748 | } | 137 | 5.47k | } | 138 | 500 | | 139 | 500 | std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>); | 140 | 500 | | 141 | 500 | startLine() << Label << " [ (" << hex(Value) << ")\n"; | 142 | 748 | for (const auto &Flag : SetFlags) { | 143 | 748 | startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n"; | 144 | 748 | } | 145 | 500 | startLine() << "]\n"; | 146 | 500 | } |
void llvm::ScopedPrinter::printFlags<unsigned char, unsigned char>(llvm::StringRef, unsigned char, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >, unsigned char, unsigned char, unsigned char) Line | Count | Source | 116 | 458 | TFlag EnumMask3 = {}) { | 117 | 458 | typedef EnumEntry<TFlag> FlagEntry; | 118 | 458 | typedef SmallVector<FlagEntry, 10> FlagVector; | 119 | 458 | FlagVector SetFlags; | 120 | 458 | | 121 | 2.02k | for (const auto &Flag : Flags) { | 122 | 2.02k | if (Flag.Value == 0) | 123 | 0 | continue; | 124 | 2.02k | | 125 | 2.02k | TFlag EnumMask{}; | 126 | 2.02k | if (Flag.Value & EnumMask1) | 127 | 0 | EnumMask = EnumMask1; | 128 | 2.02k | else if (2.02k Flag.Value & EnumMask22.02k ) | 129 | 0 | EnumMask = EnumMask2; | 130 | 2.02k | else if (2.02k Flag.Value & EnumMask32.02k ) | 131 | 0 | EnumMask = EnumMask3; | 132 | 2.02k | bool IsEnum = (Flag.Value & EnumMask) != 0; | 133 | 2.02k | if ((!IsEnum && 2.02k (Value & Flag.Value) == Flag.Value2.02k ) || | 134 | 2.02k | (IsEnum && 1.88k (Value & EnumMask) == Flag.Value0 )) { | 135 | 145 | SetFlags.push_back(Flag); | 136 | 145 | } | 137 | 2.02k | } | 138 | 458 | | 139 | 458 | std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>); | 140 | 458 | | 141 | 458 | startLine() << Label << " [ (" << hex(Value) << ")\n"; | 142 | 145 | for (const auto &Flag : SetFlags) { | 143 | 145 | startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n"; | 144 | 145 | } | 145 | 458 | startLine() << "]\n"; | 146 | 458 | } |
|
147 | | |
148 | | template <typename T> void printFlags(StringRef Label, T Value) { |
149 | | startLine() << Label << " [ (" << hex(Value) << ")\n"; |
150 | | uint64_t Flag = 1; |
151 | | uint64_t Curr = Value; |
152 | | while (Curr > 0) { |
153 | | if (Curr & 1) |
154 | | startLine() << " " << hex(Flag) << "\n"; |
155 | | Curr >>= 1; |
156 | | Flag <<= 1; |
157 | | } |
158 | | startLine() << "]\n"; |
159 | | } |
160 | | |
161 | 403k | void printNumber(StringRef Label, uint64_t Value) { |
162 | 403k | startLine() << Label << ": " << Value << "\n"; |
163 | 403k | } |
164 | | |
165 | 284k | void printNumber(StringRef Label, uint32_t Value) { |
166 | 284k | startLine() << Label << ": " << Value << "\n"; |
167 | 284k | } |
168 | | |
169 | 6.13k | void printNumber(StringRef Label, uint16_t Value) { |
170 | 6.13k | startLine() << Label << ": " << Value << "\n"; |
171 | 6.13k | } |
172 | | |
173 | 1.42k | void printNumber(StringRef Label, uint8_t Value) { |
174 | 1.42k | startLine() << Label << ": " << unsigned(Value) << "\n"; |
175 | 1.42k | } |
176 | | |
177 | 0 | void printNumber(StringRef Label, int64_t Value) { |
178 | 0 | startLine() << Label << ": " << Value << "\n"; |
179 | 0 | } |
180 | | |
181 | 139k | void printNumber(StringRef Label, int32_t Value) { |
182 | 139k | startLine() << Label << ": " << Value << "\n"; |
183 | 139k | } |
184 | | |
185 | 0 | void printNumber(StringRef Label, int16_t Value) { |
186 | 0 | startLine() << Label << ": " << Value << "\n"; |
187 | 0 | } |
188 | | |
189 | 0 | void printNumber(StringRef Label, int8_t Value) { |
190 | 0 | startLine() << Label << ": " << int(Value) << "\n"; |
191 | 0 | } |
192 | | |
193 | 6.03k | void printNumber(StringRef Label, const APSInt &Value) { |
194 | 6.03k | startLine() << Label << ": " << Value << "\n"; |
195 | 6.03k | } |
196 | | |
197 | | void printBoolean(StringRef Label, bool Value) { |
198 | | startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n'; |
199 | | } |
200 | | |
201 | | template <typename... T> void printVersion(StringRef Label, T... Version) { |
202 | | startLine() << Label << ": "; |
203 | | printVersionInternal(Version...); |
204 | | getOStream() << "\n"; |
205 | | } |
206 | | |
207 | | template <typename T> void printList(StringRef Label, const T &List) { |
208 | | startLine() << Label << ": ["; |
209 | | bool Comma = false; |
210 | | for (const auto &Item : List) { |
211 | | if (Comma) |
212 | | OS << ", "; |
213 | | OS << Item; |
214 | | Comma = true; |
215 | | } |
216 | | OS << "]\n"; |
217 | | } |
218 | | |
219 | | template <typename T, typename U> |
220 | | void printList(StringRef Label, const T &List, const U &Printer) { |
221 | | startLine() << Label << ": ["; |
222 | | bool Comma = false; |
223 | | for (const auto &Item : List) { |
224 | | if (Comma) |
225 | | OS << ", "; |
226 | | Printer(OS, Item); |
227 | | Comma = true; |
228 | | } |
229 | | OS << "]\n"; |
230 | | } |
231 | | |
232 | | template <typename T> void printHexList(StringRef Label, const T &List) { |
233 | | startLine() << Label << ": ["; |
234 | | bool Comma = false; |
235 | | for (const auto &Item : List) { |
236 | | if (Comma) |
237 | | OS << ", "; |
238 | | OS << hex(Item); |
239 | | Comma = true; |
240 | | } |
241 | | OS << "]\n"; |
242 | | } |
243 | | |
244 | 7.41k | template <typename T> void printHex(StringRef Label, T Value) { |
245 | 7.41k | startLine() << Label << ": " << hex(Value) << "\n"; |
246 | 7.41k | } void llvm::ScopedPrinter::printHex<unsigned int>(llvm::StringRef, unsigned int) Line | Count | Source | 244 | 5.02k | template <typename T> void printHex(StringRef Label, T Value) { | 245 | 5.02k | startLine() << Label << ": " << hex(Value) << "\n"; | 246 | 5.02k | } |
void llvm::ScopedPrinter::printHex<int>(llvm::StringRef, int) Line | Count | Source | 244 | 15 | template <typename T> void printHex(StringRef Label, T Value) { | 245 | 15 | startLine() << Label << ": " << hex(Value) << "\n"; | 246 | 15 | } |
void llvm::ScopedPrinter::printHex<unsigned short>(llvm::StringRef, unsigned short) Line | Count | Source | 244 | 445 | template <typename T> void printHex(StringRef Label, T Value) { | 245 | 445 | startLine() << Label << ": " << hex(Value) << "\n"; | 246 | 445 | } |
void llvm::ScopedPrinter::printHex<unsigned long long>(llvm::StringRef, unsigned long long) Line | Count | Source | 244 | 1.92k | template <typename T> void printHex(StringRef Label, T Value) { | 245 | 1.92k | startLine() << Label << ": " << hex(Value) << "\n"; | 246 | 1.92k | } |
|
247 | | |
248 | 6.31k | template <typename T> void printHex(StringRef Label, StringRef Str, T Value) { |
249 | 6.31k | startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n"; |
250 | 6.31k | } |
251 | | |
252 | | template <typename T> |
253 | | void printSymbolOffset(StringRef Label, StringRef Symbol, T Value) { |
254 | | startLine() << Label << ": " << Symbol << '+' << hex(Value) << '\n'; |
255 | | } |
256 | | |
257 | 0 | void printString(StringRef Value) { startLine() << Value << "\n"; } |
258 | | |
259 | 11.0k | void printString(StringRef Label, StringRef Value) { |
260 | 11.0k | startLine() << Label << ": " << Value << "\n"; |
261 | 11.0k | } |
262 | | |
263 | 547 | void printString(StringRef Label, const std::string &Value) { |
264 | 547 | startLine() << Label << ": " << Value << "\n"; |
265 | 547 | } |
266 | | |
267 | | template <typename T> |
268 | | void printNumber(StringRef Label, StringRef Str, T Value) { |
269 | | startLine() << Label << ": " << Str << " (" << Value << ")\n"; |
270 | | } |
271 | | |
272 | 0 | void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) { |
273 | 0 | printBinaryImpl(Label, Str, Value, false); |
274 | 0 | } |
275 | | |
276 | 0 | void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) { |
277 | 0 | auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), |
278 | 0 | Value.size()); |
279 | 0 | printBinaryImpl(Label, Str, V, false); |
280 | 0 | } |
281 | | |
282 | 0 | void printBinary(StringRef Label, ArrayRef<uint8_t> Value) { |
283 | 0 | printBinaryImpl(Label, StringRef(), Value, false); |
284 | 0 | } |
285 | | |
286 | 0 | void printBinary(StringRef Label, ArrayRef<char> Value) { |
287 | 0 | auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), |
288 | 0 | Value.size()); |
289 | 0 | printBinaryImpl(Label, StringRef(), V, false); |
290 | 0 | } |
291 | | |
292 | 0 | void printBinary(StringRef Label, StringRef Value) { |
293 | 0 | auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), |
294 | 0 | Value.size()); |
295 | 0 | printBinaryImpl(Label, StringRef(), V, false); |
296 | 0 | } |
297 | | |
298 | | void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value, |
299 | 0 | uint32_t StartOffset) { |
300 | 0 | printBinaryImpl(Label, StringRef(), Value, true, StartOffset); |
301 | 0 | } |
302 | | |
303 | 0 | void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value) { |
304 | 0 | printBinaryImpl(Label, StringRef(), Value, true); |
305 | 0 | } |
306 | | |
307 | 2.02k | void printBinaryBlock(StringRef Label, StringRef Value) { |
308 | 2.02k | auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()), |
309 | 2.02k | Value.size()); |
310 | 2.02k | printBinaryImpl(Label, StringRef(), V, true); |
311 | 2.02k | } |
312 | | |
313 | | template <typename T> void printObject(StringRef Label, const T &Value) { |
314 | | startLine() << Label << ": " << Value << "\n"; |
315 | | } |
316 | | |
317 | 2.06M | raw_ostream &startLine() { |
318 | 2.06M | printIndent(); |
319 | 2.06M | return OS; |
320 | 2.06M | } |
321 | | |
322 | 308k | raw_ostream &getOStream() { return OS; } |
323 | | |
324 | | private: |
325 | | template <typename T> void printVersionInternal(T Value) { |
326 | | getOStream() << Value; |
327 | | } |
328 | | |
329 | | template <typename S, typename T, typename... TArgs> |
330 | | void printVersionInternal(S Value, T Value2, TArgs... Args) { |
331 | | getOStream() << Value << "."; |
332 | | printVersionInternal(Value2, Args...); |
333 | | } |
334 | | |
335 | | template <typename T> |
336 | 401 | static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) { |
337 | 401 | return lhs.Name < rhs.Name; |
338 | 401 | } bool llvm::ScopedPrinter::flagName<unsigned short>(llvm::EnumEntry<unsigned short> const&, llvm::EnumEntry<unsigned short> const&) Line | Count | Source | 336 | 389 | static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) { | 337 | 389 | return lhs.Name < rhs.Name; | 338 | 389 | } |
bool llvm::ScopedPrinter::flagName<unsigned char>(llvm::EnumEntry<unsigned char> const&, llvm::EnumEntry<unsigned char> const&) Line | Count | Source | 336 | 12 | static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) { | 337 | 12 | return lhs.Name < rhs.Name; | 338 | 12 | } |
|
339 | | |
340 | | void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value, |
341 | | bool Block, uint32_t StartOffset = 0); |
342 | | |
343 | | raw_ostream &OS; |
344 | | int IndentLevel; |
345 | | StringRef Prefix; |
346 | | }; |
347 | | |
348 | | template <> |
349 | | inline void |
350 | | ScopedPrinter::printHex<support::ulittle16_t>(StringRef Label, |
351 | 0 | support::ulittle16_t Value) { |
352 | 0 | startLine() << Label << ": " << hex(Value) << "\n"; |
353 | 0 | } |
354 | | |
355 | | template<char Open, char Close> |
356 | | struct DelimitedScope { |
357 | | explicit DelimitedScope(ScopedPrinter &W) : W(W) { |
358 | | W.startLine() << Open << '\n'; |
359 | | W.indent(); |
360 | | } |
361 | | |
362 | 4.87k | DelimitedScope(ScopedPrinter &W, StringRef N) : W(W) { |
363 | 4.87k | W.startLine() << N; |
364 | 4.87k | if (!N.empty()) |
365 | 4.87k | W.getOStream() << ' '; |
366 | 4.87k | W.getOStream() << Open << '\n'; |
367 | 4.87k | W.indent(); |
368 | 4.87k | } |
369 | | |
370 | 4.86k | ~DelimitedScope() { |
371 | 4.86k | W.unindent(); |
372 | 4.86k | W.startLine() << Close << '\n'; |
373 | 4.86k | } |
374 | | |
375 | | ScopedPrinter &W; |
376 | | }; |
377 | | |
378 | | using DictScope = DelimitedScope<'{', '}'>; |
379 | | using ListScope = DelimitedScope<'[', ']'>; |
380 | | |
381 | | } // namespace llvm |
382 | | |
383 | | #endif |