LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - NativeSession.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 51 98 52.0 %
Date: 2018-06-17 00:07:59 Functions: 8 31 25.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- NativeSession.cpp - Native implementation of IPDBSession -*- 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 "llvm/DebugInfo/PDB/Native/NativeSession.h"
      11             : 
      12             : #include "llvm/ADT/STLExtras.h"
      13             : #include "llvm/DebugInfo/CodeView/TypeIndex.h"
      14             : #include "llvm/DebugInfo/PDB/GenericError.h"
      15             : #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
      16             : #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
      17             : #include "llvm/DebugInfo/PDB/Native/NativeBuiltinSymbol.h"
      18             : #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
      19             : #include "llvm/DebugInfo/PDB/Native/NativeEnumSymbol.h"
      20             : #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
      21             : #include "llvm/DebugInfo/PDB/Native/NativeExeSymbol.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/DebugInfo/PDB/PDBSymbolCompiland.h"
      26             : #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
      27             : #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
      28             : #include "llvm/Support/Allocator.h"
      29             : #include "llvm/Support/BinaryByteStream.h"
      30             : #include "llvm/Support/Error.h"
      31             : #include "llvm/Support/ErrorOr.h"
      32             : #include "llvm/Support/MemoryBuffer.h"
      33             : 
      34             : #include <algorithm>
      35             : #include <cassert>
      36             : #include <memory>
      37             : #include <utility>
      38             : 
      39             : using namespace llvm;
      40             : using namespace llvm::msf;
      41             : using namespace llvm::pdb;
      42             : 
      43             : namespace {
      44             : // Maps codeview::SimpleTypeKind of a built-in type to the parameters necessary
      45             : // to instantiate a NativeBuiltinSymbol for that type.
      46             : static const struct BuiltinTypeEntry {
      47             :   codeview::SimpleTypeKind Kind;
      48             :   PDB_BuiltinType Type;
      49             :   uint32_t Size;
      50             : } BuiltinTypes[] = {
      51             :     {codeview::SimpleTypeKind::Int32, PDB_BuiltinType::Int, 4},
      52             :     {codeview::SimpleTypeKind::UInt32, PDB_BuiltinType::UInt, 4},
      53             :     {codeview::SimpleTypeKind::UInt32Long, PDB_BuiltinType::UInt, 4},
      54             :     {codeview::SimpleTypeKind::UInt64Quad, PDB_BuiltinType::UInt, 8},
      55             :     {codeview::SimpleTypeKind::NarrowCharacter, PDB_BuiltinType::Char, 1},
      56             :     {codeview::SimpleTypeKind::SignedCharacter, PDB_BuiltinType::Char, 1},
      57             :     {codeview::SimpleTypeKind::UnsignedCharacter, PDB_BuiltinType::UInt, 1},
      58             :     {codeview::SimpleTypeKind::UInt16Short, PDB_BuiltinType::UInt, 2},
      59             :     {codeview::SimpleTypeKind::Boolean8, PDB_BuiltinType::Bool, 1}
      60             :     // This table can be grown as necessary, but these are the only types we've
      61             :     // needed so far.
      62             : };
      63             : } // namespace
      64             : 
      65         103 : NativeSession::NativeSession(std::unique_ptr<PDBFile> PdbFile,
      66         103 :                              std::unique_ptr<BumpPtrAllocator> Allocator)
      67         309 :     : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)) {}
      68             : 
      69             : NativeSession::~NativeSession() = default;
      70             : 
      71         104 : Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
      72             :                                    std::unique_ptr<IPDBSession> &Session) {
      73         104 :   StringRef Path = Buffer->getBufferIdentifier();
      74             :   auto Stream = llvm::make_unique<MemoryBufferByteStream>(
      75         104 :       std::move(Buffer), llvm::support::little);
      76             : 
      77         208 :   auto Allocator = llvm::make_unique<BumpPtrAllocator>();
      78         104 :   auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
      79         208 :   if (auto EC = File->parseFileHeaders())
      80             :     return EC;
      81         206 :   if (auto EC = File->parseStreamData())
      82             :     return EC;
      83             : 
      84             :   Session =
      85         206 :       llvm::make_unique<NativeSession>(std::move(File), std::move(Allocator));
      86             : 
      87             :   return Error::success();
      88             : }
      89             : 
      90           0 : Error NativeSession::createFromExe(StringRef Path,
      91             :                                    std::unique_ptr<IPDBSession> &Session) {
      92           0 :   return make_error<RawError>(raw_error_code::feature_unsupported);
      93             : }
      94             : 
      95             : std::unique_ptr<PDBSymbolCompiland>
      96          50 : NativeSession::createCompilandSymbol(DbiModuleDescriptor MI) {
      97         100 :   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
      98         100 :   SymbolCache.push_back(
      99         100 :       llvm::make_unique<NativeCompilandSymbol>(*this, Id, MI));
     100             :   return llvm::make_unique<PDBSymbolCompiland>(
     101         250 :       *this, std::unique_ptr<IPDBRawSymbol>(SymbolCache[Id]->clone()));
     102             : }
     103             : 
     104             : std::unique_ptr<PDBSymbolTypeEnum>
     105           9 : NativeSession::createEnumSymbol(codeview::TypeIndex Index) {
     106           9 :   const auto Id = findSymbolByTypeIndex(Index);
     107             :   return llvm::make_unique<PDBSymbolTypeEnum>(
     108          45 :       *this, std::unique_ptr<IPDBRawSymbol>(SymbolCache[Id]->clone()));
     109             : }
     110             : 
     111             : std::unique_ptr<IPDBEnumSymbols>
     112           1 : NativeSession::createTypeEnumerator(codeview::TypeLeafKind Kind) {
     113           1 :   auto Tpi = Pdb->getPDBTpiStream();
     114           1 :   if (!Tpi) {
     115           0 :     consumeError(Tpi.takeError());
     116             :     return nullptr;
     117             :   }
     118             :   auto &Types = Tpi->typeCollection();
     119             :   return std::unique_ptr<IPDBEnumSymbols>(
     120           1 :       new NativeEnumTypes(*this, Types, codeview::LF_ENUM));
     121             : }
     122             : 
     123          27 : SymIndexId NativeSession::findSymbolByTypeIndex(codeview::TypeIndex Index) {
     124             :   // First see if it's already in our cache.
     125          27 :   const auto Entry = TypeIndexToSymbolId.find(Index);
     126          27 :   if (Entry != TypeIndexToSymbolId.end())
     127          17 :     return Entry->second;
     128             : 
     129             :   // Symbols for built-in types are created on the fly.
     130          10 :   if (Index.isSimple()) {
     131             :     // FIXME:  We will eventually need to handle pointers to other simple types,
     132             :     // which are still simple types in the world of CodeView TypeIndexes.
     133           1 :     if (Index.getSimpleMode() != codeview::SimpleTypeMode::Direct)
     134             :       return 0;
     135             :     const auto Kind = Index.getSimpleKind();
     136             :     const auto It =
     137             :         std::find_if(std::begin(BuiltinTypes), std::end(BuiltinTypes),
     138             :                      [Kind](const BuiltinTypeEntry &Builtin) {
     139             :                        return Builtin.Kind == Kind;
     140             :                      });
     141           1 :     if (It == std::end(BuiltinTypes))
     142             :       return 0;
     143           2 :     SymIndexId Id = SymbolCache.size();
     144           2 :     SymbolCache.emplace_back(
     145           2 :         llvm::make_unique<NativeBuiltinSymbol>(*this, Id, It->Type, It->Size));
     146           1 :     TypeIndexToSymbolId[Index] = Id;
     147           1 :     return Id;
     148             :   }
     149             : 
     150             :   // We need to instantiate and cache the desired type symbol.
     151           9 :   auto Tpi = Pdb->getPDBTpiStream();
     152           9 :   if (!Tpi) {
     153           0 :     consumeError(Tpi.takeError());
     154           0 :     return 0;
     155             :   }
     156             :   auto &Types = Tpi->typeCollection();
     157           9 :   const auto &I = Types.getType(Index);
     158          18 :   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
     159             :   // TODO(amccarth):  Make this handle all types, not just LF_ENUMs.
     160             :   assert(I.kind() == codeview::LF_ENUM);
     161          27 :   SymbolCache.emplace_back(llvm::make_unique<NativeEnumSymbol>(*this, Id, I));
     162           9 :   TypeIndexToSymbolId[Index] = Id;
     163             :   return Id;
     164             : }
     165             : 
     166           0 : uint64_t NativeSession::getLoadAddress() const { return 0; }
     167             : 
     168           0 : bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
     169             : 
     170           4 : std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
     171           8 :   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
     172           8 :   SymbolCache.push_back(llvm::make_unique<NativeExeSymbol>(*this, Id));
     173           8 :   auto RawSymbol = SymbolCache[Id]->clone();
     174           8 :   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
     175             :   std::unique_ptr<PDBSymbolExe> ExeSymbol(
     176             :       static_cast<PDBSymbolExe *>(PdbSymbol.release()));
     177           4 :   return ExeSymbol;
     178             : }
     179             : 
     180             : std::unique_ptr<PDBSymbol>
     181          27 : NativeSession::getSymbolById(uint32_t SymbolId) const {
     182             :   // If the caller has a SymbolId, it'd better be in our SymbolCache.
     183          27 :   return SymbolId < SymbolCache.size()
     184          72 :              ? PDBSymbol::create(*this, SymbolCache[SymbolId]->clone())
     185          99 :              : nullptr;
     186             : }
     187             : 
     188           0 : bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
     189             :                                  uint32_t &Offset) const {
     190           0 :   return false;
     191             : }
     192             : 
     193           0 : bool NativeSession::addressForRVA(uint32_t VA, uint32_t &Section,
     194             :                                   uint32_t &Offset) const {
     195           0 :   return false;
     196             : }
     197             : 
     198             : std::unique_ptr<PDBSymbol>
     199           0 : NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
     200           0 :   return nullptr;
     201             : }
     202             : 
     203             : std::unique_ptr<PDBSymbol>
     204           0 : NativeSession::findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const {
     205           0 :   return nullptr;
     206             : }
     207             : 
     208             : std::unique_ptr<PDBSymbol>
     209           0 : NativeSession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
     210             :                                       PDB_SymType Type) const {
     211           0 :   return nullptr;
     212             : }
     213             : 
     214             : std::unique_ptr<IPDBEnumLineNumbers>
     215           0 : NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
     216             :                                const IPDBSourceFile &File) const {
     217           0 :   return nullptr;
     218             : }
     219             : 
     220             : std::unique_ptr<IPDBEnumLineNumbers>
     221           0 : NativeSession::findLineNumbersByAddress(uint64_t Address,
     222             :                                         uint32_t Length) const {
     223           0 :   return nullptr;
     224             : }
     225             : 
     226             : std::unique_ptr<IPDBEnumLineNumbers>
     227           0 : NativeSession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
     228           0 :   return nullptr;
     229             : }
     230             : 
     231             : std::unique_ptr<IPDBEnumLineNumbers>
     232           0 : NativeSession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
     233             :                                            uint32_t Length) const {
     234           0 :   return nullptr;
     235             : }
     236             : 
     237             : std::unique_ptr<IPDBEnumSourceFiles>
     238           0 : NativeSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
     239             :                                StringRef Pattern,
     240             :                                PDB_NameSearchFlags Flags) const {
     241           0 :   return nullptr;
     242             : }
     243             : 
     244             : std::unique_ptr<IPDBSourceFile>
     245           0 : NativeSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
     246             :                                  StringRef Pattern,
     247             :                                  PDB_NameSearchFlags Flags) const {
     248           0 :   return nullptr;
     249             : }
     250             : 
     251             : std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
     252           0 : NativeSession::findCompilandsForSourceFile(StringRef Pattern,
     253             :                                            PDB_NameSearchFlags Flags) const {
     254           0 :   return nullptr;
     255             : }
     256             : 
     257             : std::unique_ptr<PDBSymbolCompiland>
     258           0 : NativeSession::findOneCompilandForSourceFile(StringRef Pattern,
     259             :                                              PDB_NameSearchFlags Flags) const {
     260           0 :   return nullptr;
     261             : }
     262             : 
     263           0 : std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getAllSourceFiles() const {
     264           0 :   return nullptr;
     265             : }
     266             : 
     267           0 : std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getSourceFilesForCompiland(
     268             :     const PDBSymbolCompiland &Compiland) const {
     269           0 :   return nullptr;
     270             : }
     271             : 
     272             : std::unique_ptr<IPDBSourceFile>
     273           0 : NativeSession::getSourceFileById(uint32_t FileId) const {
     274           0 :   return nullptr;
     275             : }
     276             : 
     277           0 : std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
     278           0 :   return nullptr;
     279             : }
     280             : 
     281           0 : std::unique_ptr<IPDBEnumTables> NativeSession::getEnumTables() const {
     282           0 :   return nullptr;
     283             : }
     284             : 
     285             : std::unique_ptr<IPDBEnumInjectedSources>
     286           0 : NativeSession::getInjectedSources() const {
     287           0 :   return nullptr;
     288             : }
     289             : 
     290             : std::unique_ptr<IPDBEnumSectionContribs>
     291           0 : NativeSession::getSectionContribs() const {
     292           0 :   return nullptr;
     293             : }

Generated by: LCOV version 1.13