LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - NativeSession.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 28 72 38.9 %
Date: 2018-09-23 13:06:45 Functions: 7 30 23.3 %
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/IPDBEnumChildren.h"
      15             : #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
      16             : #include "llvm/DebugInfo/PDB/Native/NativeCompilandSymbol.h"
      17             : #include "llvm/DebugInfo/PDB/Native/NativeEnumTypes.h"
      18             : #include "llvm/DebugInfo/PDB/Native/NativeExeSymbol.h"
      19             : #include "llvm/DebugInfo/PDB/Native/NativeTypeBuiltin.h"
      20             : #include "llvm/DebugInfo/PDB/Native/NativeTypeEnum.h"
      21             : #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
      22             : #include "llvm/DebugInfo/PDB/Native/RawError.h"
      23             : #include "llvm/DebugInfo/PDB/Native/SymbolCache.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         121 : static DbiStream *getDbiStreamPtr(PDBFile &File) {
      44         121 :   Expected<DbiStream &> DbiS = File.getPDBDbiStream();
      45         121 :   if (DbiS)
      46         116 :     return &DbiS.get();
      47             : 
      48           5 :   consumeError(DbiS.takeError());
      49           5 :   return nullptr;
      50             : }
      51             : 
      52         121 : NativeSession::NativeSession(std::unique_ptr<PDBFile> PdbFile,
      53         121 :                              std::unique_ptr<BumpPtrAllocator> Allocator)
      54             :     : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)),
      55         242 :       Cache(*this, getDbiStreamPtr(*Pdb)) {}
      56             : 
      57             : NativeSession::~NativeSession() = default;
      58             : 
      59         123 : Error NativeSession::createFromPdb(std::unique_ptr<MemoryBuffer> Buffer,
      60             :                                    std::unique_ptr<IPDBSession> &Session) {
      61         123 :   StringRef Path = Buffer->getBufferIdentifier();
      62             :   auto Stream = llvm::make_unique<MemoryBufferByteStream>(
      63         123 :       std::move(Buffer), llvm::support::little);
      64             : 
      65         246 :   auto Allocator = llvm::make_unique<BumpPtrAllocator>();
      66         123 :   auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
      67         246 :   if (auto EC = File->parseFileHeaders())
      68             :     return EC;
      69         242 :   if (auto EC = File->parseStreamData())
      70             :     return EC;
      71             : 
      72             :   Session =
      73         242 :       llvm::make_unique<NativeSession>(std::move(File), std::move(Allocator));
      74             : 
      75             :   return Error::success();
      76             : }
      77             : 
      78           0 : Error NativeSession::createFromExe(StringRef Path,
      79             :                                    std::unique_ptr<IPDBSession> &Session) {
      80           0 :   return make_error<RawError>(raw_error_code::feature_unsupported);
      81             : }
      82             : 
      83           0 : uint64_t NativeSession::getLoadAddress() const { return 0; }
      84             : 
      85           0 : bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
      86             : 
      87          16 : std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
      88          16 :   return PDBSymbol::createAs<PDBSymbolExe>(*this, getNativeGlobalScope());
      89             : }
      90             : 
      91             : std::unique_ptr<PDBSymbol>
      92         360 : NativeSession::getSymbolById(SymIndexId SymbolId) const {
      93         360 :   return Cache.getSymbolById(SymbolId);
      94             : }
      95             : 
      96           0 : bool NativeSession::addressForVA(uint64_t VA, uint32_t &Section,
      97             :                                  uint32_t &Offset) const {
      98           0 :   return false;
      99             : }
     100             : 
     101           0 : bool NativeSession::addressForRVA(uint32_t VA, uint32_t &Section,
     102             :                                   uint32_t &Offset) const {
     103           0 :   return false;
     104             : }
     105             : 
     106             : std::unique_ptr<PDBSymbol>
     107           0 : NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
     108           0 :   return nullptr;
     109             : }
     110             : 
     111             : std::unique_ptr<PDBSymbol>
     112           0 : NativeSession::findSymbolByRVA(uint32_t RVA, PDB_SymType Type) const {
     113           0 :   return nullptr;
     114             : }
     115             : 
     116             : std::unique_ptr<PDBSymbol>
     117           0 : NativeSession::findSymbolBySectOffset(uint32_t Sect, uint32_t Offset,
     118             :                                       PDB_SymType Type) const {
     119           0 :   return nullptr;
     120             : }
     121             : 
     122             : std::unique_ptr<IPDBEnumLineNumbers>
     123           0 : NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
     124             :                                const IPDBSourceFile &File) const {
     125           0 :   return nullptr;
     126             : }
     127             : 
     128             : std::unique_ptr<IPDBEnumLineNumbers>
     129           0 : NativeSession::findLineNumbersByAddress(uint64_t Address,
     130             :                                         uint32_t Length) const {
     131           0 :   return nullptr;
     132             : }
     133             : 
     134             : std::unique_ptr<IPDBEnumLineNumbers>
     135           0 : NativeSession::findLineNumbersByRVA(uint32_t RVA, uint32_t Length) const {
     136           0 :   return nullptr;
     137             : }
     138             : 
     139             : std::unique_ptr<IPDBEnumLineNumbers>
     140           0 : NativeSession::findLineNumbersBySectOffset(uint32_t Section, uint32_t Offset,
     141             :                                            uint32_t Length) const {
     142           0 :   return nullptr;
     143             : }
     144             : 
     145             : std::unique_ptr<IPDBEnumSourceFiles>
     146           0 : NativeSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
     147             :                                StringRef Pattern,
     148             :                                PDB_NameSearchFlags Flags) const {
     149           0 :   return nullptr;
     150             : }
     151             : 
     152             : std::unique_ptr<IPDBSourceFile>
     153           0 : NativeSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
     154             :                                  StringRef Pattern,
     155             :                                  PDB_NameSearchFlags Flags) const {
     156           0 :   return nullptr;
     157             : }
     158             : 
     159             : std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
     160           0 : NativeSession::findCompilandsForSourceFile(StringRef Pattern,
     161             :                                            PDB_NameSearchFlags Flags) const {
     162           0 :   return nullptr;
     163             : }
     164             : 
     165             : std::unique_ptr<PDBSymbolCompiland>
     166           0 : NativeSession::findOneCompilandForSourceFile(StringRef Pattern,
     167             :                                              PDB_NameSearchFlags Flags) const {
     168           0 :   return nullptr;
     169             : }
     170             : 
     171           0 : std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getAllSourceFiles() const {
     172           0 :   return nullptr;
     173             : }
     174             : 
     175           0 : std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getSourceFilesForCompiland(
     176             :     const PDBSymbolCompiland &Compiland) const {
     177           0 :   return nullptr;
     178             : }
     179             : 
     180             : std::unique_ptr<IPDBSourceFile>
     181           0 : NativeSession::getSourceFileById(uint32_t FileId) const {
     182           0 :   return nullptr;
     183             : }
     184             : 
     185           0 : std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
     186           0 :   return nullptr;
     187             : }
     188             : 
     189           0 : std::unique_ptr<IPDBEnumTables> NativeSession::getEnumTables() const {
     190           0 :   return nullptr;
     191             : }
     192             : 
     193             : std::unique_ptr<IPDBEnumInjectedSources>
     194           0 : NativeSession::getInjectedSources() const {
     195           0 :   return nullptr;
     196             : }
     197             : 
     198             : std::unique_ptr<IPDBEnumSectionContribs>
     199           0 : NativeSession::getSectionContribs() const {
     200           0 :   return nullptr;
     201             : }
     202             : 
     203          16 : void NativeSession::initializeExeSymbol() {
     204          16 :   if (ExeSymbol == 0)
     205          14 :     ExeSymbol = Cache.createSymbol<NativeExeSymbol>();
     206          16 : }
     207             : 
     208          16 : NativeExeSymbol &NativeSession::getNativeGlobalScope() const {
     209          16 :   const_cast<NativeSession &>(*this).initializeExeSymbol();
     210             : 
     211          16 :   return Cache.getNativeSymbolById<NativeExeSymbol>(ExeSymbol);
     212             : }

Generated by: LCOV version 1.13