LLVM  13.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"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/ADT/StringExtras.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/Support/DataTypes.h"
18 #include "llvm/Support/Endian.h"
20 #include <algorithm>
21 
22 namespace llvm {
23 
24 template <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
35  EnumEntry(StringRef N, StringRef A, T V) : Name(N), AltName(A), Value(V) {}
36  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  HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {}
45  HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) {}
46  HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) {}
47  HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) {}
48  HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) {}
49  HexNumber(signed long long Value)
50  : Value(static_cast<unsigned long long>(Value)) {}
51  HexNumber(unsigned char Value) : Value(Value) {}
52  HexNumber(unsigned short Value) : Value(Value) {}
53  HexNumber(unsigned int Value) : Value(Value) {}
54  HexNumber(unsigned long Value) : Value(Value) {}
55  HexNumber(unsigned long long Value) : Value(Value) {}
56  uint64_t Value;
57 };
58 
60 std::string to_hexString(uint64_t Value, bool UpperCase = true);
61 
62 template <class T> std::string to_string(const T &Value) {
63  std::string number;
64  llvm::raw_string_ostream stream(number);
65  stream << Value;
66  return stream.str();
67 }
68 
70 public:
71  ScopedPrinter(raw_ostream &OS) : OS(OS), IndentLevel(0) {}
72 
73  void flush() { OS.flush(); }
74 
75  void indent(int Levels = 1) { IndentLevel += Levels; }
76 
77  void unindent(int Levels = 1) {
78  IndentLevel = std::max(0, IndentLevel - Levels);
79  }
80 
81  void resetIndent() { IndentLevel = 0; }
82 
83  int getIndentLevel() { return IndentLevel; }
84 
85  void setPrefix(StringRef P) { Prefix = P; }
86 
87  void printIndent() {
88  OS << Prefix;
89  for (int i = 0; i < IndentLevel; ++i)
90  OS << " ";
91  }
92 
93  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
94 
95  template <typename T, typename TEnum>
96  void printEnum(StringRef Label, T Value,
97  ArrayRef<EnumEntry<TEnum>> EnumValues) {
99  bool Found = false;
100  for (const auto &EnumItem : EnumValues) {
101  if (EnumItem.Value == Value) {
102  Name = EnumItem.Name;
103  Found = true;
104  break;
105  }
106  }
107 
108  if (Found) {
109  startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
110  } else {
111  startLine() << Label << ": " << hex(Value) << "\n";
112  }
113  }
114 
115  template <typename T, typename TFlag>
117  TFlag EnumMask1 = {}, TFlag EnumMask2 = {},
118  TFlag EnumMask3 = {}) {
119  typedef EnumEntry<TFlag> FlagEntry;
120  typedef SmallVector<FlagEntry, 10> FlagVector;
121  FlagVector SetFlags;
122 
123  for (const auto &Flag : Flags) {
124  if (Flag.Value == 0)
125  continue;
126 
127  TFlag EnumMask{};
128  if (Flag.Value & EnumMask1)
129  EnumMask = EnumMask1;
130  else if (Flag.Value & EnumMask2)
131  EnumMask = EnumMask2;
132  else if (Flag.Value & EnumMask3)
133  EnumMask = EnumMask3;
134  bool IsEnum = (Flag.Value & EnumMask) != 0;
135  if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
136  (IsEnum && (Value & EnumMask) == Flag.Value)) {
137  SetFlags.push_back(Flag);
138  }
139  }
140 
141  llvm::sort(SetFlags, &flagName<TFlag>);
142 
143  startLine() << Label << " [ (" << hex(Value) << ")\n";
144  for (const auto &Flag : SetFlags) {
145  startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
146  }
147  startLine() << "]\n";
148  }
149 
150  template <typename T> void printFlags(StringRef Label, T Value) {
151  startLine() << Label << " [ (" << hex(Value) << ")\n";
152  uint64_t Flag = 1;
153  uint64_t Curr = Value;
154  while (Curr > 0) {
155  if (Curr & 1)
156  startLine() << " " << hex(Flag) << "\n";
157  Curr >>= 1;
158  Flag <<= 1;
159  }
160  startLine() << "]\n";
161  }
162 
163  void printNumber(StringRef Label, uint64_t Value) {
164  startLine() << Label << ": " << Value << "\n";
165  }
166 
168  startLine() << Label << ": " << Value << "\n";
169  }
170 
172  startLine() << Label << ": " << Value << "\n";
173  }
174 
175  void printNumber(StringRef Label, uint8_t Value) {
176  startLine() << Label << ": " << unsigned(Value) << "\n";
177  }
178 
179  void printNumber(StringRef Label, int64_t Value) {
180  startLine() << Label << ": " << Value << "\n";
181  }
182 
183  void printNumber(StringRef Label, int32_t Value) {
184  startLine() << Label << ": " << Value << "\n";
185  }
186 
187  void printNumber(StringRef Label, int16_t Value) {
188  startLine() << Label << ": " << Value << "\n";
189  }
190 
191  void printNumber(StringRef Label, int8_t Value) {
192  startLine() << Label << ": " << int(Value) << "\n";
193  }
194 
195  void printNumber(StringRef Label, const APSInt &Value) {
196  startLine() << Label << ": " << Value << "\n";
197  }
198 
199  void printBoolean(StringRef Label, bool Value) {
200  startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
201  }
202 
203  template <typename... T> void printVersion(StringRef Label, T... Version) {
204  startLine() << Label << ": ";
205  printVersionInternal(Version...);
206  getOStream() << "\n";
207  }
208 
209  template <typename T> void printList(StringRef Label, const T &List) {
210  startLine() << Label << ": [";
211  ListSeparator LS;
212  for (const auto &Item : List)
213  OS << LS << Item;
214  OS << "]\n";
215  }
216 
217  template <typename T, typename U>
218  void printList(StringRef Label, const T &List, const U &Printer) {
219  startLine() << Label << ": [";
220  ListSeparator LS;
221  for (const auto &Item : List) {
222  OS << LS;
223  Printer(OS, Item);
224  }
225  OS << "]\n";
226  }
227 
228  template <typename T> void printHexList(StringRef Label, const T &List) {
229  startLine() << Label << ": [";
230  ListSeparator LS;
231  for (const auto &Item : List)
232  OS << LS << hex(Item);
233  OS << "]\n";
234  }
235 
236  template <typename T> void printHex(StringRef Label, T Value) {
237  startLine() << Label << ": " << hex(Value) << "\n";
238  }
239 
240  template <typename T> void printHex(StringRef Label, StringRef Str, T Value) {
241  startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
242  }
243 
244  template <typename T>
246  startLine() << Label << ": " << Symbol << '+' << hex(Value) << '\n';
247  }
248 
249  void printString(StringRef Value) { startLine() << Value << "\n"; }
250 
252  startLine() << Label << ": " << Value << "\n";
253  }
254 
255  void printString(StringRef Label, const std::string &Value) {
256  printString(Label, StringRef(Value));
257  }
258 
259  void printString(StringRef Label, const char* Value) {
260  printString(Label, StringRef(Value));
261  }
262 
263  template <typename T>
264  void printNumber(StringRef Label, StringRef Str, T Value) {
265  startLine() << Label << ": " << Str << " (" << Value << ")\n";
266  }
267 
269  printBinaryImpl(Label, Str, Value, false);
270  }
271 
273  auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
274  Value.size());
275  printBinaryImpl(Label, Str, V, false);
276  }
277 
279  printBinaryImpl(Label, StringRef(), Value, false);
280  }
281 
283  auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
284  Value.size());
285  printBinaryImpl(Label, StringRef(), V, false);
286  }
287 
289  auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
290  Value.size());
291  printBinaryImpl(Label, StringRef(), V, false);
292  }
293 
295  uint32_t StartOffset) {
296  printBinaryImpl(Label, StringRef(), Value, true, StartOffset);
297  }
298 
300  printBinaryImpl(Label, StringRef(), Value, true);
301  }
302 
304  auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
305  Value.size());
306  printBinaryImpl(Label, StringRef(), V, true);
307  }
308 
309  template <typename T> void printObject(StringRef Label, const T &Value) {
310  startLine() << Label << ": " << Value << "\n";
311  }
312 
314  printIndent();
315  return OS;
316  }
317 
318  raw_ostream &getOStream() { return OS; }
319 
320 private:
321  template <typename T> void printVersionInternal(T Value) {
322  getOStream() << Value;
323  }
324 
325  template <typename S, typename T, typename... TArgs>
326  void printVersionInternal(S Value, T Value2, TArgs... Args) {
327  getOStream() << Value << ".";
328  printVersionInternal(Value2, Args...);
329  }
330 
331  template <typename T>
332  static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) {
333  return lhs.Name < rhs.Name;
334  }
335 
336  void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
337  bool Block, uint32_t StartOffset = 0);
338 
339  raw_ostream &OS;
340  int IndentLevel;
341  StringRef Prefix;
342 };
343 
344 template <>
345 inline void
346 ScopedPrinter::printHex<support::ulittle16_t>(StringRef Label,
348  startLine() << Label << ": " << hex(Value) << "\n";
349 }
350 
351 template<char Open, char Close>
353  explicit DelimitedScope(ScopedPrinter &W) : W(W) {
354  W.startLine() << Open << '\n';
355  W.indent();
356  }
357 
359  W.startLine() << N;
360  if (!N.empty())
361  W.getOStream() << ' ';
362  W.getOStream() << Open << '\n';
363  W.indent();
364  }
365 
367  W.unindent();
368  W.startLine() << Close << '\n';
369  }
370 
372 };
373 
374 using DictScope = DelimitedScope<'{', '}'>;
376 
377 } // namespace llvm
378 
379 #endif
i
i
Definition: README.txt:29
llvm::ScopedPrinter::printSymbolOffset
void printSymbolOffset(StringRef Label, StringRef Symbol, T Value)
Definition: ScopedPrinter.h:245
llvm::ScopedPrinter::printVersion
void printVersion(StringRef Label, T... Version)
Definition: ScopedPrinter.h:203
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, StringRef Str, T Value)
Definition: ScopedPrinter.h:264
llvm
Definition: AllocatorList.h:23
llvm::HexNumber::HexNumber
HexNumber(unsigned long long Value)
Definition: ScopedPrinter.h:55
llvm::ScopedPrinter::getOStream
raw_ostream & getOStream()
Definition: ScopedPrinter.h:318
llvm::support::detail::packed_endian_specific_integral
Definition: Endian.h:206
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::ScopedPrinter::printBinary
void printBinary(StringRef Label, StringRef Str, ArrayRef< char > Value)
Definition: ScopedPrinter.h:272
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:614
llvm::ScopedPrinter::ScopedPrinter
ScopedPrinter(raw_ostream &OS)
Definition: ScopedPrinter.h:71
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, uint8_t Value)
Definition: ScopedPrinter.h:175
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, uint32_t Value)
Definition: ScopedPrinter.h:167
llvm::ScopedPrinter::printString
void printString(StringRef Value)
Definition: ScopedPrinter.h:249
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, uint16_t Value)
Definition: ScopedPrinter.h:171
llvm::ScopedPrinter::printObject
void printObject(StringRef Label, const T &Value)
Definition: ScopedPrinter.h:309
llvm::EnumEntry::AltName
StringRef AltName
Definition: ScopedPrinter.h:33
llvm::ScopedPrinter::printString
void printString(StringRef Label, StringRef Value)
Definition: ScopedPrinter.h:251
llvm::EnumEntry::EnumEntry
EnumEntry(StringRef N, T V)
Definition: ScopedPrinter.h:36
llvm::to_hexString
std::string to_hexString(uint64_t Value, bool UpperCase=true)
Definition: ScopedPrinter.cpp:15
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, int16_t Value)
Definition: ScopedPrinter.h:187
llvm::HexNumber::HexNumber
HexNumber(signed short Value)
Definition: ScopedPrinter.h:46
llvm::ScopedPrinter::getIndentLevel
int getIndentLevel()
Definition: ScopedPrinter.h:83
llvm::ScopedPrinter::startLine
raw_ostream & startLine()
Definition: ScopedPrinter.h:313
llvm::DelimitedScope::DelimitedScope
DelimitedScope(ScopedPrinter &W)
Definition: ScopedPrinter.h:353
llvm::ScopedPrinter::printBinaryBlock
void printBinaryBlock(StringRef Label, ArrayRef< uint8_t > Value)
Definition: ScopedPrinter.h:299
llvm::EnumEntry
Definition: ScopedPrinter.h:24
llvm::ScopedPrinter::printHex
void printHex(StringRef Label, StringRef Str, T Value)
Definition: ScopedPrinter.h:240
llvm::ScopedPrinter::unindent
void unindent(int Levels=1)
Definition: ScopedPrinter.h:77
llvm::HexNumber::HexNumber
HexNumber(unsigned char Value)
Definition: ScopedPrinter.h:51
llvm::HexNumber::HexNumber
HexNumber(signed int Value)
Definition: ScopedPrinter.h:47
Printer
print alias Alias Set Printer
Definition: AliasSetTracker.cpp:762
llvm::ScopedPrinter::hex
HexNumber hex(T Value)
Definition: ScopedPrinter.h:93
llvm::ScopedPrinter::printFlags
void printFlags(StringRef Label, T Value)
Definition: ScopedPrinter.h:150
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, uint64_t Value)
Definition: ScopedPrinter.h:163
int
Clang compiles this i1 i64 store i64 i64 store i64 i64 store i64 i64 store i64 align Which gets codegen d xmm0 movaps rbp movaps rbp movaps rbp movaps rbp rbp rbp rbp rbp It would be better to have movq s of instead of the movaps s LLVM produces ret int
Definition: README.txt:536
llvm::HexNumber::HexNumber
HexNumber(unsigned short Value)
Definition: ScopedPrinter.h:52
llvm::HexNumber::HexNumber
HexNumber(signed char Value)
Definition: ScopedPrinter.h:45
llvm::ScopedPrinter::printBinary
void printBinary(StringRef Label, ArrayRef< char > Value)
Definition: ScopedPrinter.h:282
llvm::DelimitedScope
Definition: ScopedPrinter.h:352
llvm::ScopedPrinter::printBinary
void printBinary(StringRef Label, StringRef Value)
Definition: ScopedPrinter.h:288
llvm::MCID::Flag
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:146
llvm::APSInt
An arbitrary precision integer that knows its signedness.
Definition: APSInt.h:22
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:183
llvm::operator<<
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:230
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::EnumEntry::Name
StringRef Name
Definition: ScopedPrinter.h:25
llvm::ScopedPrinter::printBinary
void printBinary(StringRef Label, StringRef Str, ArrayRef< uint8_t > Value)
Definition: ScopedPrinter.h:268
llvm::ScopedPrinter::flush
void flush()
Definition: ScopedPrinter.h:73
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, int64_t Value)
Definition: ScopedPrinter.h:179
llvm::ScopedPrinter::setPrefix
void setPrefix(StringRef P)
Definition: ScopedPrinter.h:85
llvm::ScopedPrinter::printFlags
void printFlags(StringRef Label, T Value, ArrayRef< EnumEntry< TFlag >> Flags, TFlag EnumMask1={}, TFlag EnumMask2={}, TFlag EnumMask3={})
Definition: ScopedPrinter.h:116
llvm::ScopedPrinter::printEnum
void printEnum(StringRef Label, T Value, ArrayRef< EnumEntry< TEnum >> EnumValues)
Definition: ScopedPrinter.h:96
StringExtras.h
llvm::HexNumber
Definition: ScopedPrinter.h:39
ArrayRef.h
llvm::ScopedPrinter::printBinaryBlock
void printBinaryBlock(StringRef Label, ArrayRef< uint8_t > Value, uint32_t StartOffset)
Definition: ScopedPrinter.h:294
llvm::HexNumber::HexNumber
HexNumber(signed long long Value)
Definition: ScopedPrinter.h:49
llvm::ScopedPrinter::printBoolean
void printBoolean(StringRef Label, bool Value)
Definition: ScopedPrinter.h:199
llvm::DelimitedScope::~DelimitedScope
~DelimitedScope()
Definition: ScopedPrinter.h:366
APSInt.h
llvm::ScopedPrinter::printString
void printString(StringRef Label, const char *Value)
Definition: ScopedPrinter.h:259
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::EnumEntry::Value
T Value
Definition: ScopedPrinter.h:34
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, int32_t Value)
Definition: ScopedPrinter.h:183
uint32_t
llvm::ScopedPrinter::printBinaryBlock
void printBinaryBlock(StringRef Label, StringRef Value)
Definition: ScopedPrinter.h:303
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::DelimitedScope::W
ScopedPrinter & W
Definition: ScopedPrinter.h:371
llvm::ScopedPrinter::printHexList
void printHexList(StringRef Label, const T &List)
Definition: ScopedPrinter.h:228
llvm::ScopedPrinter::printBinary
void printBinary(StringRef Label, ArrayRef< uint8_t > Value)
Definition: ScopedPrinter.h:278
llvm::pdb::PDB_SymType::Label
@ Label
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
uint16_t
llvm::ScopedPrinter::printString
void printString(StringRef Label, const std::string &Value)
Definition: ScopedPrinter.h:255
llvm::ScopedPrinter::printList
void printList(StringRef Label, const T &List)
Definition: ScopedPrinter.h:209
llvm::ScopedPrinter::printIndent
void printIndent()
Definition: ScopedPrinter.h:87
llvm::AArch64CC::LS
@ LS
Definition: AArch64BaseInfo.h:245
llvm::ScopedPrinter::indent
void indent(int Levels=1)
Definition: ScopedPrinter.h:75
llvm::ScopedPrinter
Definition: ScopedPrinter.h:69
llvm::sort
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1423
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::HexNumber::HexNumber
HexNumber(unsigned long Value)
Definition: ScopedPrinter.h:54
llvm::DelimitedScope::DelimitedScope
DelimitedScope(ScopedPrinter &W, StringRef N)
Definition: ScopedPrinter.h:358
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:474
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:79
llvm::ScopedPrinter::printHex
void printHex(StringRef Label, T Value)
Definition: ScopedPrinter.h:236
SmallVector.h
List
const NodeList & List
Definition: RDFGraph.cpp:201
llvm::HexNumber::HexNumber
HexNumber(signed long Value)
Definition: ScopedPrinter.h:48
llvm::HexNumber::HexNumber
HexNumber(unsigned int Value)
Definition: ScopedPrinter.h:53
N
#define N
llvm::EnumEntry::EnumEntry
EnumEntry(StringRef N, StringRef A, T V)
Definition: ScopedPrinter.h:35
llvm::ScopedPrinter::resetIndent
void resetIndent()
Definition: ScopedPrinter.h:81
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:62
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
DataTypes.h
llvm::HexNumber::HexNumber
HexNumber(char Value)
Definition: ScopedPrinter.h:44
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
raw_ostream.h
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, int8_t Value)
Definition: ScopedPrinter.h:191
llvm::ScopedPrinter::printList
void printList(StringRef Label, const T &List, const U &Printer)
Definition: ScopedPrinter.h:218
Endian.h
llvm::raw_string_ostream::str
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
Definition: raw_ostream.h:632
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::ScopedPrinter::printNumber
void printNumber(StringRef Label, const APSInt &Value)
Definition: ScopedPrinter.h:195
llvm::HexNumber::Value
uint64_t Value
Definition: ScopedPrinter.h:56