160 lines · c
1//===-- PdbIndex.h ----------------------------------------------*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_PDBINDEX_H10#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_PDBINDEX_H11 12#include "lldb/lldb-types.h"13#include "llvm/ADT/IntervalMap.h"14#include "llvm/DebugInfo/PDB/Native/PDBFile.h"15#include "llvm/DebugInfo/PDB/PDBTypes.h"16 17#include "CompileUnitIndex.h"18#include "PdbSymUid.h"19 20#include <map>21#include <memory>22#include <optional>23 24namespace llvm {25namespace pdb {26class DbiStream;27class TpiStream;28class InfoStream;29class PublicsStream;30class GlobalsStream;31class SymbolStream;32} // namespace pdb33} // namespace llvm34 35namespace lldb_private {36namespace npdb {37struct SegmentOffset;38 39/// PdbIndex - Lazy access to the important parts of a PDB file.40///41/// This is a layer on top of LLVM's native PDB support libraries which cache42/// certain data when it is accessed the first time. The entire PDB file is43/// mapped into memory, and the underlying support libraries vend out memory44/// that is always backed by the file, so it is safe to hold StringRefs and45/// ArrayRefs into the backing memory as long as the PdbIndex instance is46/// alive.47class PdbIndex {48 49 /// The underlying PDB file.50 llvm::pdb::PDBFile *m_file = nullptr;51 52 /// The DBI stream. This contains general high level information about the53 /// features present in the PDB file, compile units (such as the information54 /// necessary to locate full symbol information for each compile unit),55 /// section contributions, and other data which is not specifically symbol or56 /// type records.57 llvm::pdb::DbiStream *m_dbi = nullptr;58 59 /// TPI (types) and IPI (indices) streams. These are both in the exact same60 /// format with different data. Most type records are stored in the TPI61 /// stream but certain specific types of records are stored in the IPI stream.62 /// The IPI stream records can refer to the records in the TPI stream, but not63 /// the other way around.64 llvm::pdb::TpiStream *m_tpi = nullptr;65 llvm::pdb::TpiStream *m_ipi = nullptr;66 67 /// This is called the "PDB Stream" in the Microsoft reference implementation.68 /// It contains information about the structure of the file, as well as fields69 /// used to match EXE and PDB.70 llvm::pdb::InfoStream *m_info = nullptr;71 72 /// Publics stream. Is actually a serialized hash table where the keys are73 /// addresses of symbols in the executable, and values are a record containing74 /// mangled names and an index which can be used to locate more detailed info75 /// about the symbol in the Symbol Records stream. The publics stream only76 /// contains info about externally visible symbols.77 llvm::pdb::PublicsStream *m_publics = nullptr;78 79 /// Globals stream. Contrary to its name, this does not contain information80 /// about all "global variables" or "global functions". Rather, it is the81 /// "global symbol table", i.e. it contains information about *every* symbol82 /// in the executable. It is a hash table keyed on name, whose values are83 /// indices into the symbol records stream to find the full record.84 llvm::pdb::GlobalsStream *m_globals = nullptr;85 86 /// Symbol records stream. The publics and globals stream refer to records87 /// in this stream. For some records, like constants and typedefs, the88 /// complete record lives in this stream. For other symbol types, such as89 /// functions, data, and other things that have been materialied into a90 /// specific compile unit, the records here simply provide a reference91 /// necessary to locate the full information.92 llvm::pdb::SymbolStream *m_symrecords = nullptr;93 94 /// Index of all compile units, mapping identifier to |CompilandIndexItem|95 /// instance.96 CompileUnitIndex m_cus;97 98 /// An allocator for the interval maps99 llvm::IntervalMap<lldb::addr_t, uint32_t>::Allocator m_allocator;100 101 /// Maps virtual address to module index102 llvm::IntervalMap<lldb::addr_t, uint16_t> m_va_to_modi;103 104 /// The address at which the program has been loaded into memory.105 lldb::addr_t m_load_address = 0;106 107 PdbIndex();108 109 void BuildAddrToSymbolMap(CompilandIndexItem &cci);110 111public:112 static llvm::Expected<std::unique_ptr<PdbIndex>> create(llvm::pdb::PDBFile *);113 114 void SetLoadAddress(lldb::addr_t addr) { m_load_address = addr; }115 lldb::addr_t GetLoadAddress() const { return m_load_address; }116 void ParseSectionContribs();117 118 llvm::pdb::PDBFile &pdb() { return *m_file; }119 const llvm::pdb::PDBFile &pdb() const { return *m_file; }120 121 llvm::pdb::DbiStream &dbi() { return *m_dbi; }122 const llvm::pdb::DbiStream &dbi() const { return *m_dbi; }123 124 llvm::pdb::TpiStream &tpi() { return *m_tpi; }125 const llvm::pdb::TpiStream &tpi() const { return *m_tpi; }126 127 llvm::pdb::TpiStream &ipi() { return *m_ipi; }128 const llvm::pdb::TpiStream &ipi() const { return *m_ipi; }129 130 llvm::pdb::InfoStream &info() { return *m_info; }131 const llvm::pdb::InfoStream &info() const { return *m_info; }132 133 llvm::pdb::PublicsStream &publics() { return *m_publics; }134 const llvm::pdb::PublicsStream &publics() const { return *m_publics; }135 136 llvm::pdb::GlobalsStream &globals() { return *m_globals; }137 const llvm::pdb::GlobalsStream &globals() const { return *m_globals; }138 139 llvm::pdb::SymbolStream &symrecords() { return *m_symrecords; }140 const llvm::pdb::SymbolStream &symrecords() const { return *m_symrecords; }141 142 CompileUnitIndex &compilands() { return m_cus; }143 const CompileUnitIndex &compilands() const { return m_cus; }144 145 lldb::addr_t MakeVirtualAddress(uint16_t segment, uint32_t offset) const;146 147 std::vector<SymbolAndUid> FindSymbolsByVa(lldb::addr_t va);148 149 llvm::codeview::CVSymbol ReadSymbolRecord(PdbCompilandSymId cu_sym) const;150 llvm::codeview::CVSymbol ReadSymbolRecord(PdbGlobalSymId global) const;151 152 std::optional<uint16_t> GetModuleIndexForAddr(uint16_t segment,153 uint32_t offset) const;154 std::optional<uint16_t> GetModuleIndexForVa(lldb::addr_t va) const;155};156} // namespace npdb157} // namespace lldb_private158 159#endif160