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

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