llvm/tools/llvm-pdbutil/InputFile.cpp

   1 //===- InputFile.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 "InputFile.h"
  10
  11 #include "FormatUtil.h"
  12 #include "LinePrinter.h"
  13
  14 #include "llvm/BinaryFormat/Magic.h"
  15 #include "llvm/DebugInfo/CodeView/CodeView.h"
  16 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  17 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
  18 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  19 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
  20 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  21 #include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
  22 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  23 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  24 #include "llvm/DebugInfo/PDB/PDB.h"
  25 #include "llvm/Object/COFF.h"
  26 #include "llvm/Support/FileSystem.h"
  27 #include "llvm/Support/FormatVariadic.h"
  28
  29 using namespace llvm;
  30 using namespace llvm::codeview;
  31 using namespace llvm::object;
  32 using namespace llvm::pdb;
  33
  34 InputFile::InputFile() {}
  35 InputFile::~InputFile() {}
  36
  37 static Expected<ModuleDebugStreamRef>
  38 getModuleDebugStream(PDBFile &File, StringRef &ModuleName, uint32_t Index) {
  39   ExitOnError Err("Unexpected error: ");
  40
  41   auto &Dbi = Err(File.getPDBDbiStream());
  42   const auto &Modules = Dbi.modules();
  43   if (Index >= Modules.getModuleCount())
  44     return make_error<RawError>(raw_error_code::index_out_of_bounds,
  45                                 "Invalid module index");
  46
  47   auto Modi = Modules.getModuleDescriptor(Index);
  48
  49   ModuleName = Modi.getModuleName();
  50
  51   uint16_t ModiStream = Modi.getModuleStreamIndex();
  52   if (ModiStream == kInvalidStreamIndex)
  53     return make_error<RawError>(raw_error_code::no_stream,
  54                                 "Module stream not present");
  55
  56   auto ModStreamData = File.createIndexedStream(ModiStream);
  57
  58   ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
  59   if (auto EC = ModS.reload())
  60     return make_error<RawError>(raw_error_code::corrupt_file,
  61                                 "Invalid module stream");
  62
  63   return std::move(ModS);
  64 }
  65
  66 static inline bool isCodeViewDebugSubsection(object::SectionRef Section,
  67                                              StringRef Name,
  68                                              BinaryStreamReader &Reader) {
  69   if (Expected<StringRef> NameOrErr = Section.getName()) {
  70     if (*NameOrErr != Name)
  71       return false;
  72   } else {
  73     consumeError(NameOrErr.takeError());
  74     return false;
  75   }
  76
  77   Expected<StringRef> ContentsOrErr = Section.getContents();
  78   if (!ContentsOrErr) {
  79     consumeError(ContentsOrErr.takeError());
  80     return false;
  81   }
  82
  83   Reader = BinaryStreamReader(*ContentsOrErr, support::little);
  84   uint32_t Magic;
  85   if (Reader.bytesRemaining() < sizeof(uint32_t))
  86     return false;
  87   cantFail(Reader.readInteger(Magic));
  88   if (Magic != COFF::DEBUG_SECTION_MAGIC)
  89     return false;
  90   return true;
  91 }
  92
  93 static inline bool isDebugSSection(object::SectionRef Section,
  94                                    DebugSubsectionArray &Subsections) {
  95   BinaryStreamReader Reader;
  96   if (!isCodeViewDebugSubsection(Section, ".debug$S", Reader))
  97     return false;
  98
  99   cantFail(Reader.readArray(Subsections, Reader.bytesRemaining()));
 100   return true;
 101 }
 102
 103 static bool isDebugTSection(SectionRef Section, CVTypeArray &Types) {
 104   BinaryStreamReader Reader;
 105   if (!isCodeViewDebugSubsection(Section, ".debug$T", Reader) &&
 106       !isCodeViewDebugSubsection(Section, ".debug$P", Reader))
 107     return false;
 108   cantFail(Reader.readArray(Types, Reader.bytesRemaining()));
 109   return true;
 110 }
 111
 112 static std::string formatChecksumKind(FileChecksumKind Kind) {
 113   switch (Kind) {
 114     RETURN_CASE(FileChecksumKind, None, "None");
 115     RETURN_CASE(FileChecksumKind, MD5, "MD5");
 116     RETURN_CASE(FileChecksumKind, SHA1, "SHA-1");
 117     RETURN_CASE(FileChecksumKind, SHA256, "SHA-256");
 118   }
 119   return formatUnknownEnum(Kind);
 120 }
 121
 122 template <typename... Args>
 123 static void formatInternal(LinePrinter &Printer, bool Append, Args &&... args) {
 124   if (Append)
 125     Printer.format(std::forward<Args>(args)...);
 126   else
 127     Printer.formatLine(std::forward<Args>(args)...);
 128 }
 129
 130 SymbolGroup::SymbolGroup(InputFile *File, uint32_t GroupIndex) : File(File) {
 131   if (!File)
 132     return;
 133
 134   if (File->isPdb())
 135     initializeForPdb(GroupIndex);
 136   else {
 137     Name = ".debug$S";
 138     uint32_t I = 0;
 139     for (const auto &S : File->obj().sections()) {
 140       DebugSubsectionArray SS;
 141       if (!isDebugSSection(S, SS))
 142         continue;
 143
 144       if (!SC.hasChecksums() || !SC.hasStrings())
 145         SC.initialize(SS);
 146
 147       if (I == GroupIndex)
 148         Subsections = SS;
 149
 150       if (SC.hasChecksums() && SC.hasStrings())
 151         break;
 152     }
 153     rebuildChecksumMap();
 154   }
 155 }
 156
 157 StringRef SymbolGroup::name() const { return Name; }
 158
 159 void SymbolGroup::updateDebugS(const codeview::DebugSubsectionArray &SS) {
 160   Subsections = SS;
 161 }
 162
 163 void SymbolGroup::updatePdbModi(uint32_t Modi) { initializeForPdb(Modi); }
 164
 165 void SymbolGroup::initializeForPdb(uint32_t Modi) {
 166   assert(File && File->isPdb());
 167
 168   // PDB always uses the same string table, but each module has its own
 169   // checksums.  So we only set the strings if they're not already set.
 170   if (!SC.hasStrings()) {
 171     auto StringTable = File->pdb().getStringTable();
 172     if (StringTable)
 173       SC.setStrings(StringTable->getStringTable());
 174     else
 175       consumeError(StringTable.takeError());
 176   }
 177
 178   SC.resetChecksums();
 179   auto MDS = getModuleDebugStream(File->pdb(), Name, Modi);
 180   if (!MDS) {
 181     consumeError(MDS.takeError());
 182     return;
 183   }
 184
 185   DebugStream = std::make_shared<ModuleDebugStreamRef>(std::move(*MDS));
 186   Subsections = DebugStream->getSubsectionsArray();
 187   SC.initialize(Subsections);
 188   rebuildChecksumMap();
 189 }
 190
 191 void SymbolGroup::rebuildChecksumMap() {
 192   if (!SC.hasChecksums())
 193     return;
 194
 195   for (const auto &Entry : SC.checksums()) {
 196     auto S = SC.strings().getString(Entry.FileNameOffset);
 197     if (!S)
 198       continue;
 199     ChecksumsByFile[*S] = Entry;
 200   }
 201 }
 202
 203 const ModuleDebugStreamRef &SymbolGroup::getPdbModuleStream() const {
 204   assert(File && File->isPdb() && DebugStream);
 205   return *DebugStream;
 206 }
 207
 208 Expected<StringRef> SymbolGroup::getNameFromStringTable(uint32_t Offset) const {
 209   return SC.strings().getString(Offset);
 210 }
 211
 212 void SymbolGroup::formatFromFileName(LinePrinter &Printer, StringRef File,
 213                                      bool Append) const {
 214   auto FC = ChecksumsByFile.find(File);
 215   if (FC == ChecksumsByFile.end()) {
 216     formatInternal(Printer, Append, "- (no checksum) {0}", File);
 217     return;
 218   }
 219
 220   formatInternal(Printer, Append, "- ({0}: {1}) {2}",
 221                  formatChecksumKind(FC->getValue().Kind),
 222                  toHex(FC->getValue().Checksum), File);
 223 }
 224
 225 void SymbolGroup::formatFromChecksumsOffset(LinePrinter &Printer,
 226                                             uint32_t Offset,
 227                                             bool Append) const {
 228   if (!SC.hasChecksums()) {
 229     formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 230     return;
 231   }
 232
 233   auto Iter = SC.checksums().getArray().at(Offset);
 234   if (Iter == SC.checksums().getArray().end()) {
 235     formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 236     return;
 237   }
 238
 239   uint32_t FO = Iter->FileNameOffset;
 240   auto ExpectedFile = getNameFromStringTable(FO);
 241   if (!ExpectedFile) {
 242     formatInternal(Printer, Append, "(unknown file name offset {0})", Offset);
 243     consumeError(ExpectedFile.takeError());
 244     return;
 245   }
 246   if (Iter->Kind == FileChecksumKind::None) {
 247     formatInternal(Printer, Append, "{0} (no checksum)", *ExpectedFile);
 248   } else {
 249     formatInternal(Printer, Append, "{0} ({1}: {2})", *ExpectedFile,
 250                    formatChecksumKind(Iter->Kind), toHex(Iter->Checksum));
 251   }
 252 }
 253
 254 Expected<InputFile> InputFile::open(StringRef Path, bool AllowUnknownFile) {
 255   InputFile IF;
 256   if (!llvm::sys::fs::exists(Path))
 257     return make_error<StringError>(formatv("File {0} not found", Path),
 258                                    inconvertibleErrorCode());
 259
 260   file_magic Magic;
 261   if (auto EC = identify_magic(Path, Magic))
 262     return make_error<StringError>(
 263         formatv("Unable to identify file type for file {0}", Path), EC);
 264
 265   if (Magic == file_magic::coff_object) {
 266     Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(Path);
 267     if (!BinaryOrErr)
 268       return BinaryOrErr.takeError();
 269
 270     IF.CoffObject = std::move(*BinaryOrErr);
 271     IF.PdbOrObj = llvm::cast<COFFObjectFile>(IF.CoffObject.getBinary());
 272     return std::move(IF);
 273   }
 274
 275   if (Magic == file_magic::pdb) {
 276     std::unique_ptr<IPDBSession> Session;
 277     if (auto Err = loadDataForPDB(PDB_ReaderType::Native, Path, Session))
 278       return std::move(Err);
 279
 280     IF.PdbSession.reset(static_cast<NativeSession *>(Session.release()));
 281     IF.PdbOrObj = &IF.PdbSession->getPDBFile();
 282
 283     return std::move(IF);
 284   }
 285
 286   if (!AllowUnknownFile)
 287     return make_error<StringError>(
 288         formatv("File {0} is not a supported file type", Path),
 289         inconvertibleErrorCode());
 290
 291   auto Result = MemoryBuffer::getFile(Path, /*IsText=*/false,
 292                                       /*RequiresNullTerminator=*/false);
 293   if (!Result)
 294     return make_error<StringError>(
 295         formatv("File {0} could not be opened", Path), Result.getError());
 296
 297   IF.UnknownFile = std::move(*Result);
 298   IF.PdbOrObj = IF.UnknownFile.get();
 299   return std::move(IF);
 300 }
 301
 302 PDBFile &InputFile::pdb() {
 303   assert(isPdb());
 304   return *PdbOrObj.get<PDBFile *>();
 305 }
 306
 307 const PDBFile &InputFile::pdb() const {
 308   assert(isPdb());
 309   return *PdbOrObj.get<PDBFile *>();
 310 }
 311
 312 object::COFFObjectFile &InputFile::obj() {
 313   assert(isObj());
 314   return *PdbOrObj.get<object::COFFObjectFile *>();
 315 }
 316
 317 const object::COFFObjectFile &InputFile::obj() const {
 318   assert(isObj());
 319   return *PdbOrObj.get<object::COFFObjectFile *>();
 320 }
 321
 322 MemoryBuffer &InputFile::unknown() {
 323   assert(isUnknown());
 324   return *PdbOrObj.get<MemoryBuffer *>();
 325 }
 326
 327 const MemoryBuffer &InputFile::unknown() const {
 328   assert(isUnknown());
 329   return *PdbOrObj.get<MemoryBuffer *>();
 330 }
 331
 332 StringRef InputFile::getFilePath() const {
 333   if (isPdb())
 334     return pdb().getFilePath();
 335   if (isObj())
 336     return obj().getFileName();
 337   assert(isUnknown());
 338   return unknown().getBufferIdentifier();
 339 }
 340
 341 bool InputFile::hasTypes() const {
 342   if (isPdb())
 343     return pdb().hasPDBTpiStream();
 344
 345   for (const auto &Section : obj().sections()) {
 346     CVTypeArray Types;
 347     if (isDebugTSection(Section, Types))
 348       return true;
 349   }
 350   return false;
 351 }
 352
 353 bool InputFile::hasIds() const {
 354   if (isObj())
 355     return false;
 356   return pdb().hasPDBIpiStream();
 357 }
 358
 359 bool InputFile::isPdb() const { return PdbOrObj.is<PDBFile *>(); }
 360
 361 bool InputFile::isObj() const {
 362   return PdbOrObj.is<object::COFFObjectFile *>();
 363 }
 364
 365 bool InputFile::isUnknown() const { return PdbOrObj.is<MemoryBuffer *>(); }
 366
 367 codeview::LazyRandomTypeCollection &
 368 InputFile::getOrCreateTypeCollection(TypeCollectionKind Kind) {
 369   if (Types && Kind == kTypes)
 370     return *Types;
 371   if (Ids && Kind == kIds)
 372     return *Ids;
 373
 374   if (Kind == kIds) {
 375     assert(isPdb() && pdb().hasPDBIpiStream());
 376   }
 377
 378   // If the collection was already initialized, we should have just returned it
 379   // in step 1.
 380   if (isPdb()) {
 381     TypeCollectionPtr &Collection = (Kind == kIds) ? Ids : Types;
 382     auto &Stream = cantFail((Kind == kIds) ? pdb().getPDBIpiStream()
 383                                            : pdb().getPDBTpiStream());
 384
 385     auto &Array = Stream.typeArray();
 386     uint32_t Count = Stream.getNumTypeRecords();
 387     auto Offsets = Stream.getTypeIndexOffsets();
 388     Collection =
 389         std::make_unique<LazyRandomTypeCollection>(Array, Count, Offsets);
 390     return *Collection;
 391   }
 392
 393   assert(isObj());
 394   assert(Kind == kTypes);
 395   assert(!Types);
 396
 397   for (const auto &Section : obj().sections()) {
 398     CVTypeArray Records;
 399     if (!isDebugTSection(Section, Records))
 400       continue;
 401
 402     Types = std::make_unique<LazyRandomTypeCollection>(Records, 100);
 403     return *Types;
 404   }
 405
 406   Types = std::make_unique<LazyRandomTypeCollection>(100);
 407   return *Types;
 408 }
 409
 410 codeview::LazyRandomTypeCollection &InputFile::types() {
 411   return getOrCreateTypeCollection(kTypes);
 412 }
 413
 414 codeview::LazyRandomTypeCollection &InputFile::ids() {
 415   // Object files have only one type stream that contains both types and ids.
 416   // Similarly, some PDBs don't contain an IPI stream, and for those both types
 417   // and IDs are in the same stream.
 418   if (isObj() || !pdb().hasPDBIpiStream())
 419     return types();
 420
 421   return getOrCreateTypeCollection(kIds);
 422 }
 423
 424 iterator_range<SymbolGroupIterator> InputFile::symbol_groups() {
 425   return make_range<SymbolGroupIterator>(symbol_groups_begin(),
 426                                          symbol_groups_end());
 427 }
 428
 429 SymbolGroupIterator InputFile::symbol_groups_begin() {
 430   return SymbolGroupIterator(*this);
 431 }
 432
 433 SymbolGroupIterator InputFile::symbol_groups_end() {
 434   return SymbolGroupIterator();
 435 }
 436
 437 SymbolGroupIterator::SymbolGroupIterator() : Value(nullptr) {}
 438
 439 SymbolGroupIterator::SymbolGroupIterator(InputFile &File) : Value(&File) {
 440   if (File.isObj()) {
 441     SectionIter = File.obj().section_begin();
 442     scanToNextDebugS();
 443   }
 444 }
 445
 446 bool SymbolGroupIterator::operator==(const SymbolGroupIterator &R) const {
 447   bool E = isEnd();
 448   bool RE = R.isEnd();
 449   if (E || RE)
 450     return E == RE;
 451
 452   if (Value.File != R.Value.File)
 453     return false;
 454   return Index == R.Index;
 455 }
 456
 457 const SymbolGroup &SymbolGroupIterator::operator*() const {
 458   assert(!isEnd());
 459   return Value;
 460 }
 461 SymbolGroup &SymbolGroupIterator::operator*() {
 462   assert(!isEnd());
 463   return Value;
 464 }
 465
 466 SymbolGroupIterator &SymbolGroupIterator::operator++() {
 467   assert(Value.File && !isEnd());
 468   ++Index;
 469   if (isEnd())
 470     return *this;
 471
 472   if (Value.File->isPdb()) {
 473     Value.updatePdbModi(Index);
 474     return *this;
 475   }
 476
 477   scanToNextDebugS();
 478   return *this;
 479 }
 480
 481 void SymbolGroupIterator::scanToNextDebugS() {
 482   assert(SectionIter.hasValue());
 483   auto End = Value.File->obj().section_end();
 484   auto &Iter = *SectionIter;
 485   assert(!isEnd());
 486
 487   while (++Iter != End) {
 488     DebugSubsectionArray SS;
 489     SectionRef SR = *Iter;
 490     if (!isDebugSSection(SR, SS))
 491       continue;
 492
 493     Value.updateDebugS(SS);
 494     return;
 495   }
 496 }
 497
 498 bool SymbolGroupIterator::isEnd() const {
 499   if (!Value.File)
 500     return true;
 501   if (Value.File->isPdb()) {
 502     auto &Dbi = cantFail(Value.File->pdb().getPDBDbiStream());
 503     uint32_t Count = Dbi.modules().getModuleCount();
 504     assert(Index <= Count);
 505     return Index == Count;
 506   }
 507
 508   assert(SectionIter.hasValue());
 509   return *SectionIter == Value.File->obj().section_end();
 510 }