contrib/llvm/lib/DebugInfo/PDB/Native/NativeSession.cpp

   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/NativeExeSymbol.h"
  20 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  21 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  22 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
  23 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
  24 #include "llvm/Support/Allocator.h"
  25 #include "llvm/Support/BinaryByteStream.h"
  26 #include "llvm/Support/Error.h"
  27 #include "llvm/Support/ErrorOr.h"
  28 #include "llvm/Support/MemoryBuffer.h"
  29
  30 #include <algorithm>
  31 #include <memory>
  32 #include <utility>
  33
  34 using namespace llvm;
  35 using namespace llvm::msf;
  36 using namespace llvm::pdb;
  37
  38 namespace {
  39 // Maps codeview::SimpleTypeKind of a built-in type to the parameters necessary
  40 // to instantiate a NativeBuiltinSymbol for that type.
  41 static const struct BuiltinTypeEntry {
  42   codeview::SimpleTypeKind Kind;
  43   PDB_BuiltinType Type;
  44   uint32_t Size;
  45 } BuiltinTypes[] = {
  46     {codeview::SimpleTypeKind::Int32, PDB_BuiltinType::Int, 4},
  47     {codeview::SimpleTypeKind::UInt32, PDB_BuiltinType::UInt, 4},
  48     {codeview::SimpleTypeKind::UInt32Long, PDB_BuiltinType::UInt, 4},
  49     {codeview::SimpleTypeKind::UInt64Quad, PDB_BuiltinType::UInt, 8},
  50     {codeview::SimpleTypeKind::NarrowCharacter, PDB_BuiltinType::Char, 1},
  51     {codeview::SimpleTypeKind::SignedCharacter, PDB_BuiltinType::Char, 1},
  52     {codeview::SimpleTypeKind::UnsignedCharacter, PDB_BuiltinType::UInt, 1},
  53     {codeview::SimpleTypeKind::UInt16Short, PDB_BuiltinType::UInt, 2},
  54     {codeview::SimpleTypeKind::Boolean8, PDB_BuiltinType::Bool, 1}
  55     // This table can be grown as necessary, but these are the only types we've
  56     // needed so far.
  57 };
  58 } // namespace
  59
  60 NativeSession::NativeSession(std::unique_ptr<PDBFile> PdbFile,
  61                              std::unique_ptr<BumpPtrAllocator> Allocator)
  62     : Pdb(std::move(PdbFile)), Allocator(std::move(Allocator)) {}
  63
  64 NativeSession::~NativeSession() = default;
  65
  66 Error NativeSession::createFromPdb(StringRef Path,
  67                                    std::unique_ptr<IPDBSession> &Session) {
  68   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
  69       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
  70                                    /*RequiresNullTerminator=*/false);
  71   if (!ErrorOrBuffer)
  72     return make_error<GenericError>(generic_error_code::invalid_path);
  73
  74   std::unique_ptr<MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
  75   auto Stream = llvm::make_unique<MemoryBufferByteStream>(
  76       std::move(Buffer), llvm::support::little);
  77
  78   auto Allocator = llvm::make_unique<BumpPtrAllocator>();
  79   auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), *Allocator);
  80   if (auto EC = File->parseFileHeaders())
  81     return EC;
  82   if (auto EC = File->parseStreamData())
  83     return EC;
  84
  85   Session =
  86       llvm::make_unique<NativeSession>(std::move(File), std::move(Allocator));
  87
  88   return Error::success();
  89 }
  90
  91 Error NativeSession::createFromExe(StringRef Path,
  92                                    std::unique_ptr<IPDBSession> &Session) {
  93   return make_error<RawError>(raw_error_code::feature_unsupported);
  94 }
  95
  96 std::unique_ptr<PDBSymbolCompiland>
  97 NativeSession::createCompilandSymbol(DbiModuleDescriptor MI) {
  98   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
  99   SymbolCache.push_back(
 100       llvm::make_unique<NativeCompilandSymbol>(*this, Id, MI));
 101   return llvm::make_unique<PDBSymbolCompiland>(
 102       *this, std::unique_ptr<IPDBRawSymbol>(SymbolCache[Id]->clone()));
 103 }
 104
 105 SymIndexId NativeSession::findSymbolByTypeIndex(codeview::TypeIndex Index) {
 106   // First see if it's already in our cache.
 107   const auto Entry = TypeIndexToSymbolId.find(Index);
 108   if (Entry != TypeIndexToSymbolId.end())
 109     return Entry->second;
 110
 111   // Symbols for built-in types are created on the fly.
 112   if (Index.isSimple()) {
 113     // FIXME:  We will eventually need to handle pointers to other simple types,
 114     // which are still simple types in the world of CodeView TypeIndexes.
 115     if (Index.getSimpleMode() != codeview::SimpleTypeMode::Direct)
 116       return 0;
 117     const auto Kind = Index.getSimpleKind();
 118     const auto It =
 119         std::find_if(std::begin(BuiltinTypes), std::end(BuiltinTypes),
 120                      [Kind](const BuiltinTypeEntry &Builtin) {
 121                        return Builtin.Kind == Kind;
 122                      });
 123     if (It == std::end(BuiltinTypes))
 124       return 0;
 125     SymIndexId Id = SymbolCache.size();
 126     SymbolCache.emplace_back(
 127         llvm::make_unique<NativeBuiltinSymbol>(*this, Id, It->Type, It->Size));
 128     TypeIndexToSymbolId[Index] = Id;
 129     return Id;
 130   }
 131
 132   // TODO:  Look up PDB type by type index
 133
 134   return 0;
 135 }
 136
 137 uint64_t NativeSession::getLoadAddress() const { return 0; }
 138
 139 void NativeSession::setLoadAddress(uint64_t Address) {}
 140
 141 std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
 142   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
 143   SymbolCache.push_back(llvm::make_unique<NativeExeSymbol>(*this, Id));
 144   auto RawSymbol = SymbolCache[Id]->clone();
 145   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
 146   std::unique_ptr<PDBSymbolExe> ExeSymbol(
 147       static_cast<PDBSymbolExe *>(PdbSymbol.release()));
 148   return ExeSymbol;
 149 }
 150
 151 std::unique_ptr<PDBSymbol>
 152 NativeSession::getSymbolById(uint32_t SymbolId) const {
 153   // If the caller has a SymbolId, it'd better be in our SymbolCache.
 154   return SymbolId < SymbolCache.size()
 155              ? PDBSymbol::create(*this, SymbolCache[SymbolId]->clone())
 156              : nullptr;
 157 }
 158
 159 std::unique_ptr<PDBSymbol>
 160 NativeSession::findSymbolByAddress(uint64_t Address, PDB_SymType Type) const {
 161   return nullptr;
 162 }
 163
 164 std::unique_ptr<IPDBEnumLineNumbers>
 165 NativeSession::findLineNumbers(const PDBSymbolCompiland &Compiland,
 166                                const IPDBSourceFile &File) const {
 167   return nullptr;
 168 }
 169
 170 std::unique_ptr<IPDBEnumLineNumbers>
 171 NativeSession::findLineNumbersByAddress(uint64_t Address,
 172                                         uint32_t Length) const {
 173   return nullptr;
 174 }
 175
 176 std::unique_ptr<IPDBEnumSourceFiles>
 177 NativeSession::findSourceFiles(const PDBSymbolCompiland *Compiland,
 178                                StringRef Pattern,
 179                                PDB_NameSearchFlags Flags) const {
 180   return nullptr;
 181 }
 182
 183 std::unique_ptr<IPDBSourceFile>
 184 NativeSession::findOneSourceFile(const PDBSymbolCompiland *Compiland,
 185                                  StringRef Pattern,
 186                                  PDB_NameSearchFlags Flags) const {
 187   return nullptr;
 188 }
 189
 190 std::unique_ptr<IPDBEnumChildren<PDBSymbolCompiland>>
 191 NativeSession::findCompilandsForSourceFile(StringRef Pattern,
 192                                            PDB_NameSearchFlags Flags) const {
 193   return nullptr;
 194 }
 195
 196 std::unique_ptr<PDBSymbolCompiland>
 197 NativeSession::findOneCompilandForSourceFile(StringRef Pattern,
 198                                              PDB_NameSearchFlags Flags) const {
 199   return nullptr;
 200 }
 201
 202 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getAllSourceFiles() const {
 203   return nullptr;
 204 }
 205
 206 std::unique_ptr<IPDBEnumSourceFiles> NativeSession::getSourceFilesForCompiland(
 207     const PDBSymbolCompiland &Compiland) const {
 208   return nullptr;
 209 }
 210
 211 std::unique_ptr<IPDBSourceFile>
 212 NativeSession::getSourceFileById(uint32_t FileId) const {
 213   return nullptr;
 214 }
 215
 216 std::unique_ptr<IPDBEnumDataStreams> NativeSession::getDebugStreams() const {
 217   return nullptr;
 218 }