LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - DbiStream.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 124 141 87.9 %
Date: 2018-06-17 00:07:59 Functions: 31 36 86.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- DbiStream.cpp - PDB Dbi Stream (Stream 3) Access -------------------===//
       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 "llvm/DebugInfo/PDB/Native/DbiStream.h"
      11             : #include "llvm/ADT/StringRef.h"
      12             : #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
      13             : #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
      14             : #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
      15             : #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
      16             : #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
      17             : #include "llvm/DebugInfo/PDB/Native/RawError.h"
      18             : #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
      19             : #include "llvm/DebugInfo/PDB/PDBTypes.h"
      20             : #include "llvm/Object/COFF.h"
      21             : #include "llvm/Support/BinaryStreamArray.h"
      22             : #include "llvm/Support/BinaryStreamReader.h"
      23             : #include "llvm/Support/Error.h"
      24             : #include <algorithm>
      25             : #include <cstddef>
      26             : #include <cstdint>
      27             : 
      28             : using namespace llvm;
      29             : using namespace llvm::codeview;
      30             : using namespace llvm::msf;
      31             : using namespace llvm::pdb;
      32             : using namespace llvm::support;
      33             : 
      34             : template <typename ContribType>
      35          60 : static Error loadSectionContribs(FixedStreamArray<ContribType> &Output,
      36             :                                  BinaryStreamReader &Reader) {
      37          60 :   if (Reader.bytesRemaining() % sizeof(ContribType) != 0)
      38             :     return make_error<RawError>(
      39             :         raw_error_code::corrupt_file,
      40             :         "Invalid number of bytes of section contributions");
      41             : 
      42          60 :   uint32_t Count = Reader.bytesRemaining() / sizeof(ContribType);
      43         120 :   if (auto EC = Reader.readArray(Output, Count))
      44             :     return EC;
      45             :   return Error::success();
      46             : }
      47             : 
      48          67 : DbiStream::DbiStream(std::unique_ptr<BinaryStream> Stream)
      49         201 :     : Stream(std::move(Stream)), Header(nullptr) {}
      50             : 
      51             : DbiStream::~DbiStream() = default;
      52             : 
      53          67 : Error DbiStream::reload(PDBFile *Pdb) {
      54          67 :   BinaryStreamReader Reader(*Stream);
      55             : 
      56          67 :   if (Stream->getLength() < sizeof(DbiStreamHeader))
      57             :     return make_error<RawError>(raw_error_code::corrupt_file,
      58             :                                 "DBI Stream does not contain a header.");
      59         134 :   if (auto EC = Reader.readObject(Header))
      60             :     return make_error<RawError>(raw_error_code::corrupt_file,
      61             :                                 "DBI Stream does not contain a header.");
      62             : 
      63         134 :   if (Header->VersionSignature != -1)
      64             :     return make_error<RawError>(raw_error_code::corrupt_file,
      65             :                                 "Invalid DBI version signature.");
      66             : 
      67             :   // Require at least version 7, which should be present in all PDBs
      68             :   // produced in the last decade and allows us to avoid having to
      69             :   // special case all kinds of complicated arcane formats.
      70          67 :   if (Header->VersionHeader < PdbDbiV70)
      71             :     return make_error<RawError>(raw_error_code::feature_unsupported,
      72             :                                 "Unsupported DBI version.");
      73             : 
      74         134 :   if (Stream->getLength() !=
      75         201 :       sizeof(DbiStreamHeader) + Header->ModiSubstreamSize +
      76         201 :           Header->SecContrSubstreamSize + Header->SectionMapSize +
      77         201 :           Header->FileInfoSize + Header->TypeServerSize +
      78         134 :           Header->OptionalDbgHdrSize + Header->ECSubstreamSize)
      79             :     return make_error<RawError>(raw_error_code::corrupt_file,
      80             :                                 "DBI Length does not equal sum of substreams.");
      81             : 
      82             :   // Only certain substreams are guaranteed to be aligned.  Validate
      83             :   // them here.
      84          67 :   if (Header->ModiSubstreamSize % sizeof(uint32_t) != 0)
      85             :     return make_error<RawError>(raw_error_code::corrupt_file,
      86             :                                 "DBI MODI substream not aligned.");
      87          67 :   if (Header->SecContrSubstreamSize % sizeof(uint32_t) != 0)
      88             :     return make_error<RawError>(
      89             :         raw_error_code::corrupt_file,
      90             :         "DBI section contribution substream not aligned.");
      91          67 :   if (Header->SectionMapSize % sizeof(uint32_t) != 0)
      92             :     return make_error<RawError>(raw_error_code::corrupt_file,
      93             :                                 "DBI section map substream not aligned.");
      94          67 :   if (Header->FileInfoSize % sizeof(uint32_t) != 0)
      95             :     return make_error<RawError>(raw_error_code::corrupt_file,
      96             :                                 "DBI file info substream not aligned.");
      97          67 :   if (Header->TypeServerSize % sizeof(uint32_t) != 0)
      98             :     return make_error<RawError>(raw_error_code::corrupt_file,
      99             :                                 "DBI type server substream not aligned.");
     100             : 
     101         134 :   if (auto EC = Reader.readSubstream(ModiSubstream, Header->ModiSubstreamSize))
     102             :     return EC;
     103             : 
     104          67 :   if (auto EC = Reader.readSubstream(SecContrSubstream,
     105         134 :                                      Header->SecContrSubstreamSize))
     106             :     return EC;
     107         201 :   if (auto EC = Reader.readSubstream(SecMapSubstream, Header->SectionMapSize))
     108             :     return EC;
     109         201 :   if (auto EC = Reader.readSubstream(FileInfoSubstream, Header->FileInfoSize))
     110             :     return EC;
     111          67 :   if (auto EC =
     112         134 :           Reader.readSubstream(TypeServerMapSubstream, Header->TypeServerSize))
     113             :     return EC;
     114         201 :   if (auto EC = Reader.readSubstream(ECSubstream, Header->ECSubstreamSize))
     115             :     return EC;
     116          67 :   if (auto EC = Reader.readArray(
     117         134 :           DbgStreams, Header->OptionalDbgHdrSize / sizeof(ulittle16_t)))
     118             :     return EC;
     119             : 
     120          67 :   if (auto EC = Modules.initialize(ModiSubstream.StreamData,
     121         268 :                                    FileInfoSubstream.StreamData))
     122             :     return EC;
     123             : 
     124         134 :   if (auto EC = initializeSectionContributionData())
     125             :     return EC;
     126         134 :   if (auto EC = initializeSectionHeadersData(Pdb))
     127             :     return EC;
     128         134 :   if (auto EC = initializeSectionMapData())
     129             :     return EC;
     130         134 :   if (auto EC = initializeFpoRecords(Pdb))
     131             :     return EC;
     132             : 
     133          67 :   if (Reader.bytesRemaining() > 0)
     134             :     return make_error<RawError>(raw_error_code::corrupt_file,
     135             :                                 "Found unexpected bytes in DBI Stream.");
     136             : 
     137          67 :   if (!ECSubstream.empty()) {
     138         134 :     BinaryStreamReader ECReader(ECSubstream.StreamData);
     139         134 :     if (auto EC = ECNames.reload(ECReader))
     140             :       return EC;
     141             :   }
     142             : 
     143             :   return Error::success();
     144             : }
     145             : 
     146          12 : PdbRaw_DbiVer DbiStream::getDbiVersion() const {
     147          12 :   uint32_t Value = Header->VersionHeader;
     148          12 :   return static_cast<PdbRaw_DbiVer>(Value);
     149             : }
     150             : 
     151          24 : uint32_t DbiStream::getAge() const { return Header->Age; }
     152             : 
     153         109 : uint16_t DbiStream::getPublicSymbolStreamIndex() const {
     154         218 :   return Header->PublicSymbolStreamIndex;
     155             : }
     156             : 
     157         135 : uint16_t DbiStream::getGlobalSymbolStreamIndex() const {
     158         270 :   return Header->GlobalSymbolStreamIndex;
     159             : }
     160             : 
     161          24 : uint16_t DbiStream::getFlags() const { return Header->Flags; }
     162             : 
     163           4 : bool DbiStream::isIncrementallyLinked() const {
     164           8 :   return (Header->Flags & DbiFlags::FlagIncrementalMask) != 0;
     165             : }
     166             : 
     167           8 : bool DbiStream::hasCTypes() const {
     168          16 :   return (Header->Flags & DbiFlags::FlagHasCTypesMask) != 0;
     169             : }
     170             : 
     171           8 : bool DbiStream::isStripped() const {
     172          16 :   return (Header->Flags & DbiFlags::FlagStrippedMask) != 0;
     173             : }
     174             : 
     175          24 : uint16_t DbiStream::getBuildNumber() const { return Header->BuildNumber; }
     176             : 
     177           0 : uint16_t DbiStream::getBuildMajorVersion() const {
     178           0 :   return (Header->BuildNumber & DbiBuildNo::BuildMajorMask) >>
     179           0 :          DbiBuildNo::BuildMajorShift;
     180             : }
     181             : 
     182           0 : uint16_t DbiStream::getBuildMinorVersion() const {
     183           0 :   return (Header->BuildNumber & DbiBuildNo::BuildMinorMask) >>
     184           0 :          DbiBuildNo::BuildMinorShift;
     185             : }
     186             : 
     187          24 : uint16_t DbiStream::getPdbDllRbld() const { return Header->PdbDllRbld; }
     188             : 
     189          24 : uint32_t DbiStream::getPdbDllVersion() const { return Header->PdbDllVersion; }
     190             : 
     191         103 : uint32_t DbiStream::getSymRecordStreamIndex() const {
     192         206 :   return Header->SymRecordStreamIndex;
     193             : }
     194             : 
     195          12 : PDB_Machine DbiStream::getMachineType() const {
     196          12 :   uint16_t Machine = Header->MachineType;
     197          12 :   return static_cast<PDB_Machine>(Machine);
     198             : }
     199             : 
     200           0 : FixedStreamArray<object::coff_section> DbiStream::getSectionHeaders() {
     201           0 :   return SectionHeaders;
     202             : }
     203             : 
     204           0 : FixedStreamArray<object::FpoData> DbiStream::getFpoRecords() {
     205           0 :   return FpoRecords;
     206             : }
     207             : 
     208         934 : const DbiModuleList &DbiStream::modules() const { return Modules; }
     209             : 
     210           2 : FixedStreamArray<SecMapEntry> DbiStream::getSectionMap() const {
     211           2 :   return SectionMap;
     212             : }
     213             : 
     214           3 : void DbiStream::visitSectionContributions(
     215             :     ISectionContribVisitor &Visitor) const {
     216           3 :   if (!SectionContribs.empty()) {
     217             :     assert(SectionContribVersion == DbiSecContribVer60);
     218          37 :     for (auto &SC : SectionContribs)
     219          28 :       Visitor.visit(SC);
     220           0 :   } else if (!SectionContribs2.empty()) {
     221             :     assert(SectionContribVersion == DbiSecContribV2);
     222           0 :     for (auto &SC : SectionContribs2)
     223           0 :       Visitor.visit(SC);
     224             :   }
     225           3 : }
     226             : 
     227         220 : Expected<StringRef> DbiStream::getECName(uint32_t NI) const {
     228         220 :   return ECNames.getStringForID(NI);
     229             : }
     230             : 
     231          67 : Error DbiStream::initializeSectionContributionData() {
     232          67 :   if (SecContrSubstream.empty())
     233             :     return Error::success();
     234             : 
     235         120 :   BinaryStreamReader SCReader(SecContrSubstream.StreamData);
     236         120 :   if (auto EC = SCReader.readEnum(SectionContribVersion))
     237             :     return EC;
     238             : 
     239          60 :   if (SectionContribVersion == DbiSecContribVer60)
     240          60 :     return loadSectionContribs<SectionContrib>(SectionContribs, SCReader);
     241           0 :   if (SectionContribVersion == DbiSecContribV2)
     242           0 :     return loadSectionContribs<SectionContrib2>(SectionContribs2, SCReader);
     243             : 
     244             :   return make_error<RawError>(raw_error_code::feature_unsupported,
     245             :                               "Unsupported DBI Section Contribution version");
     246             : }
     247             : 
     248             : // Initializes this->SectionHeaders.
     249          67 : Error DbiStream::initializeSectionHeadersData(PDBFile *Pdb) {
     250          67 :   if (!Pdb)
     251             :     return Error::success();
     252             : 
     253          67 :   if (DbgStreams.size() == 0)
     254             :     return Error::success();
     255             : 
     256          67 :   uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::SectionHdr);
     257          67 :   if (StreamNum == kInvalidStreamIndex)
     258             :     return Error::success();
     259             : 
     260          60 :   if (StreamNum >= Pdb->getNumStreams())
     261           0 :     return make_error<RawError>(raw_error_code::no_stream);
     262             : 
     263             :   auto SHS = MappedBlockStream::createIndexedStream(
     264         180 :       Pdb->getMsfLayout(), Pdb->getMsfBuffer(), StreamNum, Pdb->getAllocator());
     265             : 
     266          60 :   size_t StreamLen = SHS->getLength();
     267          60 :   if (StreamLen % sizeof(object::coff_section))
     268             :     return make_error<RawError>(raw_error_code::corrupt_file,
     269             :                                 "Corrupted section header stream.");
     270             : 
     271          60 :   size_t NumSections = StreamLen / sizeof(object::coff_section);
     272          60 :   BinaryStreamReader Reader(*SHS);
     273         120 :   if (auto EC = Reader.readArray(SectionHeaders, NumSections))
     274             :     return make_error<RawError>(raw_error_code::corrupt_file,
     275             :                                 "Could not read a bitmap.");
     276             : 
     277             :   SectionHeaderStream = std::move(SHS);
     278             :   return Error::success();
     279             : }
     280             : 
     281             : // Initializes this->Fpos.
     282          67 : Error DbiStream::initializeFpoRecords(PDBFile *Pdb) {
     283          67 :   if (!Pdb)
     284             :     return Error::success();
     285             : 
     286          67 :   if (DbgStreams.size() == 0)
     287             :     return Error::success();
     288             : 
     289          67 :   uint32_t StreamNum = getDebugStreamIndex(DbgHeaderType::NewFPO);
     290             : 
     291             :   // This means there is no FPO data.
     292          67 :   if (StreamNum == kInvalidStreamIndex)
     293             :     return Error::success();
     294             : 
     295          36 :   if (StreamNum >= Pdb->getNumStreams())
     296           0 :     return make_error<RawError>(raw_error_code::no_stream);
     297             : 
     298             :   auto FS = MappedBlockStream::createIndexedStream(
     299         108 :       Pdb->getMsfLayout(), Pdb->getMsfBuffer(), StreamNum, Pdb->getAllocator());
     300             : 
     301          36 :   size_t StreamLen = FS->getLength();
     302          36 :   if (StreamLen % sizeof(object::FpoData))
     303             :     return make_error<RawError>(raw_error_code::corrupt_file,
     304             :                                 "Corrupted New FPO stream.");
     305             : 
     306          36 :   size_t NumRecords = StreamLen / sizeof(object::FpoData);
     307          36 :   BinaryStreamReader Reader(*FS);
     308          72 :   if (auto EC = Reader.readArray(FpoRecords, NumRecords))
     309             :     return make_error<RawError>(raw_error_code::corrupt_file,
     310             :                                 "Corrupted New FPO stream.");
     311             :   FpoStream = std::move(FS);
     312             :   return Error::success();
     313             : }
     314             : 
     315           1 : BinarySubstreamRef DbiStream::getSectionContributionData() const {
     316           1 :   return SecContrSubstream;
     317             : }
     318             : 
     319           1 : BinarySubstreamRef DbiStream::getSecMapSubstreamData() const {
     320           1 :   return SecMapSubstream;
     321             : }
     322             : 
     323           1 : BinarySubstreamRef DbiStream::getModiSubstreamData() const {
     324           1 :   return ModiSubstream;
     325             : }
     326             : 
     327           1 : BinarySubstreamRef DbiStream::getFileInfoSubstreamData() const {
     328           1 :   return FileInfoSubstream;
     329             : }
     330             : 
     331           1 : BinarySubstreamRef DbiStream::getTypeServerMapSubstreamData() const {
     332           1 :   return TypeServerMapSubstream;
     333             : }
     334             : 
     335           2 : BinarySubstreamRef DbiStream::getECSubstreamData() const { return ECSubstream; }
     336             : 
     337          67 : Error DbiStream::initializeSectionMapData() {
     338          67 :   if (SecMapSubstream.empty())
     339             :     return Error::success();
     340             : 
     341         120 :   BinaryStreamReader SMReader(SecMapSubstream.StreamData);
     342             :   const SecMapHeader *Header;
     343         120 :   if (auto EC = SMReader.readObject(Header))
     344             :     return EC;
     345         180 :   if (auto EC = SMReader.readArray(SectionMap, Header->SecCount))
     346             :     return EC;
     347             :   return Error::success();
     348             : }
     349             : 
     350         751 : uint32_t DbiStream::getDebugStreamIndex(DbgHeaderType Type) const {
     351             :   uint16_t T = static_cast<uint16_t>(Type);
     352        1502 :   if (T >= DbgStreams.size())
     353             :     return kInvalidStreamIndex;
     354        1502 :   return DbgStreams[T];
     355             : }

Generated by: LCOV version 1.13