contrib/llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

   1 //===-- SymbolDumper.cpp - CodeView symbol info dumper ----------*- C++ -*-===//
   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 #include "llvm/DebugInfo/CodeView/SymbolDumper.h"
  11 #include "llvm/ADT/DenseMap.h"
  12 #include "llvm/ADT/SmallString.h"
  13 #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
  14 #include "llvm/DebugInfo/CodeView/EnumTables.h"
  15 #include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
  16 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
  17 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
  18 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
  19 #include "llvm/Support/ScopedPrinter.h"
  20
  21 #include <system_error>
  22
  23 using namespace llvm;
  24 using namespace llvm::codeview;
  25
  26 namespace {
  27 /// Use this private dumper implementation to keep implementation details about
  28 /// the visitor out of SymbolDumper.h.
  29 class CVSymbolDumperImpl : public CVSymbolVisitor<CVSymbolDumperImpl> {
  30 public:
  31   CVSymbolDumperImpl(CVTypeDumper &CVTD, SymbolDumpDelegate *ObjDelegate,
  32                      ScopedPrinter &W, bool PrintRecordBytes)
  33       : CVSymbolVisitor(ObjDelegate), CVTD(CVTD), ObjDelegate(ObjDelegate),
  34         W(W), PrintRecordBytes(PrintRecordBytes), InFunctionScope(false) {}
  35
  36 /// CVSymbolVisitor overrides.
  37 #define SYMBOL_RECORD(EnumName, EnumVal, Name)                                 \
  38   void visit##Name(SymbolKind Kind, Name &Record);
  39 #define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
  40 #include "llvm/DebugInfo/CodeView/CVSymbolTypes.def"
  41
  42   void visitSymbolBegin(SymbolKind Kind, ArrayRef<uint8_t> Data);
  43   void visitSymbolEnd(SymbolKind Kind, ArrayRef<uint8_t> OriginalSymData);
  44   void visitUnknownSymbol(SymbolKind Kind, ArrayRef<uint8_t> Data);
  45
  46 private:
  47   void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
  48                                    uint32_t RelocationOffset);
  49   void printLocalVariableAddrGap(ArrayRef<LocalVariableAddrGap> Gaps);
  50
  51   CVTypeDumper &CVTD;
  52   SymbolDumpDelegate *ObjDelegate;
  53   ScopedPrinter &W;
  54
  55   bool PrintRecordBytes;
  56   bool InFunctionScope;
  57 };
  58 }
  59
  60 void CVSymbolDumperImpl::printLocalVariableAddrRange(
  61     const LocalVariableAddrRange &Range, uint32_t RelocationOffset) {
  62   DictScope S(W, "LocalVariableAddrRange");
  63   if (ObjDelegate)
  64     ObjDelegate->printRelocatedField("OffsetStart", RelocationOffset,
  65                                      Range.OffsetStart);
  66   W.printHex("ISectStart", Range.ISectStart);
  67   W.printHex("Range", Range.Range);
  68 }
  69
  70 void CVSymbolDumperImpl::printLocalVariableAddrGap(
  71     ArrayRef<LocalVariableAddrGap> Gaps) {
  72   for (auto &Gap : Gaps) {
  73     ListScope S(W, "LocalVariableAddrGap");
  74     W.printHex("GapStartOffset", Gap.GapStartOffset);
  75     W.printHex("Range", Gap.Range);
  76   }
  77 }
  78
  79 void CVSymbolDumperImpl::visitSymbolBegin(SymbolKind Kind,
  80                                           ArrayRef<uint8_t> Data) {}
  81
  82 void CVSymbolDumperImpl::visitSymbolEnd(SymbolKind Kind,
  83                                         ArrayRef<uint8_t> OriginalSymData) {
  84   if (PrintRecordBytes && ObjDelegate)
  85     ObjDelegate->printBinaryBlockWithRelocs("SymData", OriginalSymData);
  86 }
  87
  88 void CVSymbolDumperImpl::visitBlockSym(SymbolKind Kind, BlockSym &Block) {
  89   DictScope S(W, "BlockStart");
  90
  91   StringRef LinkageName;
  92   W.printHex("PtrParent", Block.Header.PtrParent);
  93   W.printHex("PtrEnd", Block.Header.PtrEnd);
  94   W.printHex("CodeSize", Block.Header.CodeSize);
  95   if (ObjDelegate) {
  96     ObjDelegate->printRelocatedField("CodeOffset", Block.getRelocationOffset(),
  97                                      Block.Header.CodeOffset, &LinkageName);
  98   }
  99   W.printHex("Segment", Block.Header.Segment);
 100   W.printString("BlockName", Block.Name);
 101   W.printString("LinkageName", LinkageName);
 102 }
 103
 104 void CVSymbolDumperImpl::visitThunk32Sym(SymbolKind Kind, Thunk32Sym &Thunk) {
 105   DictScope S(W, "Thunk32");
 106   W.printNumber("Parent", Thunk.Header.Parent);
 107   W.printNumber("End", Thunk.Header.End);
 108   W.printNumber("Next", Thunk.Header.Next);
 109   W.printNumber("Off", Thunk.Header.Off);
 110   W.printNumber("Seg", Thunk.Header.Seg);
 111   W.printNumber("Len", Thunk.Header.Len);
 112   W.printEnum("Ordinal", Thunk.Header.Ord, getThunkOrdinalNames());
 113 }
 114
 115 void CVSymbolDumperImpl::visitTrampolineSym(SymbolKind Kind,
 116                                             TrampolineSym &Tramp) {
 117   DictScope S(W, "Trampoline");
 118   W.printEnum("Type", Tramp.Header.Type, getTrampolineNames());
 119   W.printNumber("Size", Tramp.Header.Size);
 120   W.printNumber("ThunkOff", Tramp.Header.ThunkOff);
 121   W.printNumber("TargetOff", Tramp.Header.TargetOff);
 122   W.printNumber("ThunkSection", Tramp.Header.ThunkSection);
 123   W.printNumber("TargetSection", Tramp.Header.TargetSection);
 124 }
 125
 126 void CVSymbolDumperImpl::visitSectionSym(SymbolKind Kind, SectionSym &Section) {
 127   DictScope S(W, "Section");
 128   W.printNumber("SectionNumber", Section.Header.SectionNumber);
 129   W.printNumber("Alignment", Section.Header.Alignment);
 130   W.printNumber("Reserved", Section.Header.Reserved);
 131   W.printNumber("Rva", Section.Header.Rva);
 132   W.printNumber("Length", Section.Header.Length);
 133   W.printFlags("Characteristics", Section.Header.Characteristics,
 134                getImageSectionCharacteristicNames(),
 135                COFF::SectionCharacteristics(0x00F00000));
 136
 137   W.printString("Name", Section.Name);
 138 }
 139
 140 void CVSymbolDumperImpl::visitCoffGroupSym(SymbolKind Kind,
 141                                            CoffGroupSym &CoffGroup) {
 142   DictScope S(W, "COFF Group");
 143   W.printNumber("Size", CoffGroup.Header.Size);
 144   W.printFlags("Characteristics", CoffGroup.Header.Characteristics,
 145                getImageSectionCharacteristicNames(),
 146                COFF::SectionCharacteristics(0x00F00000));
 147   W.printNumber("Offset", CoffGroup.Header.Offset);
 148   W.printNumber("Segment", CoffGroup.Header.Segment);
 149   W.printString("Name", CoffGroup.Name);
 150 }
 151
 152 void CVSymbolDumperImpl::visitBPRelativeSym(SymbolKind Kind,
 153                                             BPRelativeSym &BPRel) {
 154   DictScope S(W, "BPRelativeSym");
 155
 156   W.printNumber("Offset", BPRel.Header.Offset);
 157   CVTD.printTypeIndex("Type", BPRel.Header.Type);
 158   W.printString("VarName", BPRel.Name);
 159 }
 160
 161 void CVSymbolDumperImpl::visitBuildInfoSym(SymbolKind Kind,
 162                                            BuildInfoSym &BuildInfo) {
 163   DictScope S(W, "BuildInfo");
 164
 165   W.printNumber("BuildId", BuildInfo.Header.BuildId);
 166 }
 167
 168 void CVSymbolDumperImpl::visitCallSiteInfoSym(SymbolKind Kind,
 169                                               CallSiteInfoSym &CallSiteInfo) {
 170   DictScope S(W, "CallSiteInfo");
 171
 172   StringRef LinkageName;
 173   if (ObjDelegate) {
 174     ObjDelegate->printRelocatedField(
 175         "CodeOffset", CallSiteInfo.getRelocationOffset(),
 176         CallSiteInfo.Header.CodeOffset, &LinkageName);
 177   }
 178   W.printHex("Segment", CallSiteInfo.Header.Segment);
 179   W.printHex("Reserved", CallSiteInfo.Header.Reserved);
 180   CVTD.printTypeIndex("Type", CallSiteInfo.Header.Type);
 181   if (!LinkageName.empty())
 182     W.printString("LinkageName", LinkageName);
 183 }
 184
 185 void CVSymbolDumperImpl::visitEnvBlockSym(SymbolKind Kind,
 186                                           EnvBlockSym &EnvBlock) {
 187   DictScope S(W, "EnvBlock");
 188
 189   W.printNumber("Reserved", EnvBlock.Header.Reserved);
 190   ListScope L(W, "Entries");
 191   for (auto Entry : EnvBlock.Fields) {
 192     W.printString(Entry);
 193   }
 194 }
 195
 196 void CVSymbolDumperImpl::visitFileStaticSym(SymbolKind Kind,
 197                                             FileStaticSym &FileStatic) {
 198   DictScope S(W, "FileStatic");
 199   W.printNumber("Index", FileStatic.Header.Index);
 200   W.printNumber("ModFilenameOffset", FileStatic.Header.ModFilenameOffset);
 201   W.printFlags("Flags", uint16_t(FileStatic.Header.Flags), getLocalFlagNames());
 202   W.printString("Name", FileStatic.Name);
 203 }
 204
 205 void CVSymbolDumperImpl::visitExportSym(SymbolKind Kind, ExportSym &Export) {
 206   DictScope S(W, "Export");
 207   W.printNumber("Ordinal", Export.Header.Ordinal);
 208   W.printFlags("Flags", Export.Header.Flags, getExportSymFlagNames());
 209   W.printString("Name", Export.Name);
 210 }
 211
 212 void CVSymbolDumperImpl::visitCompile2Sym(SymbolKind Kind,
 213                                           Compile2Sym &Compile2) {
 214   DictScope S(W, "CompilerFlags2");
 215
 216   W.printEnum("Language", Compile2.Header.getLanguage(),
 217               getSourceLanguageNames());
 218   W.printFlags("Flags", Compile2.Header.flags & ~0xff,
 219                getCompileSym2FlagNames());
 220   W.printEnum("Machine", unsigned(Compile2.Header.Machine), getCPUTypeNames());
 221   std::string FrontendVersion;
 222   {
 223     raw_string_ostream Out(FrontendVersion);
 224     Out << Compile2.Header.VersionFrontendMajor << '.'
 225         << Compile2.Header.VersionFrontendMinor << '.'
 226         << Compile2.Header.VersionFrontendBuild;
 227   }
 228   std::string BackendVersion;
 229   {
 230     raw_string_ostream Out(BackendVersion);
 231     Out << Compile2.Header.VersionBackendMajor << '.'
 232         << Compile2.Header.VersionBackendMinor << '.'
 233         << Compile2.Header.VersionBackendBuild;
 234   }
 235   W.printString("FrontendVersion", FrontendVersion);
 236   W.printString("BackendVersion", BackendVersion);
 237   W.printString("VersionName", Compile2.Version);
 238 }
 239
 240 void CVSymbolDumperImpl::visitCompile3Sym(SymbolKind Kind,
 241                                           Compile3Sym &Compile3) {
 242   DictScope S(W, "CompilerFlags3");
 243
 244   W.printEnum("Language", Compile3.Header.getLanguage(),
 245               getSourceLanguageNames());
 246   W.printFlags("Flags", Compile3.Header.flags & ~0xff,
 247                getCompileSym3FlagNames());
 248   W.printEnum("Machine", unsigned(Compile3.Header.Machine), getCPUTypeNames());
 249   std::string FrontendVersion;
 250   {
 251     raw_string_ostream Out(FrontendVersion);
 252     Out << Compile3.Header.VersionFrontendMajor << '.'
 253         << Compile3.Header.VersionFrontendMinor << '.'
 254         << Compile3.Header.VersionFrontendBuild << '.'
 255         << Compile3.Header.VersionFrontendQFE;
 256   }
 257   std::string BackendVersion;
 258   {
 259     raw_string_ostream Out(BackendVersion);
 260     Out << Compile3.Header.VersionBackendMajor << '.'
 261         << Compile3.Header.VersionBackendMinor << '.'
 262         << Compile3.Header.VersionBackendBuild << '.'
 263         << Compile3.Header.VersionBackendQFE;
 264   }
 265   W.printString("FrontendVersion", FrontendVersion);
 266   W.printString("BackendVersion", BackendVersion);
 267   W.printString("VersionName", Compile3.Version);
 268 }
 269
 270 void CVSymbolDumperImpl::visitConstantSym(SymbolKind Kind,
 271                                           ConstantSym &Constant) {
 272   DictScope S(W, "Constant");
 273
 274   CVTD.printTypeIndex("Type", Constant.Header.Type);
 275   W.printNumber("Value", Constant.Value);
 276   W.printString("Name", Constant.Name);
 277 }
 278
 279 void CVSymbolDumperImpl::visitDataSym(SymbolKind Kind, DataSym &Data) {
 280   DictScope S(W, "DataSym");
 281
 282   W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames());
 283   StringRef LinkageName;
 284   if (ObjDelegate) {
 285     ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(),
 286                                      Data.Header.DataOffset, &LinkageName);
 287   }
 288   CVTD.printTypeIndex("Type", Data.Header.Type);
 289   W.printString("DisplayName", Data.Name);
 290   if (!LinkageName.empty())
 291     W.printString("LinkageName", LinkageName);
 292 }
 293
 294 void CVSymbolDumperImpl::visitDefRangeFramePointerRelFullScopeSym(
 295     SymbolKind Kind,
 296     DefRangeFramePointerRelFullScopeSym &DefRangeFramePointerRelFullScope) {
 297   DictScope S(W, "DefRangeFramePointerRelFullScope");
 298   W.printNumber("Offset", DefRangeFramePointerRelFullScope.Header.Offset);
 299 }
 300
 301 void CVSymbolDumperImpl::visitDefRangeFramePointerRelSym(
 302     SymbolKind Kind, DefRangeFramePointerRelSym &DefRangeFramePointerRel) {
 303   DictScope S(W, "DefRangeFramePointerRel");
 304
 305   W.printNumber("Offset", DefRangeFramePointerRel.Header.Offset);
 306   printLocalVariableAddrRange(DefRangeFramePointerRel.Header.Range,
 307                               DefRangeFramePointerRel.getRelocationOffset());
 308   printLocalVariableAddrGap(DefRangeFramePointerRel.Gaps);
 309 }
 310
 311 void CVSymbolDumperImpl::visitDefRangeRegisterRelSym(
 312     SymbolKind Kind, DefRangeRegisterRelSym &DefRangeRegisterRel) {
 313   DictScope S(W, "DefRangeRegisterRel");
 314
 315   W.printNumber("BaseRegister", DefRangeRegisterRel.Header.BaseRegister);
 316   W.printBoolean("HasSpilledUDTMember",
 317                  DefRangeRegisterRel.hasSpilledUDTMember());
 318   W.printNumber("OffsetInParent", DefRangeRegisterRel.offsetInParent());
 319   W.printNumber("BasePointerOffset",
 320                 DefRangeRegisterRel.Header.BasePointerOffset);
 321   printLocalVariableAddrRange(DefRangeRegisterRel.Header.Range,
 322                               DefRangeRegisterRel.getRelocationOffset());
 323   printLocalVariableAddrGap(DefRangeRegisterRel.Gaps);
 324 }
 325
 326 void CVSymbolDumperImpl::visitDefRangeRegisterSym(
 327     SymbolKind Kind, DefRangeRegisterSym &DefRangeRegister) {
 328   DictScope S(W, "DefRangeRegister");
 329
 330   W.printNumber("Register", DefRangeRegister.Header.Register);
 331   W.printNumber("MayHaveNoName", DefRangeRegister.Header.MayHaveNoName);
 332   printLocalVariableAddrRange(DefRangeRegister.Header.Range,
 333                               DefRangeRegister.getRelocationOffset());
 334   printLocalVariableAddrGap(DefRangeRegister.Gaps);
 335 }
 336
 337 void CVSymbolDumperImpl::visitDefRangeSubfieldRegisterSym(
 338     SymbolKind Kind, DefRangeSubfieldRegisterSym &DefRangeSubfieldRegister) {
 339   DictScope S(W, "DefRangeSubfieldRegister");
 340
 341   W.printNumber("Register", DefRangeSubfieldRegister.Header.Register);
 342   W.printNumber("MayHaveNoName", DefRangeSubfieldRegister.Header.MayHaveNoName);
 343   W.printNumber("OffsetInParent",
 344                 DefRangeSubfieldRegister.Header.OffsetInParent);
 345   printLocalVariableAddrRange(DefRangeSubfieldRegister.Header.Range,
 346                               DefRangeSubfieldRegister.getRelocationOffset());
 347   printLocalVariableAddrGap(DefRangeSubfieldRegister.Gaps);
 348 }
 349
 350 void CVSymbolDumperImpl::visitDefRangeSubfieldSym(
 351     SymbolKind Kind, DefRangeSubfieldSym &DefRangeSubfield) {
 352   DictScope S(W, "DefRangeSubfield");
 353
 354   if (ObjDelegate) {
 355     StringRef StringTable = ObjDelegate->getStringTable();
 356     auto ProgramStringTableOffset = DefRangeSubfield.Header.Program;
 357     if (ProgramStringTableOffset >= StringTable.size())
 358       return parseError();
 359     StringRef Program =
 360         StringTable.drop_front(ProgramStringTableOffset).split('\0').first;
 361     W.printString("Program", Program);
 362   }
 363   W.printNumber("OffsetInParent", DefRangeSubfield.Header.OffsetInParent);
 364   printLocalVariableAddrRange(DefRangeSubfield.Header.Range,
 365                               DefRangeSubfield.getRelocationOffset());
 366   printLocalVariableAddrGap(DefRangeSubfield.Gaps);
 367 }
 368
 369 void CVSymbolDumperImpl::visitDefRangeSym(SymbolKind Kind,
 370                                           DefRangeSym &DefRange) {
 371   DictScope S(W, "DefRange");
 372
 373   if (ObjDelegate) {
 374     StringRef StringTable = ObjDelegate->getStringTable();
 375     auto ProgramStringTableOffset = DefRange.Header.Program;
 376     if (ProgramStringTableOffset >= StringTable.size())
 377       return parseError();
 378     StringRef Program =
 379         StringTable.drop_front(ProgramStringTableOffset).split('\0').first;
 380     W.printString("Program", Program);
 381   }
 382   printLocalVariableAddrRange(DefRange.Header.Range,
 383                               DefRange.getRelocationOffset());
 384   printLocalVariableAddrGap(DefRange.Gaps);
 385 }
 386
 387 void CVSymbolDumperImpl::visitFrameCookieSym(SymbolKind Kind,
 388                                              FrameCookieSym &FrameCookie) {
 389   DictScope S(W, "FrameCookie");
 390
 391   StringRef LinkageName;
 392   if (ObjDelegate) {
 393     ObjDelegate->printRelocatedField(
 394         "CodeOffset", FrameCookie.getRelocationOffset(),
 395         FrameCookie.Header.CodeOffset, &LinkageName);
 396   }
 397   W.printHex("Register", FrameCookie.Header.Register);
 398   W.printEnum("CookieKind", uint16_t(FrameCookie.Header.CookieKind),
 399               getFrameCookieKindNames());
 400   W.printHex("Flags", FrameCookie.Header.Flags);
 401 }
 402
 403 void CVSymbolDumperImpl::visitFrameProcSym(SymbolKind Kind,
 404                                            FrameProcSym &FrameProc) {
 405   DictScope S(W, "FrameProc");
 406
 407   W.printHex("TotalFrameBytes", FrameProc.Header.TotalFrameBytes);
 408   W.printHex("PaddingFrameBytes", FrameProc.Header.PaddingFrameBytes);
 409   W.printHex("OffsetToPadding", FrameProc.Header.OffsetToPadding);
 410   W.printHex("BytesOfCalleeSavedRegisters",
 411              FrameProc.Header.BytesOfCalleeSavedRegisters);
 412   W.printHex("OffsetOfExceptionHandler",
 413              FrameProc.Header.OffsetOfExceptionHandler);
 414   W.printHex("SectionIdOfExceptionHandler",
 415              FrameProc.Header.SectionIdOfExceptionHandler);
 416   W.printFlags("Flags", FrameProc.Header.Flags, getFrameProcSymFlagNames());
 417 }
 418
 419 void CVSymbolDumperImpl::visitHeapAllocationSiteSym(
 420     SymbolKind Kind, HeapAllocationSiteSym &HeapAllocSite) {
 421   DictScope S(W, "HeapAllocationSite");
 422
 423   StringRef LinkageName;
 424   if (ObjDelegate) {
 425     ObjDelegate->printRelocatedField(
 426         "CodeOffset", HeapAllocSite.getRelocationOffset(),
 427         HeapAllocSite.Header.CodeOffset, &LinkageName);
 428   }
 429   W.printHex("Segment", HeapAllocSite.Header.Segment);
 430   W.printHex("CallInstructionSize", HeapAllocSite.Header.CallInstructionSize);
 431   CVTD.printTypeIndex("Type", HeapAllocSite.Header.Type);
 432   if (!LinkageName.empty())
 433     W.printString("LinkageName", LinkageName);
 434 }
 435
 436 void CVSymbolDumperImpl::visitInlineSiteSym(SymbolKind Kind,
 437                                             InlineSiteSym &InlineSite) {
 438   DictScope S(W, "InlineSite");
 439
 440   W.printHex("PtrParent", InlineSite.Header.PtrParent);
 441   W.printHex("PtrEnd", InlineSite.Header.PtrEnd);
 442   CVTD.printTypeIndex("Inlinee", InlineSite.Header.Inlinee);
 443
 444   ListScope BinaryAnnotations(W, "BinaryAnnotations");
 445   for (auto &Annotation : InlineSite.annotations()) {
 446     switch (Annotation.OpCode) {
 447     case BinaryAnnotationsOpCode::Invalid:
 448       return parseError();
 449     case BinaryAnnotationsOpCode::CodeOffset:
 450     case BinaryAnnotationsOpCode::ChangeCodeOffset:
 451     case BinaryAnnotationsOpCode::ChangeCodeLength:
 452       W.printHex(Annotation.Name, Annotation.U1);
 453       break;
 454     case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
 455     case BinaryAnnotationsOpCode::ChangeLineEndDelta:
 456     case BinaryAnnotationsOpCode::ChangeRangeKind:
 457     case BinaryAnnotationsOpCode::ChangeColumnStart:
 458     case BinaryAnnotationsOpCode::ChangeColumnEnd:
 459       W.printNumber(Annotation.Name, Annotation.U1);
 460       break;
 461     case BinaryAnnotationsOpCode::ChangeLineOffset:
 462     case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
 463       W.printNumber(Annotation.Name, Annotation.S1);
 464       break;
 465     case BinaryAnnotationsOpCode::ChangeFile:
 466       if (ObjDelegate) {
 467         W.printHex("ChangeFile",
 468                    ObjDelegate->getFileNameForFileOffset(Annotation.U1),
 469                    Annotation.U1);
 470       } else {
 471         W.printHex("ChangeFile", Annotation.U1);
 472       }
 473
 474       break;
 475     case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset: {
 476       W.startLine() << "ChangeCodeOffsetAndLineOffset: {CodeOffset: "
 477                     << W.hex(Annotation.U1) << ", LineOffset: " << Annotation.S1
 478                     << "}\n";
 479       break;
 480     }
 481     case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset: {
 482       W.startLine() << "ChangeCodeLengthAndCodeOffset: {CodeOffset: "
 483                     << W.hex(Annotation.U2)
 484                     << ", Length: " << W.hex(Annotation.U1) << "}\n";
 485       break;
 486     }
 487     }
 488   }
 489 }
 490
 491 void CVSymbolDumperImpl::visitRegisterSym(SymbolKind Kind,
 492                                           RegisterSym &Register) {
 493   DictScope S(W, "RegisterSym");
 494   W.printNumber("Type", Register.Header.Index);
 495   W.printEnum("Seg", uint16_t(Register.Header.Register), getRegisterNames());
 496   W.printString("Name", Register.Name);
 497 }
 498
 499 void CVSymbolDumperImpl::visitPublicSym32(SymbolKind Kind,
 500                                           PublicSym32 &Public) {
 501   DictScope S(W, "PublicSym");
 502   W.printNumber("Type", Public.Header.Index);
 503   W.printNumber("Seg", Public.Header.Seg);
 504   W.printNumber("Off", Public.Header.Off);
 505   W.printString("Name", Public.Name);
 506 }
 507
 508 void CVSymbolDumperImpl::visitProcRefSym(SymbolKind Kind, ProcRefSym &ProcRef) {
 509   DictScope S(W, "ProcRef");
 510   W.printNumber("SumName", ProcRef.Header.SumName);
 511   W.printNumber("SymOffset", ProcRef.Header.SymOffset);
 512   W.printNumber("Mod", ProcRef.Header.Mod);
 513   W.printString("Name", ProcRef.Name);
 514 }
 515
 516 void CVSymbolDumperImpl::visitLabelSym(SymbolKind Kind, LabelSym &Label) {
 517   DictScope S(W, "Label");
 518
 519   StringRef LinkageName;
 520   if (ObjDelegate) {
 521     ObjDelegate->printRelocatedField("CodeOffset", Label.getRelocationOffset(),
 522                                      Label.Header.CodeOffset, &LinkageName);
 523   }
 524   W.printHex("Segment", Label.Header.Segment);
 525   W.printHex("Flags", Label.Header.Flags);
 526   W.printFlags("Flags", Label.Header.Flags, getProcSymFlagNames());
 527   W.printString("DisplayName", Label.Name);
 528   if (!LinkageName.empty())
 529     W.printString("LinkageName", LinkageName);
 530 }
 531
 532 void CVSymbolDumperImpl::visitLocalSym(SymbolKind Kind, LocalSym &Local) {
 533   DictScope S(W, "Local");
 534
 535   CVTD.printTypeIndex("Type", Local.Header.Type);
 536   W.printFlags("Flags", uint16_t(Local.Header.Flags), getLocalFlagNames());
 537   W.printString("VarName", Local.Name);
 538 }
 539
 540 void CVSymbolDumperImpl::visitObjNameSym(SymbolKind Kind, ObjNameSym &ObjName) {
 541   DictScope S(W, "ObjectName");
 542
 543   W.printHex("Signature", ObjName.Header.Signature);
 544   W.printString("ObjectName", ObjName.Name);
 545 }
 546
 547 void CVSymbolDumperImpl::visitProcSym(SymbolKind Kind, ProcSym &Proc) {
 548   DictScope S(W, "ProcStart");
 549
 550   if (InFunctionScope)
 551     return parseError();
 552
 553   InFunctionScope = true;
 554
 555   StringRef LinkageName;
 556   W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames());
 557   W.printHex("PtrParent", Proc.Header.PtrParent);
 558   W.printHex("PtrEnd", Proc.Header.PtrEnd);
 559   W.printHex("PtrNext", Proc.Header.PtrNext);
 560   W.printHex("CodeSize", Proc.Header.CodeSize);
 561   W.printHex("DbgStart", Proc.Header.DbgStart);
 562   W.printHex("DbgEnd", Proc.Header.DbgEnd);
 563   CVTD.printTypeIndex("FunctionType", Proc.Header.FunctionType);
 564   if (ObjDelegate) {
 565     ObjDelegate->printRelocatedField("CodeOffset", Proc.getRelocationOffset(),
 566                                      Proc.Header.CodeOffset, &LinkageName);
 567   }
 568   W.printHex("Segment", Proc.Header.Segment);
 569   W.printFlags("Flags", static_cast<uint8_t>(Proc.Header.Flags),
 570                getProcSymFlagNames());
 571   W.printString("DisplayName", Proc.Name);
 572   if (!LinkageName.empty())
 573     W.printString("LinkageName", LinkageName);
 574 }
 575
 576 void CVSymbolDumperImpl::visitScopeEndSym(SymbolKind Kind,
 577                                           ScopeEndSym &ScopeEnd) {
 578   if (Kind == SymbolKind::S_END)
 579     DictScope S(W, "BlockEnd");
 580   else if (Kind == SymbolKind::S_PROC_ID_END)
 581     DictScope S(W, "ProcEnd");
 582   else if (Kind == SymbolKind::S_INLINESITE_END)
 583     DictScope S(W, "InlineSiteEnd");
 584
 585   InFunctionScope = false;
 586 }
 587
 588 void CVSymbolDumperImpl::visitCallerSym(SymbolKind Kind, CallerSym &Caller) {
 589   ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers");
 590   for (auto FuncID : Caller.Indices)
 591     CVTD.printTypeIndex("FuncID", FuncID);
 592 }
 593
 594 void CVSymbolDumperImpl::visitRegRelativeSym(SymbolKind Kind,
 595                                              RegRelativeSym &RegRel) {
 596   DictScope S(W, "RegRelativeSym");
 597
 598   W.printHex("Offset", RegRel.Header.Offset);
 599   CVTD.printTypeIndex("Type", RegRel.Header.Type);
 600   W.printHex("Register", RegRel.Header.Register);
 601   W.printString("VarName", RegRel.Name);
 602 }
 603
 604 void CVSymbolDumperImpl::visitThreadLocalDataSym(SymbolKind Kind,
 605                                                  ThreadLocalDataSym &Data) {
 606   DictScope S(W, "ThreadLocalDataSym");
 607
 608   StringRef LinkageName;
 609   if (ObjDelegate) {
 610     ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(),
 611                                      Data.Header.DataOffset, &LinkageName);
 612   }
 613   CVTD.printTypeIndex("Type", Data.Header.Type);
 614   W.printString("DisplayName", Data.Name);
 615   if (!LinkageName.empty())
 616     W.printString("LinkageName", LinkageName);
 617 }
 618
 619 void CVSymbolDumperImpl::visitUDTSym(SymbolKind Kind, UDTSym &UDT) {
 620   DictScope S(W, "UDT");
 621   CVTD.printTypeIndex("Type", UDT.Header.Type);
 622   W.printString("UDTName", UDT.Name);
 623 }
 624
 625 void CVSymbolDumperImpl::visitUnknownSymbol(SymbolKind Kind,
 626                                             ArrayRef<uint8_t> Data) {
 627   DictScope S(W, "UnknownSym");
 628   W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames());
 629   W.printNumber("Length", uint32_t(Data.size()));
 630 }
 631
 632 bool CVSymbolDumper::dump(const CVRecord<SymbolKind> &Record) {
 633   CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes);
 634   Dumper.visitSymbolRecord(Record);
 635   return !Dumper.hadError();
 636 }
 637
 638 bool CVSymbolDumper::dump(const CVSymbolArray &Symbols) {
 639   CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes);
 640   Dumper.visitSymbolStream(Symbols);
 641   return !Dumper.hadError();
 642 }