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