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-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_PDBINDEX_H
10#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_PDBINDEX_H
11
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 pdb
33} // namespace llvm
34
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 cache
42/// certain data when it is accessed the first time. The entire PDB file is
43/// mapped into memory, and the underlying support libraries vend out memory
44/// that is always backed by the file, so it is safe to hold StringRefs and
45/// ArrayRefs into the backing memory as long as the PdbIndex instance is
46/// 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 the
53 /// features present in the PDB file, compile units (such as the information
54 /// necessary to locate full symbol information for each compile unit),
55 /// section contributions, and other data which is not specifically symbol or
56 /// type records.
57 llvm::pdb::DbiStream *m_dbi = nullptr;
58
59 /// TPI (types) and IPI (indices) streams. These are both in the exact same
60 /// format with different data. Most type records are stored in the TPI
61 /// 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 not
63 /// 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 fields
69 /// 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 are
73 /// addresses of symbols in the executable, and values are a record containing
74 /// mangled names and an index which can be used to locate more detailed info
75 /// about the symbol in the Symbol Records stream. The publics stream only
76 /// 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 information
80 /// about all "global variables" or "global functions". Rather, it is the
81 /// "global symbol table", i.e. it contains information about *every* symbol
82 /// in the executable. It is a hash table keyed on name, whose values are
83 /// 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 records
87 /// in this stream. For some records, like constants and typedefs, the
88 /// complete record lives in this stream. For other symbol types, such as
89 /// functions, data, and other things that have been materialied into a
90 /// specific compile unit, the records here simply provide a reference
91 /// 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 maps
99 llvm::IntervalMap<lldb::addr_t, uint32_t>::Allocator m_allocator;
100
101 /// Maps virtual address to module index
102 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 npdb
157} // namespace lldb_private
158
159#endif
160

source code of lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.h