contrib/llvm/tools/llvm-pdbutil/BytesOutputStyle.cpp

   1 //===- BytesOutputStyle.cpp ----------------------------------- *- 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 "BytesOutputStyle.h"
  11
  12 #include "FormatUtil.h"
  13 #include "StreamUtil.h"
  14 #include "llvm-pdbutil.h"
  15
  16 #include "llvm/DebugInfo/CodeView/Formatters.h"
  17 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  18 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
  19 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  20 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  21 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
  22 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  23 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  24 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  25 #include "llvm/Support/BinaryStreamReader.h"
  26 #include "llvm/Support/FormatAdapters.h"
  27 #include "llvm/Support/FormatVariadic.h"
  28
  29 using namespace llvm;
  30 using namespace llvm::codeview;
  31 using namespace llvm::msf;
  32 using namespace llvm::pdb;
  33
  34 namespace {
  35 struct StreamSpec {
  36   uint32_t SI = 0;
  37   uint32_t Begin = 0;
  38   uint32_t Size = 0;
  39 };
  40 } // namespace
  41
  42 static Expected<StreamSpec> parseStreamSpec(StringRef Str) {
  43   StreamSpec Result;
  44   if (Str.consumeInteger(0, Result.SI))
  45     return make_error<RawError>(raw_error_code::invalid_format,
  46                                 "Invalid Stream Specification");
  47   if (Str.consume_front(":")) {
  48     if (Str.consumeInteger(0, Result.Begin))
  49       return make_error<RawError>(raw_error_code::invalid_format,
  50                                   "Invalid Stream Specification");
  51   }
  52   if (Str.consume_front("@")) {
  53     if (Str.consumeInteger(0, Result.Size))
  54       return make_error<RawError>(raw_error_code::invalid_format,
  55                                   "Invalid Stream Specification");
  56   }
  57
  58   if (!Str.empty())
  59     return make_error<RawError>(raw_error_code::invalid_format,
  60                                 "Invalid Stream Specification");
  61   return Result;
  62 }
  63
  64 static SmallVector<StreamSpec, 2> parseStreamSpecs(LinePrinter &P) {
  65   SmallVector<StreamSpec, 2> Result;
  66
  67   for (auto &Str : opts::bytes::DumpStreamData) {
  68     auto ESS = parseStreamSpec(Str);
  69     if (!ESS) {
  70       P.formatLine("Error parsing stream spec {0}: {1}", Str,
  71                    toString(ESS.takeError()));
  72       continue;
  73     }
  74     Result.push_back(*ESS);
  75   }
  76   return Result;
  77 }
  78
  79 static void printHeader(LinePrinter &P, const Twine &S) {
  80   P.NewLine();
  81   P.formatLine("{0,=60}", S);
  82   P.formatLine("{0}", fmt_repeat('=', 60));
  83 }
  84
  85 BytesOutputStyle::BytesOutputStyle(PDBFile &File)
  86     : File(File), P(2, false, outs()) {}
  87
  88 Error BytesOutputStyle::dump() {
  89
  90   if (opts::bytes::DumpBlockRange.hasValue()) {
  91     auto &R = *opts::bytes::DumpBlockRange;
  92     uint32_t Max = R.Max.getValueOr(R.Min);
  93
  94     if (Max < R.Min)
  95       return make_error<StringError>(
  96           "Invalid block range specified.  Max < Min",
  97           inconvertibleErrorCode());
  98     if (Max >= File.getBlockCount())
  99       return make_error<StringError>(
 100           "Invalid block range specified.  Requested block out of bounds",
 101           inconvertibleErrorCode());
 102
 103     dumpBlockRanges(R.Min, Max);
 104     P.NewLine();
 105   }
 106
 107   if (opts::bytes::DumpByteRange.hasValue()) {
 108     auto &R = *opts::bytes::DumpByteRange;
 109     uint32_t Max = R.Max.getValueOr(File.getFileSize());
 110
 111     if (Max < R.Min)
 112       return make_error<StringError>("Invalid byte range specified.  Max < Min",
 113                                      inconvertibleErrorCode());
 114     if (Max >= File.getFileSize())
 115       return make_error<StringError>(
 116           "Invalid byte range specified.  Requested byte larger than file size",
 117           inconvertibleErrorCode());
 118
 119     dumpByteRanges(R.Min, Max);
 120     P.NewLine();
 121   }
 122
 123   if (!opts::bytes::DumpStreamData.empty()) {
 124     dumpStreamBytes();
 125     P.NewLine();
 126   }
 127
 128   if (opts::bytes::NameMap) {
 129     dumpNameMap();
 130     P.NewLine();
 131   }
 132
 133   if (opts::bytes::SectionContributions) {
 134     dumpSectionContributions();
 135     P.NewLine();
 136   }
 137
 138   if (opts::bytes::SectionMap) {
 139     dumpSectionMap();
 140     P.NewLine();
 141   }
 142
 143   if (opts::bytes::ModuleInfos) {
 144     dumpModuleInfos();
 145     P.NewLine();
 146   }
 147
 148   if (opts::bytes::FileInfo) {
 149     dumpFileInfo();
 150     P.NewLine();
 151   }
 152
 153   if (opts::bytes::TypeServerMap) {
 154     dumpTypeServerMap();
 155     P.NewLine();
 156   }
 157
 158   if (opts::bytes::ECData) {
 159     dumpECData();
 160     P.NewLine();
 161   }
 162
 163   if (!opts::bytes::TypeIndex.empty()) {
 164     dumpTypeIndex(StreamTPI, opts::bytes::TypeIndex);
 165     P.NewLine();
 166   }
 167
 168   if (!opts::bytes::IdIndex.empty()) {
 169     dumpTypeIndex(StreamIPI, opts::bytes::IdIndex);
 170     P.NewLine();
 171   }
 172
 173   if (opts::bytes::ModuleSyms) {
 174     dumpModuleSyms();
 175     P.NewLine();
 176   }
 177
 178   if (opts::bytes::ModuleC11) {
 179     dumpModuleC11();
 180     P.NewLine();
 181   }
 182
 183   if (opts::bytes::ModuleC13) {
 184     dumpModuleC13();
 185     P.NewLine();
 186   }
 187
 188   return Error::success();
 189 }
 190
 191 void BytesOutputStyle::dumpNameMap() {
 192   printHeader(P, "Named Stream Map");
 193
 194   AutoIndent Indent(P);
 195
 196   auto &InfoS = Err(File.getPDBInfoStream());
 197   BinarySubstreamRef NS = InfoS.getNamedStreamsBuffer();
 198   auto Layout = File.getStreamLayout(StreamPDB);
 199   P.formatMsfStreamData("Named Stream Map", File, Layout, NS);
 200 }
 201
 202 void BytesOutputStyle::dumpBlockRanges(uint32_t Min, uint32_t Max) {
 203   printHeader(P, "MSF Blocks");
 204
 205   AutoIndent Indent(P);
 206   for (uint32_t I = Min; I <= Max; ++I) {
 207     uint64_t Base = I;
 208     Base *= File.getBlockSize();
 209
 210     auto ExpectedData = File.getBlockData(I, File.getBlockSize());
 211     if (!ExpectedData) {
 212       P.formatLine("Could not get block {0}.  Reason = {1}", I,
 213                    toString(ExpectedData.takeError()));
 214       continue;
 215     }
 216     std::string Label = formatv("Block {0}", I).str();
 217     P.formatBinary(Label, *ExpectedData, Base, 0);
 218   }
 219 }
 220
 221 void BytesOutputStyle::dumpSectionContributions() {
 222   printHeader(P, "Section Contributions");
 223
 224   AutoIndent Indent(P);
 225
 226   auto &DbiS = Err(File.getPDBDbiStream());
 227   BinarySubstreamRef NS = DbiS.getSectionContributionData();
 228   auto Layout = File.getStreamLayout(StreamDBI);
 229   P.formatMsfStreamData("Section Contributions", File, Layout, NS);
 230 }
 231
 232 void BytesOutputStyle::dumpSectionMap() {
 233   printHeader(P, "Section Map");
 234
 235   AutoIndent Indent(P);
 236
 237   auto &DbiS = Err(File.getPDBDbiStream());
 238   BinarySubstreamRef NS = DbiS.getSecMapSubstreamData();
 239   auto Layout = File.getStreamLayout(StreamDBI);
 240   P.formatMsfStreamData("Section Map", File, Layout, NS);
 241 }
 242
 243 void BytesOutputStyle::dumpModuleInfos() {
 244   printHeader(P, "Module Infos");
 245
 246   AutoIndent Indent(P);
 247
 248   auto &DbiS = Err(File.getPDBDbiStream());
 249   BinarySubstreamRef NS = DbiS.getModiSubstreamData();
 250   auto Layout = File.getStreamLayout(StreamDBI);
 251   P.formatMsfStreamData("Module Infos", File, Layout, NS);
 252 }
 253
 254 void BytesOutputStyle::dumpFileInfo() {
 255   printHeader(P, "File Info");
 256
 257   AutoIndent Indent(P);
 258
 259   auto &DbiS = Err(File.getPDBDbiStream());
 260   BinarySubstreamRef NS = DbiS.getFileInfoSubstreamData();
 261   auto Layout = File.getStreamLayout(StreamDBI);
 262   P.formatMsfStreamData("File Info", File, Layout, NS);
 263 }
 264
 265 void BytesOutputStyle::dumpTypeServerMap() {
 266   printHeader(P, "Type Server Map");
 267
 268   AutoIndent Indent(P);
 269
 270   auto &DbiS = Err(File.getPDBDbiStream());
 271   BinarySubstreamRef NS = DbiS.getTypeServerMapSubstreamData();
 272   auto Layout = File.getStreamLayout(StreamDBI);
 273   P.formatMsfStreamData("Type Server Map", File, Layout, NS);
 274 }
 275
 276 void BytesOutputStyle::dumpECData() {
 277   printHeader(P, "Edit and Continue Data");
 278
 279   AutoIndent Indent(P);
 280
 281   auto &DbiS = Err(File.getPDBDbiStream());
 282   BinarySubstreamRef NS = DbiS.getECSubstreamData();
 283   auto Layout = File.getStreamLayout(StreamDBI);
 284   P.formatMsfStreamData("Edit and Continue Data", File, Layout, NS);
 285 }
 286
 287 void BytesOutputStyle::dumpTypeIndex(uint32_t StreamIdx,
 288                                      ArrayRef<uint32_t> Indices) {
 289   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 290   assert(!Indices.empty());
 291
 292   bool IsTpi = (StreamIdx == StreamTPI);
 293
 294   StringRef Label = IsTpi ? "Type (TPI) Records" : "Index (IPI) Records";
 295   printHeader(P, Label);
 296   auto &Stream = Err(IsTpi ? File.getPDBTpiStream() : File.getPDBIpiStream());
 297
 298   AutoIndent Indent(P);
 299
 300   auto Substream = Stream.getTypeRecordsSubstream();
 301   auto &Types = Err(initializeTypes(StreamIdx));
 302   auto Layout = File.getStreamLayout(StreamIdx);
 303   for (const auto &Id : Indices) {
 304     TypeIndex TI(Id);
 305     if (TI.toArrayIndex() >= Types.capacity()) {
 306       P.formatLine("Error: TypeIndex {0} does not exist", TI);
 307       continue;
 308     }
 309
 310     auto Type = Types.getType(TI);
 311     uint32_t Offset = Types.getOffsetOfType(TI);
 312     auto OneType = Substream.slice(Offset, Type.length());
 313     P.formatMsfStreamData(formatv("Type {0}", TI).str(), File, Layout, OneType);
 314   }
 315 }
 316
 317 template <typename CallbackT>
 318 static void iterateOneModule(PDBFile &File, LinePrinter &P,
 319                              const DbiModuleList &Modules, uint32_t I,
 320                              uint32_t Digits, uint32_t IndentLevel,
 321                              CallbackT Callback) {
 322   if (I >= Modules.getModuleCount()) {
 323     P.formatLine("Mod {0:4} | Invalid module index ",
 324                  fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)));
 325     return;
 326   }
 327
 328   auto Modi = Modules.getModuleDescriptor(I);
 329   P.formatLine("Mod {0:4} | `{1}`: ",
 330                fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)),
 331                Modi.getModuleName());
 332
 333   uint16_t ModiStream = Modi.getModuleStreamIndex();
 334   AutoIndent Indent2(P, IndentLevel);
 335   if (ModiStream == kInvalidStreamIndex)
 336     return;
 337
 338   auto ModStreamData = MappedBlockStream::createIndexedStream(
 339       File.getMsfLayout(), File.getMsfBuffer(), ModiStream,
 340       File.getAllocator());
 341   ModuleDebugStreamRef ModStream(Modi, std::move(ModStreamData));
 342   if (auto EC = ModStream.reload()) {
 343     P.formatLine("Could not parse debug information.");
 344     return;
 345   }
 346   auto Layout = File.getStreamLayout(ModiStream);
 347   Callback(I, ModStream, Layout);
 348 }
 349
 350 template <typename CallbackT>
 351 static void iterateModules(PDBFile &File, LinePrinter &P, uint32_t IndentLevel,
 352                            CallbackT Callback) {
 353   AutoIndent Indent(P);
 354   if (!File.hasPDBDbiStream()) {
 355     P.formatLine("DBI Stream not present");
 356     return;
 357   }
 358
 359   ExitOnError Err("Unexpected error processing modules");
 360
 361   auto &Stream = Err(File.getPDBDbiStream());
 362
 363   const DbiModuleList &Modules = Stream.modules();
 364
 365   if (opts::bytes::ModuleIndex.getNumOccurrences() > 0) {
 366     iterateOneModule(File, P, Modules, opts::bytes::ModuleIndex, 1, IndentLevel,
 367                      Callback);
 368   } else {
 369     uint32_t Count = Modules.getModuleCount();
 370     uint32_t Digits = NumDigits(Count);
 371     for (uint32_t I = 0; I < Count; ++I) {
 372       iterateOneModule(File, P, Modules, I, Digits, IndentLevel, Callback);
 373     }
 374   }
 375 }
 376
 377 void BytesOutputStyle::dumpModuleSyms() {
 378   printHeader(P, "Module Symbols");
 379
 380   AutoIndent Indent(P);
 381
 382   iterateModules(File, P, 2,
 383                  [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 384                         const MSFStreamLayout &Layout) {
 385                    auto Symbols = Stream.getSymbolsSubstream();
 386                    P.formatMsfStreamData("Symbols", File, Layout, Symbols);
 387                  });
 388 }
 389
 390 void BytesOutputStyle::dumpModuleC11() {
 391   printHeader(P, "C11 Debug Chunks");
 392
 393   AutoIndent Indent(P);
 394
 395   iterateModules(File, P, 2,
 396                  [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 397                         const MSFStreamLayout &Layout) {
 398                    auto Chunks = Stream.getC11LinesSubstream();
 399                    P.formatMsfStreamData("C11 Debug Chunks", File, Layout,
 400                                          Chunks);
 401                  });
 402 }
 403
 404 static std::string formatChunkKind(DebugSubsectionKind Kind) {
 405   switch (Kind) {
 406     RETURN_CASE(DebugSubsectionKind, None, "none");
 407     RETURN_CASE(DebugSubsectionKind, Symbols, "symbols");
 408     RETURN_CASE(DebugSubsectionKind, Lines, "lines");
 409     RETURN_CASE(DebugSubsectionKind, StringTable, "strings");
 410     RETURN_CASE(DebugSubsectionKind, FileChecksums, "checksums");
 411     RETURN_CASE(DebugSubsectionKind, FrameData, "frames");
 412     RETURN_CASE(DebugSubsectionKind, InlineeLines, "inlinee lines");
 413     RETURN_CASE(DebugSubsectionKind, CrossScopeImports, "xmi");
 414     RETURN_CASE(DebugSubsectionKind, CrossScopeExports, "xme");
 415     RETURN_CASE(DebugSubsectionKind, ILLines, "il lines");
 416     RETURN_CASE(DebugSubsectionKind, FuncMDTokenMap, "func md token map");
 417     RETURN_CASE(DebugSubsectionKind, TypeMDTokenMap, "type md token map");
 418     RETURN_CASE(DebugSubsectionKind, MergedAssemblyInput,
 419                 "merged assembly input");
 420     RETURN_CASE(DebugSubsectionKind, CoffSymbolRVA, "coff symbol rva");
 421   }
 422   return formatUnknownEnum(Kind);
 423 }
 424
 425 void BytesOutputStyle::dumpModuleC13() {
 426   printHeader(P, "Debug Chunks");
 427
 428   AutoIndent Indent(P);
 429
 430   iterateModules(
 431       File, P, 2,
 432       [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 433              const MSFStreamLayout &Layout) {
 434         auto Chunks = Stream.getC13LinesSubstream();
 435         if (opts::bytes::SplitChunks) {
 436           for (const auto &SS : Stream.subsections()) {
 437             BinarySubstreamRef ThisChunk;
 438             std::tie(ThisChunk, Chunks) = Chunks.split(SS.getRecordLength());
 439             P.formatMsfStreamData(formatChunkKind(SS.kind()), File, Layout,
 440                                   ThisChunk);
 441           }
 442         } else {
 443           P.formatMsfStreamData("Debug Chunks", File, Layout, Chunks);
 444         }
 445       });
 446 }
 447
 448 void BytesOutputStyle::dumpByteRanges(uint32_t Min, uint32_t Max) {
 449   printHeader(P, "MSF Bytes");
 450
 451   AutoIndent Indent(P);
 452
 453   BinaryStreamReader Reader(File.getMsfBuffer());
 454   ArrayRef<uint8_t> Data;
 455   consumeError(Reader.skip(Min));
 456   uint32_t Size = Max - Min + 1;
 457   auto EC = Reader.readBytes(Data, Size);
 458   assert(!EC);
 459   consumeError(std::move(EC));
 460   P.formatBinary("Bytes", Data, Min);
 461 }
 462
 463 Expected<codeview::LazyRandomTypeCollection &>
 464 BytesOutputStyle::initializeTypes(uint32_t StreamIdx) {
 465   auto &TypeCollection = (StreamIdx == StreamTPI) ? TpiTypes : IpiTypes;
 466   if (TypeCollection)
 467     return *TypeCollection;
 468
 469   auto Tpi = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
 470                                       : File.getPDBIpiStream();
 471   if (!Tpi)
 472     return Tpi.takeError();
 473
 474   auto &Types = Tpi->typeArray();
 475   uint32_t Count = Tpi->getNumTypeRecords();
 476   auto Offsets = Tpi->getTypeIndexOffsets();
 477   TypeCollection =
 478       llvm::make_unique<LazyRandomTypeCollection>(Types, Count, Offsets);
 479
 480   return *TypeCollection;
 481 }
 482
 483 void BytesOutputStyle::dumpStreamBytes() {
 484   if (StreamPurposes.empty())
 485     discoverStreamPurposes(File, StreamPurposes);
 486
 487   printHeader(P, "Stream Data");
 488   ExitOnError Err("Unexpected error reading stream data");
 489
 490   auto Specs = parseStreamSpecs(P);
 491
 492   for (const auto &Spec : Specs) {
 493     AutoIndent Indent(P);
 494     if (Spec.SI >= StreamPurposes.size()) {
 495       P.formatLine("Stream {0}: Not present", Spec.SI);
 496       continue;
 497     }
 498     P.formatMsfStreamData("Data", File, Spec.SI, StreamPurposes[Spec.SI],
 499                           Spec.Begin, Spec.Size);
 500   }
 501 }