tools/llvm-pdbutil/BytesOutputStyle.cpp

   1 //===- BytesOutputStyle.cpp ----------------------------------- *- 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 #include "BytesOutputStyle.h"
  10
  11 #include "FormatUtil.h"
  12 #include "StreamUtil.h"
  13 #include "llvm-pdbutil.h"
  14
  15 #include "llvm/DebugInfo/CodeView/Formatters.h"
  16 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  17 #include "llvm/DebugInfo/MSF/MSFCommon.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::Fpm) {
 124     dumpFpm();
 125     P.NewLine();
 126   }
 127
 128   if (!opts::bytes::DumpStreamData.empty()) {
 129     dumpStreamBytes();
 130     P.NewLine();
 131   }
 132
 133   if (opts::bytes::NameMap) {
 134     dumpNameMap();
 135     P.NewLine();
 136   }
 137
 138   if (opts::bytes::SectionContributions) {
 139     dumpSectionContributions();
 140     P.NewLine();
 141   }
 142
 143   if (opts::bytes::SectionMap) {
 144     dumpSectionMap();
 145     P.NewLine();
 146   }
 147
 148   if (opts::bytes::ModuleInfos) {
 149     dumpModuleInfos();
 150     P.NewLine();
 151   }
 152
 153   if (opts::bytes::FileInfo) {
 154     dumpFileInfo();
 155     P.NewLine();
 156   }
 157
 158   if (opts::bytes::TypeServerMap) {
 159     dumpTypeServerMap();
 160     P.NewLine();
 161   }
 162
 163   if (opts::bytes::ECData) {
 164     dumpECData();
 165     P.NewLine();
 166   }
 167
 168   if (!opts::bytes::TypeIndex.empty()) {
 169     dumpTypeIndex(StreamTPI, opts::bytes::TypeIndex);
 170     P.NewLine();
 171   }
 172
 173   if (!opts::bytes::IdIndex.empty()) {
 174     dumpTypeIndex(StreamIPI, opts::bytes::IdIndex);
 175     P.NewLine();
 176   }
 177
 178   if (opts::bytes::ModuleSyms) {
 179     dumpModuleSyms();
 180     P.NewLine();
 181   }
 182
 183   if (opts::bytes::ModuleC11) {
 184     dumpModuleC11();
 185     P.NewLine();
 186   }
 187
 188   if (opts::bytes::ModuleC13) {
 189     dumpModuleC13();
 190     P.NewLine();
 191   }
 192
 193   return Error::success();
 194 }
 195
 196 void BytesOutputStyle::dumpNameMap() {
 197   printHeader(P, "Named Stream Map");
 198
 199   AutoIndent Indent(P);
 200
 201   auto &InfoS = Err(File.getPDBInfoStream());
 202   BinarySubstreamRef NS = InfoS.getNamedStreamsBuffer();
 203   auto Layout = File.getStreamLayout(StreamPDB);
 204   P.formatMsfStreamData("Named Stream Map", File, Layout, NS);
 205 }
 206
 207 void BytesOutputStyle::dumpBlockRanges(uint32_t Min, uint32_t Max) {
 208   printHeader(P, "MSF Blocks");
 209
 210   AutoIndent Indent(P);
 211   for (uint32_t I = Min; I <= Max; ++I) {
 212     uint64_t Base = I;
 213     Base *= File.getBlockSize();
 214
 215     auto ExpectedData = File.getBlockData(I, File.getBlockSize());
 216     if (!ExpectedData) {
 217       P.formatLine("Could not get block {0}.  Reason = {1}", I,
 218                    toString(ExpectedData.takeError()));
 219       continue;
 220     }
 221     std::string Label = formatv("Block {0}", I).str();
 222     P.formatBinary(Label, *ExpectedData, Base, 0);
 223   }
 224 }
 225
 226 void BytesOutputStyle::dumpSectionContributions() {
 227   printHeader(P, "Section Contributions");
 228
 229   AutoIndent Indent(P);
 230
 231   auto &DbiS = Err(File.getPDBDbiStream());
 232   BinarySubstreamRef NS = DbiS.getSectionContributionData();
 233   auto Layout = File.getStreamLayout(StreamDBI);
 234   P.formatMsfStreamData("Section Contributions", File, Layout, NS);
 235 }
 236
 237 void BytesOutputStyle::dumpSectionMap() {
 238   printHeader(P, "Section Map");
 239
 240   AutoIndent Indent(P);
 241
 242   auto &DbiS = Err(File.getPDBDbiStream());
 243   BinarySubstreamRef NS = DbiS.getSecMapSubstreamData();
 244   auto Layout = File.getStreamLayout(StreamDBI);
 245   P.formatMsfStreamData("Section Map", File, Layout, NS);
 246 }
 247
 248 void BytesOutputStyle::dumpModuleInfos() {
 249   printHeader(P, "Module Infos");
 250
 251   AutoIndent Indent(P);
 252
 253   auto &DbiS = Err(File.getPDBDbiStream());
 254   BinarySubstreamRef NS = DbiS.getModiSubstreamData();
 255   auto Layout = File.getStreamLayout(StreamDBI);
 256   P.formatMsfStreamData("Module Infos", File, Layout, NS);
 257 }
 258
 259 void BytesOutputStyle::dumpFileInfo() {
 260   printHeader(P, "File Info");
 261
 262   AutoIndent Indent(P);
 263
 264   auto &DbiS = Err(File.getPDBDbiStream());
 265   BinarySubstreamRef NS = DbiS.getFileInfoSubstreamData();
 266   auto Layout = File.getStreamLayout(StreamDBI);
 267   P.formatMsfStreamData("File Info", File, Layout, NS);
 268 }
 269
 270 void BytesOutputStyle::dumpTypeServerMap() {
 271   printHeader(P, "Type Server Map");
 272
 273   AutoIndent Indent(P);
 274
 275   auto &DbiS = Err(File.getPDBDbiStream());
 276   BinarySubstreamRef NS = DbiS.getTypeServerMapSubstreamData();
 277   auto Layout = File.getStreamLayout(StreamDBI);
 278   P.formatMsfStreamData("Type Server Map", File, Layout, NS);
 279 }
 280
 281 void BytesOutputStyle::dumpECData() {
 282   printHeader(P, "Edit and Continue Data");
 283
 284   AutoIndent Indent(P);
 285
 286   auto &DbiS = Err(File.getPDBDbiStream());
 287   BinarySubstreamRef NS = DbiS.getECSubstreamData();
 288   auto Layout = File.getStreamLayout(StreamDBI);
 289   P.formatMsfStreamData("Edit and Continue Data", File, Layout, NS);
 290 }
 291
 292 void BytesOutputStyle::dumpTypeIndex(uint32_t StreamIdx,
 293                                      ArrayRef<uint32_t> Indices) {
 294   assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI);
 295   assert(!Indices.empty());
 296
 297   bool IsTpi = (StreamIdx == StreamTPI);
 298
 299   StringRef Label = IsTpi ? "Type (TPI) Records" : "Index (IPI) Records";
 300   printHeader(P, Label);
 301   auto &Stream = Err(IsTpi ? File.getPDBTpiStream() : File.getPDBIpiStream());
 302
 303   AutoIndent Indent(P);
 304
 305   auto Substream = Stream.getTypeRecordsSubstream();
 306   auto &Types = Err(initializeTypes(StreamIdx));
 307   auto Layout = File.getStreamLayout(StreamIdx);
 308   for (const auto &Id : Indices) {
 309     TypeIndex TI(Id);
 310     if (TI.toArrayIndex() >= Types.capacity()) {
 311       P.formatLine("Error: TypeIndex {0} does not exist", TI);
 312       continue;
 313     }
 314
 315     auto Type = Types.getType(TI);
 316     uint32_t Offset = Types.getOffsetOfType(TI);
 317     auto OneType = Substream.slice(Offset, Type.length());
 318     P.formatMsfStreamData(formatv("Type {0}", TI).str(), File, Layout, OneType);
 319   }
 320 }
 321
 322 template <typename CallbackT>
 323 static void iterateOneModule(PDBFile &File, LinePrinter &P,
 324                              const DbiModuleList &Modules, uint32_t I,
 325                              uint32_t Digits, uint32_t IndentLevel,
 326                              CallbackT Callback) {
 327   if (I >= Modules.getModuleCount()) {
 328     P.formatLine("Mod {0:4} | Invalid module index ",
 329                  fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)));
 330     return;
 331   }
 332
 333   auto Modi = Modules.getModuleDescriptor(I);
 334   P.formatLine("Mod {0:4} | `{1}`: ",
 335                fmt_align(I, AlignStyle::Right, std::max(Digits, 4U)),
 336                Modi.getModuleName());
 337
 338   uint16_t ModiStream = Modi.getModuleStreamIndex();
 339   AutoIndent Indent2(P, IndentLevel);
 340   if (ModiStream == kInvalidStreamIndex)
 341     return;
 342
 343   auto ModStreamData = File.createIndexedStream(ModiStream);
 344   ModuleDebugStreamRef ModStream(Modi, std::move(ModStreamData));
 345   if (auto EC = ModStream.reload()) {
 346     P.formatLine("Could not parse debug information.");
 347     return;
 348   }
 349   auto Layout = File.getStreamLayout(ModiStream);
 350   Callback(I, ModStream, Layout);
 351 }
 352
 353 template <typename CallbackT>
 354 static void iterateModules(PDBFile &File, LinePrinter &P, uint32_t IndentLevel,
 355                            CallbackT Callback) {
 356   AutoIndent Indent(P);
 357   if (!File.hasPDBDbiStream()) {
 358     P.formatLine("DBI Stream not present");
 359     return;
 360   }
 361
 362   ExitOnError Err("Unexpected error processing modules");
 363
 364   auto &Stream = Err(File.getPDBDbiStream());
 365
 366   const DbiModuleList &Modules = Stream.modules();
 367
 368   if (opts::bytes::ModuleIndex.getNumOccurrences() > 0) {
 369     iterateOneModule(File, P, Modules, opts::bytes::ModuleIndex, 1, IndentLevel,
 370                      Callback);
 371   } else {
 372     uint32_t Count = Modules.getModuleCount();
 373     uint32_t Digits = NumDigits(Count);
 374     for (uint32_t I = 0; I < Count; ++I) {
 375       iterateOneModule(File, P, Modules, I, Digits, IndentLevel, Callback);
 376     }
 377   }
 378 }
 379
 380 void BytesOutputStyle::dumpModuleSyms() {
 381   printHeader(P, "Module Symbols");
 382
 383   AutoIndent Indent(P);
 384
 385   iterateModules(File, P, 2,
 386                  [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 387                         const MSFStreamLayout &Layout) {
 388                    auto Symbols = Stream.getSymbolsSubstream();
 389                    P.formatMsfStreamData("Symbols", File, Layout, Symbols);
 390                  });
 391 }
 392
 393 void BytesOutputStyle::dumpModuleC11() {
 394   printHeader(P, "C11 Debug Chunks");
 395
 396   AutoIndent Indent(P);
 397
 398   iterateModules(File, P, 2,
 399                  [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 400                         const MSFStreamLayout &Layout) {
 401                    auto Chunks = Stream.getC11LinesSubstream();
 402                    P.formatMsfStreamData("C11 Debug Chunks", File, Layout,
 403                                          Chunks);
 404                  });
 405 }
 406
 407 void BytesOutputStyle::dumpModuleC13() {
 408   printHeader(P, "Debug Chunks");
 409
 410   AutoIndent Indent(P);
 411
 412   iterateModules(
 413       File, P, 2,
 414       [this](uint32_t Modi, const ModuleDebugStreamRef &Stream,
 415              const MSFStreamLayout &Layout) {
 416         auto Chunks = Stream.getC13LinesSubstream();
 417         if (opts::bytes::SplitChunks) {
 418           for (const auto &SS : Stream.subsections()) {
 419             BinarySubstreamRef ThisChunk;
 420             std::tie(ThisChunk, Chunks) = Chunks.split(SS.getRecordLength());
 421             P.formatMsfStreamData(formatChunkKind(SS.kind()), File, Layout,
 422                                   ThisChunk);
 423           }
 424         } else {
 425           P.formatMsfStreamData("Debug Chunks", File, Layout, Chunks);
 426         }
 427       });
 428 }
 429
 430 void BytesOutputStyle::dumpByteRanges(uint32_t Min, uint32_t Max) {
 431   printHeader(P, "MSF Bytes");
 432
 433   AutoIndent Indent(P);
 434
 435   BinaryStreamReader Reader(File.getMsfBuffer());
 436   ArrayRef<uint8_t> Data;
 437   consumeError(Reader.skip(Min));
 438   uint32_t Size = Max - Min + 1;
 439   auto EC = Reader.readBytes(Data, Size);
 440   assert(!EC);
 441   consumeError(std::move(EC));
 442   P.formatBinary("Bytes", Data, Min);
 443 }
 444
 445 Expected<codeview::LazyRandomTypeCollection &>
 446 BytesOutputStyle::initializeTypes(uint32_t StreamIdx) {
 447   auto &TypeCollection = (StreamIdx == StreamTPI) ? TpiTypes : IpiTypes;
 448   if (TypeCollection)
 449     return *TypeCollection;
 450
 451   auto Tpi = (StreamIdx == StreamTPI) ? File.getPDBTpiStream()
 452                                       : File.getPDBIpiStream();
 453   if (!Tpi)
 454     return Tpi.takeError();
 455
 456   auto &Types = Tpi->typeArray();
 457   uint32_t Count = Tpi->getNumTypeRecords();
 458   auto Offsets = Tpi->getTypeIndexOffsets();
 459   TypeCollection =
 460       std::make_unique<LazyRandomTypeCollection>(Types, Count, Offsets);
 461
 462   return *TypeCollection;
 463 }
 464
 465 void BytesOutputStyle::dumpFpm() {
 466   printHeader(P, "Free Page Map");
 467
 468   msf::MSFStreamLayout FpmLayout = File.getFpmStreamLayout();
 469   P.formatMsfStreamBlocks(File, FpmLayout);
 470 }
 471
 472 void BytesOutputStyle::dumpStreamBytes() {
 473   if (StreamPurposes.empty())
 474     discoverStreamPurposes(File, StreamPurposes);
 475
 476   printHeader(P, "Stream Data");
 477   ExitOnError Err("Unexpected error reading stream data");
 478
 479   auto Specs = parseStreamSpecs(P);
 480
 481   for (const auto &Spec : Specs) {
 482     AutoIndent Indent(P);
 483     if (Spec.SI >= StreamPurposes.size()) {
 484       P.formatLine("Stream {0}: Not present", Spec.SI);
 485       continue;
 486     }
 487     P.formatMsfStreamData("Data", File, Spec.SI,
 488                           StreamPurposes[Spec.SI].getShortName(), Spec.Begin,
 489                           Spec.Size);
 490   }
 491 }