1//===--- Disasm.cpp - Disassembler for bytecode functions -------*- 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// Dump method for Function which disassembles the bytecode.
10//
11//===----------------------------------------------------------------------===//
12
13#include "Boolean.h"
14#include "Char.h"
15#include "Context.h"
16#include "EvaluationResult.h"
17#include "FixedPoint.h"
18#include "Floating.h"
19#include "Function.h"
20#include "Integral.h"
21#include "IntegralAP.h"
22#include "InterpFrame.h"
23#include "MemberPointer.h"
24#include "Opcode.h"
25#include "PrimType.h"
26#include "Program.h"
27#include "clang/AST/ASTDumperUtils.h"
28#include "clang/AST/DeclCXX.h"
29#include "clang/AST/ExprCXX.h"
30#include "llvm/Support/Compiler.h"
31#include "llvm/Support/FormatVariadic.h"
32
33using namespace clang;
34using namespace clang::interp;
35
36template <typename T> inline static std::string printArg(CodePtr &OpPC) {
37 if constexpr (std::is_pointer_v<T>) {
38 uintptr_t Ptr = OpPC.read<uintptr_t>();
39 std::string Result;
40 llvm::raw_string_ostream SS(Result);
41 SS << reinterpret_cast<void *>(Ptr);
42 return Result;
43 } else {
44 std::string Result;
45 llvm::raw_string_ostream SS(Result);
46 auto Arg = OpPC.read<T>();
47 // Make sure we print the integral value of chars.
48 if constexpr (std::is_integral_v<T>) {
49 if constexpr (sizeof(T) == 1) {
50 if constexpr (std::is_signed_v<T>)
51 SS << static_cast<int32_t>(Arg);
52 else
53 SS << static_cast<uint32_t>(Arg);
54 } else {
55 SS << Arg;
56 }
57 } else {
58 SS << Arg;
59 }
60
61 return Result;
62 }
63}
64
65template <> inline std::string printArg<Floating>(CodePtr &OpPC) {
66 auto Sem = Floating::deserializeSemantics(Buff: *OpPC);
67
68 unsigned BitWidth = llvm::APFloatBase::semanticsSizeInBits(
69 llvm::APFloatBase::EnumToSemantics(S: Sem));
70 auto Memory =
71 std::make_unique<uint64_t[]>(num: llvm::APInt::getNumWords(BitWidth));
72 Floating Result(Memory.get(), Sem);
73 Floating::deserialize(Buff: *OpPC, Result: &Result);
74
75 OpPC += align(Size: Result.bytesToSerialize());
76
77 std::string S;
78 llvm::raw_string_ostream SS(S);
79 SS << std::move(Result);
80 return S;
81}
82
83template <> inline std::string printArg<IntegralAP<false>>(CodePtr &OpPC) {
84 using T = IntegralAP<false>;
85 uint32_t BitWidth = T::deserializeSize(Buff: *OpPC);
86 auto Memory =
87 std::make_unique<uint64_t[]>(num: llvm::APInt::getNumWords(BitWidth));
88
89 T Result(Memory.get(), BitWidth);
90 T::deserialize(Buff: *OpPC, Result: &Result);
91
92 OpPC += align(Size: Result.bytesToSerialize());
93
94 std::string Str;
95 llvm::raw_string_ostream SS(Str);
96 SS << std::move(Result);
97 return Str;
98}
99
100template <> inline std::string printArg<IntegralAP<true>>(CodePtr &OpPC) {
101 using T = IntegralAP<true>;
102 uint32_t BitWidth = T::deserializeSize(Buff: *OpPC);
103 auto Memory =
104 std::make_unique<uint64_t[]>(num: llvm::APInt::getNumWords(BitWidth));
105
106 T Result(Memory.get(), BitWidth);
107 T::deserialize(Buff: *OpPC, Result: &Result);
108
109 OpPC += align(Size: Result.bytesToSerialize());
110
111 std::string Str;
112 llvm::raw_string_ostream SS(Str);
113 SS << std::move(Result);
114 return Str;
115}
116
117template <> inline std::string printArg<FixedPoint>(CodePtr &OpPC) {
118 auto F = FixedPoint::deserialize(Buff: *OpPC);
119 OpPC += align(Size: F.bytesToSerialize());
120
121 std::string Result;
122 llvm::raw_string_ostream SS(Result);
123 SS << std::move(F);
124 return Result;
125}
126
127static bool isJumpOpcode(Opcode Op) {
128 return Op == OP_Jmp || Op == OP_Jf || Op == OP_Jt;
129}
130
131static size_t getNumDisplayWidth(size_t N) {
132 unsigned L = 1u, M = 10u;
133 while (M <= N && ++L != std::numeric_limits<size_t>::digits10 + 1)
134 M *= 10u;
135
136 return L;
137}
138
139LLVM_DUMP_METHOD void Function::dump(CodePtr PC) const {
140 dump(OS&: llvm::errs(), PC);
141}
142
143LLVM_DUMP_METHOD void Function::dump(llvm::raw_ostream &OS,
144 CodePtr OpPC) const {
145 if (OpPC) {
146 assert(OpPC >= getCodeBegin());
147 assert(OpPC <= getCodeEnd());
148 }
149 {
150 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_GREEN, .Bold: true});
151 if (const FunctionDecl *FD = getDecl()) {
152 FD->getNameForDiagnostic(OS, Policy: FD->getASTContext().getPrintingPolicy(),
153 /*Qualified=*/true);
154 } else {
155 OS << getName();
156 }
157 OS << " " << (const void *)this << "\n";
158 }
159 OS << "frame size: " << getFrameSize() << "\n";
160 OS << "arg size: " << getArgSize() << "\n";
161 OS << "rvo: " << hasRVO() << "\n";
162 OS << "this arg: " << hasThisPointer() << "\n";
163
164 struct OpText {
165 size_t Addr;
166 std::string Op;
167 bool IsJump;
168 bool CurrentOp = false;
169 llvm::SmallVector<std::string> Args;
170 };
171
172 auto PrintName = [](const char *Name) -> std::string {
173 return std::string(Name);
174 };
175
176 llvm::SmallVector<OpText> Code;
177 size_t LongestAddr = 0;
178 size_t LongestOp = 0;
179
180 for (CodePtr Start = getCodeBegin(), PC = Start; PC != getCodeEnd();) {
181 size_t Addr = PC - Start;
182 OpText Text;
183 auto Op = PC.read<Opcode>();
184 Text.Addr = Addr;
185 Text.IsJump = isJumpOpcode(Op);
186 Text.CurrentOp = (PC == OpPC);
187 switch (Op) {
188#define GET_DISASM
189#include "Opcodes.inc"
190#undef GET_DISASM
191 }
192 Code.push_back(Elt: Text);
193 LongestOp = std::max(a: Text.Op.size(), b: LongestOp);
194 LongestAddr = std::max(a: getNumDisplayWidth(N: Addr), b: LongestAddr);
195 }
196
197 // Record jumps and their targets.
198 struct JmpData {
199 size_t From;
200 size_t To;
201 };
202 llvm::SmallVector<JmpData> Jumps;
203 for (auto &Text : Code) {
204 if (Text.IsJump)
205 Jumps.push_back(Elt: {.From: Text.Addr, .To: Text.Addr + std::stoi(str: Text.Args[0]) +
206 align(Size: sizeof(Opcode)) +
207 align(Size: sizeof(int32_t))});
208 }
209
210 llvm::SmallVector<std::string> Text;
211 Text.reserve(N: Code.size());
212 size_t LongestLine = 0;
213 // Print code to a string, one at a time.
214 for (const auto &C : Code) {
215 std::string Line;
216 llvm::raw_string_ostream LS(Line);
217 if (OpPC) {
218 if (C.CurrentOp)
219 LS << " * ";
220 else
221 LS << " ";
222 }
223 LS << C.Addr;
224 LS.indent(NumSpaces: LongestAddr - getNumDisplayWidth(N: C.Addr) + 4);
225 LS << C.Op;
226 LS.indent(NumSpaces: LongestOp - C.Op.size() + 4);
227 for (auto &Arg : C.Args) {
228 LS << Arg << ' ';
229 }
230 Text.push_back(Elt: Line);
231 LongestLine = std::max(a: Line.size(), b: LongestLine);
232 }
233
234 assert(Code.size() == Text.size());
235
236 auto spaces = [](unsigned N) -> std::string {
237 std::string S;
238 for (unsigned I = 0; I != N; ++I)
239 S += ' ';
240 return S;
241 };
242
243 // Now, draw the jump lines.
244 for (auto &J : Jumps) {
245 if (J.To > J.From) {
246 bool FoundStart = false;
247 for (size_t LineIndex = 0; LineIndex != Text.size(); ++LineIndex) {
248 Text[LineIndex] += spaces(LongestLine - Text[LineIndex].size());
249
250 if (Code[LineIndex].Addr == J.From) {
251 Text[LineIndex] += " --+";
252 FoundStart = true;
253 } else if (Code[LineIndex].Addr == J.To) {
254 Text[LineIndex] += " <-+";
255 break;
256 } else if (FoundStart) {
257 Text[LineIndex] += " |";
258 }
259 }
260 LongestLine += 5;
261 } else {
262 bool FoundStart = false;
263 for (ssize_t LineIndex = Text.size() - 1; LineIndex >= 0; --LineIndex) {
264 Text[LineIndex] += spaces(LongestLine - Text[LineIndex].size());
265 if (Code[LineIndex].Addr == J.From) {
266 Text[LineIndex] += " --+";
267 FoundStart = true;
268 } else if (Code[LineIndex].Addr == J.To) {
269 Text[LineIndex] += " <-+";
270 break;
271 } else if (FoundStart) {
272 Text[LineIndex] += " |";
273 }
274 }
275 LongestLine += 5;
276 }
277 }
278
279 for (auto &Line : Text)
280 OS << Line << '\n';
281}
282
283LLVM_DUMP_METHOD void Program::dump() const { dump(OS&: llvm::errs()); }
284
285static const char *primTypeToString(PrimType T) {
286 switch (T) {
287 case PT_Sint8:
288 return "Sint8";
289 case PT_Uint8:
290 return "Uint8";
291 case PT_Sint16:
292 return "Sint16";
293 case PT_Uint16:
294 return "Uint16";
295 case PT_Sint32:
296 return "Sint32";
297 case PT_Uint32:
298 return "Uint32";
299 case PT_Sint64:
300 return "Sint64";
301 case PT_Uint64:
302 return "Uint64";
303 case PT_IntAP:
304 return "IntAP";
305 case PT_IntAPS:
306 return "IntAPS";
307 case PT_Bool:
308 return "Bool";
309 case PT_Float:
310 return "Float";
311 case PT_Ptr:
312 return "Ptr";
313 case PT_MemberPtr:
314 return "MemberPtr";
315 case PT_FixedPoint:
316 return "FixedPoint";
317 }
318 llvm_unreachable("Unhandled PrimType");
319}
320
321static std::string formatBytes(size_t B) {
322 std::string Result;
323 llvm::raw_string_ostream SS(Result);
324
325 if (B < (1u << 10u))
326 SS << B << " B";
327 else if (B < (1u << 20u))
328 SS << llvm::formatv(Fmt: "{0:F2}", Vals: B / 1024.) << " KB";
329 else
330 SS << llvm::formatv(Fmt: "{0:F2}", Vals: B / 1024. / 1024.) << " MB";
331
332 return Result;
333}
334
335LLVM_DUMP_METHOD void Program::dump(llvm::raw_ostream &OS) const {
336 {
337 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_RED, .Bold: true});
338 OS << "\n:: Program\n";
339 }
340
341 {
342 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::WHITE, .Bold: true});
343 size_t Bytes = 0;
344 Bytes += Allocator.getTotalMemory();
345 // All the maps.
346 Bytes += GlobalIndices.getMemorySize();
347 Bytes += Records.getMemorySize();
348 Bytes += DummyVariables.getMemorySize();
349
350 // All Records.
351 for (const Record *R : Records.values()) {
352 Bytes += sizeof(Record) + R->BaseMap.getMemorySize() +
353 R->VirtualBaseMap.getMemorySize();
354 Bytes += R->Fields.capacity_in_bytes() + R->Bases.capacity_in_bytes() +
355 R->VirtualBases.capacity_in_bytes();
356 }
357
358 // Globals are allocated via the allocator, so already counted.
359
360 OS << "Total memory : " << formatBytes(B: Bytes) << '\n';
361 OS << "Global Variables: " << Globals.size() << '\n';
362 }
363 unsigned GI = 0;
364 for (const Global *G : Globals) {
365 const Descriptor *Desc = G->block()->getDescriptor();
366 Pointer GP = getPtrGlobal(Idx: GI);
367
368 OS << GI << ": " << (const void *)G->block() << " ";
369 {
370 ColorScope SC(OS, true,
371 GP.isInitialized()
372 ? TerminalColor{.Color: llvm::raw_ostream::GREEN, .Bold: false}
373 : TerminalColor{.Color: llvm::raw_ostream::RED, .Bold: false});
374 OS << (GP.isInitialized() ? "initialized " : "uninitialized ");
375 }
376 if (GP.block()->isDummy())
377 OS << "dummy ";
378 Desc->dump(OS);
379
380 if (GP.isInitialized() && Desc->IsTemporary) {
381 if (const auto *MTE =
382 dyn_cast_if_present<MaterializeTemporaryExpr>(Val: Desc->asExpr());
383 MTE && MTE->getLifetimeExtendedTemporaryDecl()) {
384 if (const APValue *V =
385 MTE->getLifetimeExtendedTemporaryDecl()->getValue()) {
386 OS << " (global temporary value: ";
387 {
388 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_MAGENTA, .Bold: true});
389 std::string VStr;
390 llvm::raw_string_ostream SS(VStr);
391 V->dump(OS&: SS, Context: Ctx.getASTContext());
392
393 for (unsigned I = 0; I != VStr.size(); ++I) {
394 if (VStr[I] == '\n')
395 VStr[I] = ' ';
396 }
397 VStr.pop_back(); // Remove the newline (or now space) at the end.
398 OS << VStr;
399 }
400 OS << ')';
401 }
402 }
403 }
404
405 OS << "\n";
406 if (GP.isInitialized() && Desc->isPrimitive() && !G->block()->isDummy()) {
407 OS << " ";
408 {
409 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_CYAN, .Bold: false});
410 OS << primTypeToString(T: Desc->getPrimType()) << " ";
411 }
412 TYPE_SWITCH(Desc->getPrimType(), { GP.deref<T>().print(OS); });
413 OS << "\n";
414 }
415 ++GI;
416 }
417
418 {
419 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::WHITE, .Bold: true});
420 OS << "Functions: " << Funcs.size() << "\n";
421 }
422 for (const auto &Func : Funcs) {
423 Func.second->dump();
424 }
425 for (const auto &Anon : AnonFuncs) {
426 Anon->dump();
427 }
428}
429
430LLVM_DUMP_METHOD void Descriptor::dump() const {
431 dump(OS&: llvm::errs());
432 llvm::errs() << '\n';
433}
434
435LLVM_DUMP_METHOD void Descriptor::dump(llvm::raw_ostream &OS) const {
436 // Source
437 {
438 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BLUE, .Bold: true});
439 if (const auto *ND = dyn_cast_if_present<NamedDecl>(Val: asDecl()))
440 ND->printQualifiedName(OS);
441 else if (asExpr())
442 OS << "Expr " << (const void *)asExpr();
443 }
444
445 // Print a few interesting bits about the descriptor.
446 if (isPrimitiveArray())
447 OS << " primitive-array " << getNumElems() << ' '
448 << primTypeToString(T: getPrimType());
449 else if (isCompositeArray())
450 OS << " composite-array " << getNumElems();
451 else if (isUnion())
452 OS << " union(" << ElemRecord->getName() << ")";
453 else if (isRecord())
454 OS << " record(" << ElemRecord->getName() << ")";
455 else if (isPrimitive())
456 OS << " primitive " << primTypeToString(T: getPrimType());
457
458 if (isZeroSizeArray())
459 OS << " zero-size-array";
460 else if (isUnknownSizeArray())
461 OS << " unknown-size-array";
462
463 if (IsConstexprUnknown)
464 OS << " constexpr-unknown";
465}
466
467/// Dump descriptor, including all valid offsets.
468LLVM_DUMP_METHOD void Descriptor::dumpFull(unsigned Offset,
469 unsigned Indent) const {
470 unsigned Spaces = Indent * 2;
471 llvm::raw_ostream &OS = llvm::errs();
472 OS.indent(NumSpaces: Spaces);
473 dump(OS);
474 OS << '\n';
475 OS.indent(NumSpaces: Spaces) << "Size: " << getSize() << " bytes\n";
476 OS.indent(NumSpaces: Spaces) << "AllocSize: " << getAllocSize() << " bytes\n";
477 if (isCompositeArray()) {
478 OS.indent(NumSpaces: Spaces) << "Elements: " << getNumElems() << '\n';
479 unsigned FO = Offset;
480 for (unsigned I = 0; I != getNumElems(); ++I) {
481 FO += sizeof(InlineDescriptor);
482 OS.indent(NumSpaces: Spaces) << "Element " << I << " offset: " << FO << '\n';
483 ElemDesc->dumpFull(Offset: FO, Indent: Indent + 1);
484
485 FO += ElemDesc->getAllocSize();
486 }
487 } else if (isPrimitiveArray()) {
488 OS.indent(NumSpaces: Spaces) << "Elements: " << getNumElems() << '\n';
489 OS.indent(NumSpaces: Spaces) << "Element type: " << primTypeToString(T: getPrimType())
490 << '\n';
491 unsigned FO = Offset + sizeof(InitMapPtr);
492 for (unsigned I = 0; I != getNumElems(); ++I) {
493 OS.indent(NumSpaces: Spaces) << "Element " << I << " offset: " << FO << '\n';
494 FO += getElemSize();
495 }
496 } else if (isRecord()) {
497 ElemRecord->dump(OS, Indentation: Indent + 1, Offset);
498 unsigned I = 0;
499 for (const Record::Field &F : ElemRecord->fields()) {
500 OS.indent(NumSpaces: Spaces) << "- Field " << I << ": ";
501 {
502 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_RED, .Bold: true});
503 OS << F.Decl->getName();
504 }
505 OS << ". Offset " << (Offset + F.Offset) << "\n";
506 F.Desc->dumpFull(Offset: Offset + F.Offset, Indent: Indent + 1);
507 ++I;
508 }
509 } else if (isPrimitive()) {
510 } else {
511 }
512
513 OS << '\n';
514}
515
516LLVM_DUMP_METHOD void InlineDescriptor::dump(llvm::raw_ostream &OS) const {
517 {
518 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BLUE, .Bold: true});
519 OS << "InlineDescriptor " << (const void *)this << "\n";
520 }
521 OS << "Offset: " << Offset << "\n";
522 OS << "IsConst: " << IsConst << "\n";
523 OS << "IsInitialized: " << IsInitialized << "\n";
524 OS << "IsBase: " << IsBase << "\n";
525 OS << "IsActive: " << IsActive << "\n";
526 OS << "InUnion: " << InUnion << "\n";
527 OS << "IsFieldMutable: " << IsFieldMutable << "\n";
528 OS << "IsArrayElement: " << IsArrayElement << "\n";
529 OS << "IsConstInMutable: " << IsConstInMutable << '\n';
530 OS << "Desc: ";
531 if (Desc)
532 Desc->dump(OS);
533 else
534 OS << "nullptr";
535 OS << "\n";
536}
537
538LLVM_DUMP_METHOD void InterpFrame::dump(llvm::raw_ostream &OS,
539 unsigned Indent) const {
540 unsigned Spaces = Indent * 2;
541 {
542 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BLUE, .Bold: true});
543 OS.indent(NumSpaces: Spaces);
544 if (getCallee())
545 describe(OS);
546 else
547 OS << "Frame (Depth: " << getDepth() << ")";
548 OS << "\n";
549 }
550 OS.indent(NumSpaces: Spaces) << "Function: " << getFunction();
551 if (const Function *F = getFunction()) {
552 OS << " (" << F->getName() << ")";
553 }
554 OS << "\n";
555 if (hasThisPointer())
556 OS.indent(NumSpaces: Spaces) << "This: " << getThis() << "\n";
557 else
558 OS.indent(NumSpaces: Spaces) << "This: -\n";
559 if (Func && Func->hasRVO())
560 OS.indent(NumSpaces: Spaces) << "RVO: " << getRVOPtr() << "\n";
561 else
562 OS.indent(NumSpaces: Spaces) << "RVO: -\n";
563 OS.indent(NumSpaces: Spaces) << "Depth: " << Depth << "\n";
564 OS.indent(NumSpaces: Spaces) << "ArgSize: " << ArgSize << "\n";
565 OS.indent(NumSpaces: Spaces) << "Args: " << (void *)Args << "\n";
566#ifndef NDEBUG
567 OS.indent(Spaces) << "FrameOffset: " << FrameOffset << "\n";
568#endif
569 OS.indent(NumSpaces: Spaces) << "FrameSize: " << (Func ? Func->getFrameSize() : 0)
570 << "\n";
571
572 for (const InterpFrame *F = this->Caller; F; F = F->Caller) {
573 F->dump(OS, Indent: Indent + 1);
574 }
575}
576
577LLVM_DUMP_METHOD void Record::dump(llvm::raw_ostream &OS, unsigned Indentation,
578 unsigned Offset) const {
579 unsigned Indent = Indentation * 2;
580 OS.indent(NumSpaces: Indent);
581 {
582 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BLUE, .Bold: true});
583 OS << getName() << "\n";
584 }
585
586 unsigned I = 0;
587 for (const Record::Base &B : bases()) {
588 OS.indent(NumSpaces: Indent) << "- Base " << I << ". Offset " << (Offset + B.Offset)
589 << "\n";
590 B.R->dump(OS, Indentation: Indentation + 1, Offset: Offset + B.Offset);
591 ++I;
592 }
593
594 I = 0;
595 for (const Record::Field &F : fields()) {
596 OS.indent(NumSpaces: Indent) << "- Field " << I << ": ";
597 {
598 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_RED, .Bold: true});
599 OS << F.Decl->getName();
600 }
601 OS << ". Offset " << (Offset + F.Offset) << "\n";
602 ++I;
603 }
604
605 I = 0;
606 for (const Record::Base &B : virtual_bases()) {
607 OS.indent(NumSpaces: Indent) << "- Virtual Base " << I << ". Offset "
608 << (Offset + B.Offset) << "\n";
609 B.R->dump(OS, Indentation: Indentation + 1, Offset: Offset + B.Offset);
610 ++I;
611 }
612}
613
614LLVM_DUMP_METHOD void Block::dump(llvm::raw_ostream &OS) const {
615 {
616 ColorScope SC(OS, true, {.Color: llvm::raw_ostream::BRIGHT_BLUE, .Bold: true});
617 OS << "Block " << (const void *)this;
618 }
619 OS << " (";
620 Desc->dump(OS);
621 OS << ")\n";
622 unsigned NPointers = 0;
623 for (const Pointer *P = Pointers; P; P = P->asBlockPointer().Next) {
624 ++NPointers;
625 }
626 OS << " EvalID: " << EvalID << '\n';
627 OS << " DeclID: ";
628 if (DeclID)
629 OS << *DeclID << '\n';
630 else
631 OS << "-\n";
632 OS << " Pointers: " << NPointers << "\n";
633 OS << " Dead: " << isDead() << "\n";
634 OS << " Static: " << IsStatic << "\n";
635 OS << " Extern: " << isExtern() << "\n";
636 OS << " Initialized: " << IsInitialized << "\n";
637 OS << " Weak: " << isWeak() << "\n";
638 OS << " Dummy: " << isDummy() << '\n';
639 OS << " Dynamic: " << isDynamic() << "\n";
640 OS << " Metadata: " << MDSize << '\n';
641}
642
643LLVM_DUMP_METHOD void EvaluationResult::dump() const {
644 auto &OS = llvm::errs();
645
646 if (empty()) {
647 OS << "Empty\n";
648 } else if (isInvalid()) {
649 OS << "Invalid\n";
650 } else {
651 OS << "Value: ";
652#ifndef NDEBUG
653 assert(Ctx);
654 Value.dump(OS, Ctx->getASTContext());
655#endif
656 }
657}
658