1 //===-- SymbolFilePDB.cpp -------------------------------------------------===//
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 #include "SymbolFilePDB.h"
10
11 #include "PDBASTParser.h"
12 #include "PDBLocationToDWARFExpression.h"
13
14 #include "clang/Lex/Lexer.h"
15
16 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
17 #include "lldb/Core/Module.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Symbol/CompileUnit.h"
20 #include "lldb/Symbol/LineTable.h"
21 #include "lldb/Symbol/ObjectFile.h"
22 #include "lldb/Symbol/SymbolContext.h"
23 #include "lldb/Symbol/SymbolVendor.h"
24 #include "lldb/Symbol/TypeList.h"
25 #include "lldb/Symbol/TypeMap.h"
26 #include "lldb/Symbol/Variable.h"
27 #include "lldb/Utility/Log.h"
28 #include "lldb/Utility/RegularExpression.h"
29
30 #include "llvm/DebugInfo/PDB/GenericError.h"
31 #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
32 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
33 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
34 #include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
35 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
36 #include "llvm/DebugInfo/PDB/IPDBTable.h"
37 #include "llvm/DebugInfo/PDB/PDBSymbol.h"
38 #include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
39 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
40 #include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
41 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
42 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
43 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
44 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
45 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
46 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
47 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
48 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
49 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
50
51 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
52 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
53 #include "Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h"
54
55 #include <regex>
56
57 using namespace lldb;
58 using namespace lldb_private;
59 using namespace llvm::pdb;
60
61 LLDB_PLUGIN_DEFINE(SymbolFilePDB)
62
63 char SymbolFilePDB::ID;
64
65 namespace {
TranslateLanguage(PDB_Lang lang)66 lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
67 switch (lang) {
68 case PDB_Lang::Cpp:
69 return lldb::LanguageType::eLanguageTypeC_plus_plus;
70 case PDB_Lang::C:
71 return lldb::LanguageType::eLanguageTypeC;
72 case PDB_Lang::Swift:
73 return lldb::LanguageType::eLanguageTypeSwift;
74 default:
75 return lldb::LanguageType::eLanguageTypeUnknown;
76 }
77 }
78
ShouldAddLine(uint32_t requested_line,uint32_t actual_line,uint32_t addr_length)79 bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
80 uint32_t addr_length) {
81 return ((requested_line == 0 || actual_line == requested_line) &&
82 addr_length > 0);
83 }
84 } // namespace
85
ShouldUseNativeReader()86 static bool ShouldUseNativeReader() {
87 #if defined(_WIN32)
88 llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
89 return use_native.equals_lower("on") || use_native.equals_lower("yes") ||
90 use_native.equals_lower("1") || use_native.equals_lower("true");
91 #else
92 return true;
93 #endif
94 }
95
Initialize()96 void SymbolFilePDB::Initialize() {
97 if (ShouldUseNativeReader()) {
98 npdb::SymbolFileNativePDB::Initialize();
99 } else {
100 PluginManager::RegisterPlugin(GetPluginNameStatic(),
101 GetPluginDescriptionStatic(), CreateInstance,
102 DebuggerInitialize);
103 }
104 }
105
Terminate()106 void SymbolFilePDB::Terminate() {
107 if (ShouldUseNativeReader()) {
108 npdb::SymbolFileNativePDB::Terminate();
109 } else {
110 PluginManager::UnregisterPlugin(CreateInstance);
111 }
112 }
113
DebuggerInitialize(lldb_private::Debugger & debugger)114 void SymbolFilePDB::DebuggerInitialize(lldb_private::Debugger &debugger) {}
115
GetPluginNameStatic()116 lldb_private::ConstString SymbolFilePDB::GetPluginNameStatic() {
117 static ConstString g_name("pdb");
118 return g_name;
119 }
120
GetPluginDescriptionStatic()121 const char *SymbolFilePDB::GetPluginDescriptionStatic() {
122 return "Microsoft PDB debug symbol file reader.";
123 }
124
125 lldb_private::SymbolFile *
CreateInstance(ObjectFileSP objfile_sp)126 SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
127 return new SymbolFilePDB(std::move(objfile_sp));
128 }
129
SymbolFilePDB(lldb::ObjectFileSP objfile_sp)130 SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
131 : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
132
~SymbolFilePDB()133 SymbolFilePDB::~SymbolFilePDB() {}
134
CalculateAbilities()135 uint32_t SymbolFilePDB::CalculateAbilities() {
136 uint32_t abilities = 0;
137 if (!m_objfile_sp)
138 return 0;
139
140 if (!m_session_up) {
141 // Lazily load and match the PDB file, but only do this once.
142 std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
143 auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath),
144 m_session_up);
145 if (error) {
146 llvm::consumeError(std::move(error));
147 auto module_sp = m_objfile_sp->GetModule();
148 if (!module_sp)
149 return 0;
150 // See if any symbol file is specified through `--symfile` option.
151 FileSpec symfile = module_sp->GetSymbolFileFileSpec();
152 if (!symfile)
153 return 0;
154 error = loadDataForPDB(PDB_ReaderType::DIA,
155 llvm::StringRef(symfile.GetPath()), m_session_up);
156 if (error) {
157 llvm::consumeError(std::move(error));
158 return 0;
159 }
160 }
161 }
162 if (!m_session_up)
163 return 0;
164
165 auto enum_tables_up = m_session_up->getEnumTables();
166 if (!enum_tables_up)
167 return 0;
168 while (auto table_up = enum_tables_up->getNext()) {
169 if (table_up->getItemCount() == 0)
170 continue;
171 auto type = table_up->getTableType();
172 switch (type) {
173 case PDB_TableType::Symbols:
174 // This table represents a store of symbols with types listed in
175 // PDBSym_Type
176 abilities |= (CompileUnits | Functions | Blocks | GlobalVariables |
177 LocalVariables | VariableTypes);
178 break;
179 case PDB_TableType::LineNumbers:
180 abilities |= LineTables;
181 break;
182 default:
183 break;
184 }
185 }
186 return abilities;
187 }
188
InitializeObject()189 void SymbolFilePDB::InitializeObject() {
190 lldb::addr_t obj_load_address =
191 m_objfile_sp->GetBaseAddress().GetFileAddress();
192 lldbassert(obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS);
193 m_session_up->setLoadAddress(obj_load_address);
194 if (!m_global_scope_up)
195 m_global_scope_up = m_session_up->getGlobalScope();
196 lldbassert(m_global_scope_up.get());
197 }
198
CalculateNumCompileUnits()199 uint32_t SymbolFilePDB::CalculateNumCompileUnits() {
200 auto compilands = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
201 if (!compilands)
202 return 0;
203
204 // The linker could link *.dll (compiland language = LINK), or import
205 // *.dll. For example, a compiland with name `Import:KERNEL32.dll` could be
206 // found as a child of the global scope (PDB executable). Usually, such
207 // compilands contain `thunk` symbols in which we are not interested for
208 // now. However we still count them in the compiland list. If we perform
209 // any compiland related activity, like finding symbols through
210 // llvm::pdb::IPDBSession methods, such compilands will all be searched
211 // automatically no matter whether we include them or not.
212 uint32_t compile_unit_count = compilands->getChildCount();
213
214 // The linker can inject an additional "dummy" compilation unit into the
215 // PDB. Ignore this special compile unit for our purposes, if it is there.
216 // It is always the last one.
217 auto last_compiland_up = compilands->getChildAtIndex(compile_unit_count - 1);
218 lldbassert(last_compiland_up.get());
219 std::string name = last_compiland_up->getName();
220 if (name == "* Linker *")
221 --compile_unit_count;
222 return compile_unit_count;
223 }
224
GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland & pdb_compiland,uint32_t & index)225 void SymbolFilePDB::GetCompileUnitIndex(
226 const llvm::pdb::PDBSymbolCompiland &pdb_compiland, uint32_t &index) {
227 auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
228 if (!results_up)
229 return;
230 auto uid = pdb_compiland.getSymIndexId();
231 for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
232 auto compiland_up = results_up->getChildAtIndex(cu_idx);
233 if (!compiland_up)
234 continue;
235 if (compiland_up->getSymIndexId() == uid) {
236 index = cu_idx;
237 return;
238 }
239 }
240 index = UINT32_MAX;
241 return;
242 }
243
244 std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
GetPDBCompilandByUID(uint32_t uid)245 SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) {
246 return m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(uid);
247 }
248
ParseCompileUnitAtIndex(uint32_t index)249 lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
250 if (index >= GetNumCompileUnits())
251 return CompUnitSP();
252
253 // Assuming we always retrieve same compilands listed in same order through
254 // `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a
255 // compile unit makes no sense.
256 auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
257 if (!results)
258 return CompUnitSP();
259 auto compiland_up = results->getChildAtIndex(index);
260 if (!compiland_up)
261 return CompUnitSP();
262 return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
263 }
264
ParseLanguage(CompileUnit & comp_unit)265 lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
266 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
267 auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
268 if (!compiland_up)
269 return lldb::eLanguageTypeUnknown;
270 auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
271 if (!details)
272 return lldb::eLanguageTypeUnknown;
273 return TranslateLanguage(details->getLanguage());
274 }
275
276 lldb_private::Function *
ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc & pdb_func,CompileUnit & comp_unit)277 SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
278 CompileUnit &comp_unit) {
279 if (FunctionSP result = comp_unit.FindFunctionByUID(pdb_func.getSymIndexId()))
280 return result.get();
281
282 auto file_vm_addr = pdb_func.getVirtualAddress();
283 if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
284 return nullptr;
285
286 auto func_length = pdb_func.getLength();
287 AddressRange func_range =
288 AddressRange(file_vm_addr, func_length,
289 GetObjectFile()->GetModule()->GetSectionList());
290 if (!func_range.GetBaseAddress().IsValid())
291 return nullptr;
292
293 lldb_private::Type *func_type = ResolveTypeUID(pdb_func.getSymIndexId());
294 if (!func_type)
295 return nullptr;
296
297 user_id_t func_type_uid = pdb_func.getSignatureId();
298
299 Mangled mangled = GetMangledForPDBFunc(pdb_func);
300
301 FunctionSP func_sp =
302 std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
303 func_type_uid, mangled, func_type, func_range);
304
305 comp_unit.AddFunction(func_sp);
306
307 LanguageType lang = ParseLanguage(comp_unit);
308 auto type_system_or_err = GetTypeSystemForLanguage(lang);
309 if (auto err = type_system_or_err.takeError()) {
310 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
311 std::move(err), "Unable to parse PDBFunc");
312 return nullptr;
313 }
314
315 TypeSystemClang *clang_type_system =
316 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
317 if (!clang_type_system)
318 return nullptr;
319 clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
320
321 return func_sp.get();
322 }
323
ParseFunctions(CompileUnit & comp_unit)324 size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
325 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
326 size_t func_added = 0;
327 auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
328 if (!compiland_up)
329 return 0;
330 auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
331 if (!results_up)
332 return 0;
333 while (auto pdb_func_up = results_up->getNext()) {
334 auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
335 if (!func_sp) {
336 if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
337 ++func_added;
338 }
339 }
340 return func_added;
341 }
342
ParseLineTable(CompileUnit & comp_unit)343 bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
344 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
345 if (comp_unit.GetLineTable())
346 return true;
347 return ParseCompileUnitLineTable(comp_unit, 0);
348 }
349
ParseDebugMacros(CompileUnit & comp_unit)350 bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
351 // PDB doesn't contain information about macros
352 return false;
353 }
354
ParseSupportFiles(CompileUnit & comp_unit,lldb_private::FileSpecList & support_files)355 bool SymbolFilePDB::ParseSupportFiles(
356 CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {
357
358 // In theory this is unnecessary work for us, because all of this information
359 // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
360 // second time seems like a waste. Unfortunately, there's no good way around
361 // this short of a moderate refactor since SymbolVendor depends on being able
362 // to cache this list.
363 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
364 auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
365 if (!compiland_up)
366 return false;
367 auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
368 if (!files || files->getChildCount() == 0)
369 return false;
370
371 while (auto file = files->getNext()) {
372 FileSpec spec(file->getFileName(), FileSpec::Style::windows);
373 support_files.AppendIfUnique(spec);
374 }
375
376 return true;
377 }
378
ParseImportedModules(const lldb_private::SymbolContext & sc,std::vector<SourceModule> & imported_modules)379 bool SymbolFilePDB::ParseImportedModules(
380 const lldb_private::SymbolContext &sc,
381 std::vector<SourceModule> &imported_modules) {
382 // PDB does not yet support module debug info
383 return false;
384 }
385
ParseFunctionBlocksForPDBSymbol(uint64_t func_file_vm_addr,const llvm::pdb::PDBSymbol * pdb_symbol,lldb_private::Block * parent_block,bool is_top_parent)386 static size_t ParseFunctionBlocksForPDBSymbol(
387 uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
388 lldb_private::Block *parent_block, bool is_top_parent) {
389 assert(pdb_symbol && parent_block);
390
391 size_t num_added = 0;
392 switch (pdb_symbol->getSymTag()) {
393 case PDB_SymType::Block:
394 case PDB_SymType::Function: {
395 Block *block = nullptr;
396 auto &raw_sym = pdb_symbol->getRawSymbol();
397 if (auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(pdb_symbol)) {
398 if (pdb_func->hasNoInlineAttribute())
399 break;
400 if (is_top_parent)
401 block = parent_block;
402 else
403 break;
404 } else if (llvm::dyn_cast<PDBSymbolBlock>(pdb_symbol)) {
405 auto uid = pdb_symbol->getSymIndexId();
406 if (parent_block->FindBlockByID(uid))
407 break;
408 if (raw_sym.getVirtualAddress() < func_file_vm_addr)
409 break;
410
411 auto block_sp = std::make_shared<Block>(pdb_symbol->getSymIndexId());
412 parent_block->AddChild(block_sp);
413 block = block_sp.get();
414 } else
415 llvm_unreachable("Unexpected PDB symbol!");
416
417 block->AddRange(Block::Range(
418 raw_sym.getVirtualAddress() - func_file_vm_addr, raw_sym.getLength()));
419 block->FinalizeRanges();
420 ++num_added;
421
422 auto results_up = pdb_symbol->findAllChildren();
423 if (!results_up)
424 break;
425 while (auto symbol_up = results_up->getNext()) {
426 num_added += ParseFunctionBlocksForPDBSymbol(
427 func_file_vm_addr, symbol_up.get(), block, false);
428 }
429 } break;
430 default:
431 break;
432 }
433 return num_added;
434 }
435
ParseBlocksRecursive(Function & func)436 size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
437 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
438 size_t num_added = 0;
439 auto uid = func.GetID();
440 auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
441 if (!pdb_func_up)
442 return 0;
443 Block &parent_block = func.GetBlock(false);
444 num_added = ParseFunctionBlocksForPDBSymbol(
445 pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
446 return num_added;
447 }
448
ParseTypes(CompileUnit & comp_unit)449 size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
450 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
451
452 size_t num_added = 0;
453 auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
454 if (!compiland)
455 return 0;
456
457 auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
458 std::unique_ptr<IPDBEnumSymbols> results;
459 PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
460 PDB_SymType::UDT};
461 for (auto tag : tags_to_search) {
462 results = raw_sym.findAllChildren(tag);
463 if (!results || results->getChildCount() == 0)
464 continue;
465 while (auto symbol = results->getNext()) {
466 switch (symbol->getSymTag()) {
467 case PDB_SymType::Enum:
468 case PDB_SymType::UDT:
469 case PDB_SymType::Typedef:
470 break;
471 default:
472 continue;
473 }
474
475 // This should cause the type to get cached and stored in the `m_types`
476 // lookup.
477 if (auto type = ResolveTypeUID(symbol->getSymIndexId())) {
478 // Resolve the type completely to avoid a completion
479 // (and so a list change, which causes an iterators invalidation)
480 // during a TypeList dumping
481 type->GetFullCompilerType();
482 ++num_added;
483 }
484 }
485 }
486 };
487
488 ParseTypesByTagFn(*compiland);
489
490 // Also parse global types particularly coming from this compiland.
491 // Unfortunately, PDB has no compiland information for each global type. We
492 // have to parse them all. But ensure we only do this once.
493 static bool parse_all_global_types = false;
494 if (!parse_all_global_types) {
495 ParseTypesByTagFn(*m_global_scope_up);
496 parse_all_global_types = true;
497 }
498 return num_added;
499 }
500
501 size_t
ParseVariablesForContext(const lldb_private::SymbolContext & sc)502 SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) {
503 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
504 if (!sc.comp_unit)
505 return 0;
506
507 size_t num_added = 0;
508 if (sc.function) {
509 auto pdb_func = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(
510 sc.function->GetID());
511 if (!pdb_func)
512 return 0;
513
514 num_added += ParseVariables(sc, *pdb_func);
515 sc.function->GetBlock(false).SetDidParseVariables(true, true);
516 } else if (sc.comp_unit) {
517 auto compiland = GetPDBCompilandByUID(sc.comp_unit->GetID());
518 if (!compiland)
519 return 0;
520
521 if (sc.comp_unit->GetVariableList(false))
522 return 0;
523
524 auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
525 if (results && results->getChildCount()) {
526 while (auto result = results->getNext()) {
527 auto cu_id = GetCompilandId(*result);
528 // FIXME: We are not able to determine variable's compile unit.
529 if (cu_id == 0)
530 continue;
531
532 if (cu_id == sc.comp_unit->GetID())
533 num_added += ParseVariables(sc, *result);
534 }
535 }
536
537 // FIXME: A `file static` or `global constant` variable appears both in
538 // compiland's children and global scope's children with unexpectedly
539 // different symbol's Id making it ambiguous.
540
541 // FIXME: 'local constant', for example, const char var[] = "abc", declared
542 // in a function scope, can't be found in PDB.
543
544 // Parse variables in this compiland.
545 num_added += ParseVariables(sc, *compiland);
546 }
547
548 return num_added;
549 }
550
ResolveTypeUID(lldb::user_id_t type_uid)551 lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
552 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
553 auto find_result = m_types.find(type_uid);
554 if (find_result != m_types.end())
555 return find_result->second.get();
556
557 auto type_system_or_err =
558 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
559 if (auto err = type_system_or_err.takeError()) {
560 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
561 std::move(err), "Unable to ResolveTypeUID");
562 return nullptr;
563 }
564
565 TypeSystemClang *clang_type_system =
566 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
567 if (!clang_type_system)
568 return nullptr;
569 PDBASTParser *pdb = clang_type_system->GetPDBParser();
570 if (!pdb)
571 return nullptr;
572
573 auto pdb_type = m_session_up->getSymbolById(type_uid);
574 if (pdb_type == nullptr)
575 return nullptr;
576
577 lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
578 if (result) {
579 m_types.insert(std::make_pair(type_uid, result));
580 GetTypeList().Insert(result);
581 }
582 return result.get();
583 }
584
GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,const lldb_private::ExecutionContext * exe_ctx)585 llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
586 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
587 return llvm::None;
588 }
589
CompleteType(lldb_private::CompilerType & compiler_type)590 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
591 std::lock_guard<std::recursive_mutex> guard(
592 GetObjectFile()->GetModule()->GetMutex());
593
594 auto type_system_or_err =
595 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
596 if (auto err = type_system_or_err.takeError()) {
597 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
598 std::move(err), "Unable to get dynamic array info for UID");
599 return false;
600 }
601
602 TypeSystemClang *clang_ast_ctx =
603 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
604
605 if (!clang_ast_ctx)
606 return false;
607
608 PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
609 if (!pdb)
610 return false;
611
612 return pdb->CompleteTypeFromPDB(compiler_type);
613 }
614
GetDeclForUID(lldb::user_id_t uid)615 lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
616 auto type_system_or_err =
617 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
618 if (auto err = type_system_or_err.takeError()) {
619 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
620 std::move(err), "Unable to get decl for UID");
621 return CompilerDecl();
622 }
623
624 TypeSystemClang *clang_ast_ctx =
625 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
626 if (!clang_ast_ctx)
627 return CompilerDecl();
628
629 PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
630 if (!pdb)
631 return CompilerDecl();
632
633 auto symbol = m_session_up->getSymbolById(uid);
634 if (!symbol)
635 return CompilerDecl();
636
637 auto decl = pdb->GetDeclForSymbol(*symbol);
638 if (!decl)
639 return CompilerDecl();
640
641 return clang_ast_ctx->GetCompilerDecl(decl);
642 }
643
644 lldb_private::CompilerDeclContext
GetDeclContextForUID(lldb::user_id_t uid)645 SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
646 auto type_system_or_err =
647 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
648 if (auto err = type_system_or_err.takeError()) {
649 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
650 std::move(err), "Unable to get DeclContext for UID");
651 return CompilerDeclContext();
652 }
653
654 TypeSystemClang *clang_ast_ctx =
655 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
656 if (!clang_ast_ctx)
657 return CompilerDeclContext();
658
659 PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
660 if (!pdb)
661 return CompilerDeclContext();
662
663 auto symbol = m_session_up->getSymbolById(uid);
664 if (!symbol)
665 return CompilerDeclContext();
666
667 auto decl_context = pdb->GetDeclContextForSymbol(*symbol);
668 if (!decl_context)
669 return GetDeclContextContainingUID(uid);
670
671 return clang_ast_ctx->CreateDeclContext(decl_context);
672 }
673
674 lldb_private::CompilerDeclContext
GetDeclContextContainingUID(lldb::user_id_t uid)675 SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
676 auto type_system_or_err =
677 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
678 if (auto err = type_system_or_err.takeError()) {
679 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
680 std::move(err), "Unable to get DeclContext containing UID");
681 return CompilerDeclContext();
682 }
683
684 TypeSystemClang *clang_ast_ctx =
685 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
686 if (!clang_ast_ctx)
687 return CompilerDeclContext();
688
689 PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
690 if (!pdb)
691 return CompilerDeclContext();
692
693 auto symbol = m_session_up->getSymbolById(uid);
694 if (!symbol)
695 return CompilerDeclContext();
696
697 auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
698 assert(decl_context);
699
700 return clang_ast_ctx->CreateDeclContext(decl_context);
701 }
702
ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx)703 void SymbolFilePDB::ParseDeclsForContext(
704 lldb_private::CompilerDeclContext decl_ctx) {
705 auto type_system_or_err =
706 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
707 if (auto err = type_system_or_err.takeError()) {
708 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
709 std::move(err), "Unable to parse decls for context");
710 return;
711 }
712
713 TypeSystemClang *clang_ast_ctx =
714 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
715 if (!clang_ast_ctx)
716 return;
717
718 PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
719 if (!pdb)
720 return;
721
722 pdb->ParseDeclsForDeclContext(
723 static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
724 }
725
726 uint32_t
ResolveSymbolContext(const lldb_private::Address & so_addr,SymbolContextItem resolve_scope,lldb_private::SymbolContext & sc)727 SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
728 SymbolContextItem resolve_scope,
729 lldb_private::SymbolContext &sc) {
730 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
731 uint32_t resolved_flags = 0;
732 if (resolve_scope & eSymbolContextCompUnit ||
733 resolve_scope & eSymbolContextVariable ||
734 resolve_scope & eSymbolContextFunction ||
735 resolve_scope & eSymbolContextBlock ||
736 resolve_scope & eSymbolContextLineEntry) {
737 auto cu_sp = GetCompileUnitContainsAddress(so_addr);
738 if (!cu_sp) {
739 if (resolved_flags & eSymbolContextVariable) {
740 // TODO: Resolve variables
741 }
742 return 0;
743 }
744 sc.comp_unit = cu_sp.get();
745 resolved_flags |= eSymbolContextCompUnit;
746 lldbassert(sc.module_sp == cu_sp->GetModule());
747 }
748
749 if (resolve_scope & eSymbolContextFunction ||
750 resolve_scope & eSymbolContextBlock) {
751 addr_t file_vm_addr = so_addr.GetFileAddress();
752 auto symbol_up =
753 m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
754 if (symbol_up) {
755 auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
756 assert(pdb_func);
757 auto func_uid = pdb_func->getSymIndexId();
758 sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
759 if (sc.function == nullptr)
760 sc.function =
761 ParseCompileUnitFunctionForPDBFunc(*pdb_func, *sc.comp_unit);
762 if (sc.function) {
763 resolved_flags |= eSymbolContextFunction;
764 if (resolve_scope & eSymbolContextBlock) {
765 auto block_symbol = m_session_up->findSymbolByAddress(
766 file_vm_addr, PDB_SymType::Block);
767 auto block_id = block_symbol ? block_symbol->getSymIndexId()
768 : sc.function->GetID();
769 sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
770 if (sc.block)
771 resolved_flags |= eSymbolContextBlock;
772 }
773 }
774 }
775 }
776
777 if (resolve_scope & eSymbolContextLineEntry) {
778 if (auto *line_table = sc.comp_unit->GetLineTable()) {
779 Address addr(so_addr);
780 if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
781 resolved_flags |= eSymbolContextLineEntry;
782 }
783 }
784
785 return resolved_flags;
786 }
787
ResolveSymbolContext(const lldb_private::FileSpec & file_spec,uint32_t line,bool check_inlines,SymbolContextItem resolve_scope,lldb_private::SymbolContextList & sc_list)788 uint32_t SymbolFilePDB::ResolveSymbolContext(
789 const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines,
790 SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
791 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
792 const size_t old_size = sc_list.GetSize();
793 if (resolve_scope & lldb::eSymbolContextCompUnit) {
794 // Locate all compilation units with line numbers referencing the specified
795 // file. For example, if `file_spec` is <vector>, then this should return
796 // all source files and header files that reference <vector>, either
797 // directly or indirectly.
798 auto compilands = m_session_up->findCompilandsForSourceFile(
799 file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
800
801 if (!compilands)
802 return 0;
803
804 // For each one, either find its previously parsed data or parse it afresh
805 // and add it to the symbol context list.
806 while (auto compiland = compilands->getNext()) {
807 // If we're not checking inlines, then don't add line information for
808 // this file unless the FileSpec matches. For inline functions, we don't
809 // have to match the FileSpec since they could be defined in headers
810 // other than file specified in FileSpec.
811 if (!check_inlines) {
812 std::string source_file = compiland->getSourceFileFullPath();
813 if (source_file.empty())
814 continue;
815 FileSpec this_spec(source_file, FileSpec::Style::windows);
816 bool need_full_match = !file_spec.GetDirectory().IsEmpty();
817 if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
818 continue;
819 }
820
821 SymbolContext sc;
822 auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
823 if (!cu)
824 continue;
825 sc.comp_unit = cu.get();
826 sc.module_sp = cu->GetModule();
827
828 // If we were asked to resolve line entries, add all entries to the line
829 // table that match the requested line (or all lines if `line` == 0).
830 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
831 eSymbolContextLineEntry)) {
832 bool has_line_table = ParseCompileUnitLineTable(*sc.comp_unit, line);
833
834 if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
835 // The query asks for line entries, but we can't get them for the
836 // compile unit. This is not normal for `line` = 0. So just assert
837 // it.
838 assert(line && "Couldn't get all line entries!\n");
839
840 // Current compiland does not have the requested line. Search next.
841 continue;
842 }
843
844 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
845 if (!has_line_table)
846 continue;
847
848 auto *line_table = sc.comp_unit->GetLineTable();
849 lldbassert(line_table);
850
851 uint32_t num_line_entries = line_table->GetSize();
852 // Skip the terminal line entry.
853 --num_line_entries;
854
855 // If `line `!= 0, see if we can resolve function for each line entry
856 // in the line table.
857 for (uint32_t line_idx = 0; line && line_idx < num_line_entries;
858 ++line_idx) {
859 if (!line_table->GetLineEntryAtIndex(line_idx, sc.line_entry))
860 continue;
861
862 auto file_vm_addr =
863 sc.line_entry.range.GetBaseAddress().GetFileAddress();
864 if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
865 continue;
866
867 auto symbol_up = m_session_up->findSymbolByAddress(
868 file_vm_addr, PDB_SymType::Function);
869 if (symbol_up) {
870 auto func_uid = symbol_up->getSymIndexId();
871 sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
872 if (sc.function == nullptr) {
873 auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
874 assert(pdb_func);
875 sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func,
876 *sc.comp_unit);
877 }
878 if (sc.function && (resolve_scope & eSymbolContextBlock)) {
879 Block &block = sc.function->GetBlock(true);
880 sc.block = block.FindBlockByID(sc.function->GetID());
881 }
882 }
883 sc_list.Append(sc);
884 }
885 } else if (has_line_table) {
886 // We can parse line table for the compile unit. But no query to
887 // resolve function or block. We append `sc` to the list anyway.
888 sc_list.Append(sc);
889 }
890 } else {
891 // No query for line entry, function or block. But we have a valid
892 // compile unit, append `sc` to the list.
893 sc_list.Append(sc);
894 }
895 }
896 }
897 return sc_list.GetSize() - old_size;
898 }
899
GetMangledForPDBData(const PDBSymbolData & pdb_data)900 std::string SymbolFilePDB::GetMangledForPDBData(const PDBSymbolData &pdb_data) {
901 // Cache public names at first
902 if (m_public_names.empty())
903 if (auto result_up =
904 m_global_scope_up->findAllChildren(PDB_SymType::PublicSymbol))
905 while (auto symbol_up = result_up->getNext())
906 if (auto addr = symbol_up->getRawSymbol().getVirtualAddress())
907 m_public_names[addr] = symbol_up->getRawSymbol().getName();
908
909 // Look up the name in the cache
910 return m_public_names.lookup(pdb_data.getVirtualAddress());
911 }
912
ParseVariableForPDBData(const lldb_private::SymbolContext & sc,const llvm::pdb::PDBSymbolData & pdb_data)913 VariableSP SymbolFilePDB::ParseVariableForPDBData(
914 const lldb_private::SymbolContext &sc,
915 const llvm::pdb::PDBSymbolData &pdb_data) {
916 VariableSP var_sp;
917 uint32_t var_uid = pdb_data.getSymIndexId();
918 auto result = m_variables.find(var_uid);
919 if (result != m_variables.end())
920 return result->second;
921
922 ValueType scope = eValueTypeInvalid;
923 bool is_static_member = false;
924 bool is_external = false;
925 bool is_artificial = false;
926
927 switch (pdb_data.getDataKind()) {
928 case PDB_DataKind::Global:
929 scope = eValueTypeVariableGlobal;
930 is_external = true;
931 break;
932 case PDB_DataKind::Local:
933 scope = eValueTypeVariableLocal;
934 break;
935 case PDB_DataKind::FileStatic:
936 scope = eValueTypeVariableStatic;
937 break;
938 case PDB_DataKind::StaticMember:
939 is_static_member = true;
940 scope = eValueTypeVariableStatic;
941 break;
942 case PDB_DataKind::Member:
943 scope = eValueTypeVariableStatic;
944 break;
945 case PDB_DataKind::Param:
946 scope = eValueTypeVariableArgument;
947 break;
948 case PDB_DataKind::Constant:
949 scope = eValueTypeConstResult;
950 break;
951 default:
952 break;
953 }
954
955 switch (pdb_data.getLocationType()) {
956 case PDB_LocType::TLS:
957 scope = eValueTypeVariableThreadLocal;
958 break;
959 case PDB_LocType::RegRel: {
960 // It is a `this` pointer.
961 if (pdb_data.getDataKind() == PDB_DataKind::ObjectPtr) {
962 scope = eValueTypeVariableArgument;
963 is_artificial = true;
964 }
965 } break;
966 default:
967 break;
968 }
969
970 Declaration decl;
971 if (!is_artificial && !pdb_data.isCompilerGenerated()) {
972 if (auto lines = pdb_data.getLineNumbers()) {
973 if (auto first_line = lines->getNext()) {
974 uint32_t src_file_id = first_line->getSourceFileId();
975 auto src_file = m_session_up->getSourceFileById(src_file_id);
976 if (src_file) {
977 FileSpec spec(src_file->getFileName());
978 decl.SetFile(spec);
979 decl.SetColumn(first_line->getColumnNumber());
980 decl.SetLine(first_line->getLineNumber());
981 }
982 }
983 }
984 }
985
986 Variable::RangeList ranges;
987 SymbolContextScope *context_scope = sc.comp_unit;
988 if (scope == eValueTypeVariableLocal || scope == eValueTypeVariableArgument) {
989 if (sc.function) {
990 Block &function_block = sc.function->GetBlock(true);
991 Block *block =
992 function_block.FindBlockByID(pdb_data.getLexicalParentId());
993 if (!block)
994 block = &function_block;
995
996 context_scope = block;
997
998 for (size_t i = 0, num_ranges = block->GetNumRanges(); i < num_ranges;
999 ++i) {
1000 AddressRange range;
1001 if (!block->GetRangeAtIndex(i, range))
1002 continue;
1003
1004 ranges.Append(range.GetBaseAddress().GetFileAddress(),
1005 range.GetByteSize());
1006 }
1007 }
1008 }
1009
1010 SymbolFileTypeSP type_sp =
1011 std::make_shared<SymbolFileType>(*this, pdb_data.getTypeId());
1012
1013 auto var_name = pdb_data.getName();
1014 auto mangled = GetMangledForPDBData(pdb_data);
1015 auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();
1016
1017 bool is_constant;
1018 DWARFExpression location = ConvertPDBLocationToDWARFExpression(
1019 GetObjectFile()->GetModule(), pdb_data, ranges, is_constant);
1020
1021 var_sp = std::make_shared<Variable>(
1022 var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
1023 ranges, &decl, location, is_external, is_artificial, is_static_member);
1024 var_sp->SetLocationIsConstantValueData(is_constant);
1025
1026 m_variables.insert(std::make_pair(var_uid, var_sp));
1027 return var_sp;
1028 }
1029
1030 size_t
ParseVariables(const lldb_private::SymbolContext & sc,const llvm::pdb::PDBSymbol & pdb_symbol,lldb_private::VariableList * variable_list)1031 SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
1032 const llvm::pdb::PDBSymbol &pdb_symbol,
1033 lldb_private::VariableList *variable_list) {
1034 size_t num_added = 0;
1035
1036 if (auto pdb_data = llvm::dyn_cast<PDBSymbolData>(&pdb_symbol)) {
1037 VariableListSP local_variable_list_sp;
1038
1039 auto result = m_variables.find(pdb_data->getSymIndexId());
1040 if (result != m_variables.end()) {
1041 if (variable_list)
1042 variable_list->AddVariableIfUnique(result->second);
1043 } else {
1044 // Prepare right VariableList for this variable.
1045 if (auto lexical_parent = pdb_data->getLexicalParent()) {
1046 switch (lexical_parent->getSymTag()) {
1047 case PDB_SymType::Exe:
1048 assert(sc.comp_unit);
1049 LLVM_FALLTHROUGH;
1050 case PDB_SymType::Compiland: {
1051 if (sc.comp_unit) {
1052 local_variable_list_sp = sc.comp_unit->GetVariableList(false);
1053 if (!local_variable_list_sp) {
1054 local_variable_list_sp = std::make_shared<VariableList>();
1055 sc.comp_unit->SetVariableList(local_variable_list_sp);
1056 }
1057 }
1058 } break;
1059 case PDB_SymType::Block:
1060 case PDB_SymType::Function: {
1061 if (sc.function) {
1062 Block *block = sc.function->GetBlock(true).FindBlockByID(
1063 lexical_parent->getSymIndexId());
1064 if (block) {
1065 local_variable_list_sp = block->GetBlockVariableList(false);
1066 if (!local_variable_list_sp) {
1067 local_variable_list_sp = std::make_shared<VariableList>();
1068 block->SetVariableList(local_variable_list_sp);
1069 }
1070 }
1071 }
1072 } break;
1073 default:
1074 break;
1075 }
1076 }
1077
1078 if (local_variable_list_sp) {
1079 if (auto var_sp = ParseVariableForPDBData(sc, *pdb_data)) {
1080 local_variable_list_sp->AddVariableIfUnique(var_sp);
1081 if (variable_list)
1082 variable_list->AddVariableIfUnique(var_sp);
1083 ++num_added;
1084 PDBASTParser *ast = GetPDBAstParser();
1085 if (ast)
1086 ast->GetDeclForSymbol(*pdb_data);
1087 }
1088 }
1089 }
1090 }
1091
1092 if (auto results = pdb_symbol.findAllChildren()) {
1093 while (auto result = results->getNext())
1094 num_added += ParseVariables(sc, *result, variable_list);
1095 }
1096
1097 return num_added;
1098 }
1099
FindGlobalVariables(lldb_private::ConstString name,const CompilerDeclContext & parent_decl_ctx,uint32_t max_matches,lldb_private::VariableList & variables)1100 void SymbolFilePDB::FindGlobalVariables(
1101 lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
1102 uint32_t max_matches, lldb_private::VariableList &variables) {
1103 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1104 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1105 return;
1106 if (name.IsEmpty())
1107 return;
1108
1109 auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
1110 if (!results)
1111 return;
1112
1113 uint32_t matches = 0;
1114 size_t old_size = variables.GetSize();
1115 while (auto result = results->getNext()) {
1116 auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
1117 if (max_matches > 0 && matches >= max_matches)
1118 break;
1119
1120 SymbolContext sc;
1121 sc.module_sp = m_objfile_sp->GetModule();
1122 lldbassert(sc.module_sp.get());
1123
1124 if (!name.GetStringRef().equals(
1125 MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
1126 continue;
1127
1128 sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
1129 // FIXME: We are not able to determine the compile unit.
1130 if (sc.comp_unit == nullptr)
1131 continue;
1132
1133 if (parent_decl_ctx.IsValid() &&
1134 GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
1135 continue;
1136
1137 ParseVariables(sc, *pdb_data, &variables);
1138 matches = variables.GetSize() - old_size;
1139 }
1140 }
1141
FindGlobalVariables(const lldb_private::RegularExpression & regex,uint32_t max_matches,lldb_private::VariableList & variables)1142 void SymbolFilePDB::FindGlobalVariables(
1143 const lldb_private::RegularExpression ®ex, uint32_t max_matches,
1144 lldb_private::VariableList &variables) {
1145 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1146 if (!regex.IsValid())
1147 return;
1148 auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
1149 if (!results)
1150 return;
1151
1152 uint32_t matches = 0;
1153 size_t old_size = variables.GetSize();
1154 while (auto pdb_data = results->getNext()) {
1155 if (max_matches > 0 && matches >= max_matches)
1156 break;
1157
1158 auto var_name = pdb_data->getName();
1159 if (var_name.empty())
1160 continue;
1161 if (!regex.Execute(var_name))
1162 continue;
1163 SymbolContext sc;
1164 sc.module_sp = m_objfile_sp->GetModule();
1165 lldbassert(sc.module_sp.get());
1166
1167 sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
1168 // FIXME: We are not able to determine the compile unit.
1169 if (sc.comp_unit == nullptr)
1170 continue;
1171
1172 ParseVariables(sc, *pdb_data, &variables);
1173 matches = variables.GetSize() - old_size;
1174 }
1175 }
1176
ResolveFunction(const llvm::pdb::PDBSymbolFunc & pdb_func,bool include_inlines,lldb_private::SymbolContextList & sc_list)1177 bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
1178 bool include_inlines,
1179 lldb_private::SymbolContextList &sc_list) {
1180 lldb_private::SymbolContext sc;
1181 sc.comp_unit = ParseCompileUnitForUID(pdb_func.getCompilandId()).get();
1182 if (!sc.comp_unit)
1183 return false;
1184 sc.module_sp = sc.comp_unit->GetModule();
1185 sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, *sc.comp_unit);
1186 if (!sc.function)
1187 return false;
1188
1189 sc_list.Append(sc);
1190 return true;
1191 }
1192
ResolveFunction(uint32_t uid,bool include_inlines,lldb_private::SymbolContextList & sc_list)1193 bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
1194 lldb_private::SymbolContextList &sc_list) {
1195 auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
1196 if (!pdb_func_up && !(include_inlines && pdb_func_up->hasInlineAttribute()))
1197 return false;
1198 return ResolveFunction(*pdb_func_up, include_inlines, sc_list);
1199 }
1200
CacheFunctionNames()1201 void SymbolFilePDB::CacheFunctionNames() {
1202 if (!m_func_full_names.IsEmpty())
1203 return;
1204
1205 std::map<uint64_t, uint32_t> addr_ids;
1206
1207 if (auto results_up = m_global_scope_up->findAllChildren<PDBSymbolFunc>()) {
1208 while (auto pdb_func_up = results_up->getNext()) {
1209 if (pdb_func_up->isCompilerGenerated())
1210 continue;
1211
1212 auto name = pdb_func_up->getName();
1213 auto demangled_name = pdb_func_up->getUndecoratedName();
1214 if (name.empty() && demangled_name.empty())
1215 continue;
1216
1217 auto uid = pdb_func_up->getSymIndexId();
1218 if (!demangled_name.empty() && pdb_func_up->getVirtualAddress())
1219 addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));
1220
1221 if (auto parent = pdb_func_up->getClassParent()) {
1222
1223 // PDB have symbols for class/struct methods or static methods in Enum
1224 // Class. We won't bother to check if the parent is UDT or Enum here.
1225 m_func_method_names.Append(ConstString(name), uid);
1226
1227 // To search a method name, like NS::Class:MemberFunc, LLDB searches
1228 // its base name, i.e. MemberFunc by default. Since PDBSymbolFunc does
1229 // not have information of this, we extract base names and cache them
1230 // by our own effort.
1231 llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
1232 if (!basename.empty())
1233 m_func_base_names.Append(ConstString(basename), uid);
1234 else {
1235 m_func_base_names.Append(ConstString(name), uid);
1236 }
1237
1238 if (!demangled_name.empty())
1239 m_func_full_names.Append(ConstString(demangled_name), uid);
1240
1241 } else {
1242 // Handle not-method symbols.
1243
1244 // The function name might contain namespace, or its lexical scope.
1245 llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
1246 if (!basename.empty())
1247 m_func_base_names.Append(ConstString(basename), uid);
1248 else
1249 m_func_base_names.Append(ConstString(name), uid);
1250
1251 if (name == "main") {
1252 m_func_full_names.Append(ConstString(name), uid);
1253
1254 if (!demangled_name.empty() && name != demangled_name) {
1255 m_func_full_names.Append(ConstString(demangled_name), uid);
1256 m_func_base_names.Append(ConstString(demangled_name), uid);
1257 }
1258 } else if (!demangled_name.empty()) {
1259 m_func_full_names.Append(ConstString(demangled_name), uid);
1260 } else {
1261 m_func_full_names.Append(ConstString(name), uid);
1262 }
1263 }
1264 }
1265 }
1266
1267 if (auto results_up =
1268 m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>()) {
1269 while (auto pub_sym_up = results_up->getNext()) {
1270 if (!pub_sym_up->isFunction())
1271 continue;
1272 auto name = pub_sym_up->getName();
1273 if (name.empty())
1274 continue;
1275
1276 if (CPlusPlusLanguage::IsCPPMangledName(name.c_str())) {
1277 auto vm_addr = pub_sym_up->getVirtualAddress();
1278
1279 // PDB public symbol has mangled name for its associated function.
1280 if (vm_addr && addr_ids.find(vm_addr) != addr_ids.end()) {
1281 // Cache mangled name.
1282 m_func_full_names.Append(ConstString(name), addr_ids[vm_addr]);
1283 }
1284 }
1285 }
1286 }
1287 // Sort them before value searching is working properly
1288 m_func_full_names.Sort();
1289 m_func_full_names.SizeToFit();
1290 m_func_method_names.Sort();
1291 m_func_method_names.SizeToFit();
1292 m_func_base_names.Sort();
1293 m_func_base_names.SizeToFit();
1294 }
1295
FindFunctions(lldb_private::ConstString name,const lldb_private::CompilerDeclContext & parent_decl_ctx,FunctionNameType name_type_mask,bool include_inlines,lldb_private::SymbolContextList & sc_list)1296 void SymbolFilePDB::FindFunctions(
1297 lldb_private::ConstString name,
1298 const lldb_private::CompilerDeclContext &parent_decl_ctx,
1299 FunctionNameType name_type_mask, bool include_inlines,
1300 lldb_private::SymbolContextList &sc_list) {
1301 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1302 lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
1303
1304 if (name_type_mask == eFunctionNameTypeNone)
1305 return;
1306 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1307 return;
1308 if (name.IsEmpty())
1309 return;
1310
1311 if (name_type_mask & eFunctionNameTypeFull ||
1312 name_type_mask & eFunctionNameTypeBase ||
1313 name_type_mask & eFunctionNameTypeMethod) {
1314 CacheFunctionNames();
1315
1316 std::set<uint32_t> resolved_ids;
1317 auto ResolveFn = [this, &name, parent_decl_ctx, include_inlines, &sc_list,
1318 &resolved_ids](UniqueCStringMap<uint32_t> &Names) {
1319 std::vector<uint32_t> ids;
1320 if (!Names.GetValues(name, ids))
1321 return;
1322
1323 for (uint32_t id : ids) {
1324 if (resolved_ids.find(id) != resolved_ids.end())
1325 continue;
1326
1327 if (parent_decl_ctx.IsValid() &&
1328 GetDeclContextContainingUID(id) != parent_decl_ctx)
1329 continue;
1330
1331 if (ResolveFunction(id, include_inlines, sc_list))
1332 resolved_ids.insert(id);
1333 }
1334 };
1335 if (name_type_mask & eFunctionNameTypeFull) {
1336 ResolveFn(m_func_full_names);
1337 ResolveFn(m_func_base_names);
1338 ResolveFn(m_func_method_names);
1339 }
1340 if (name_type_mask & eFunctionNameTypeBase)
1341 ResolveFn(m_func_base_names);
1342 if (name_type_mask & eFunctionNameTypeMethod)
1343 ResolveFn(m_func_method_names);
1344 }
1345 }
1346
FindFunctions(const lldb_private::RegularExpression & regex,bool include_inlines,lldb_private::SymbolContextList & sc_list)1347 void SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression ®ex,
1348 bool include_inlines,
1349 lldb_private::SymbolContextList &sc_list) {
1350 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1351 if (!regex.IsValid())
1352 return;
1353
1354 CacheFunctionNames();
1355
1356 std::set<uint32_t> resolved_ids;
1357 auto ResolveFn = [®ex, include_inlines, &sc_list, &resolved_ids,
1358 this](UniqueCStringMap<uint32_t> &Names) {
1359 std::vector<uint32_t> ids;
1360 if (Names.GetValues(regex, ids)) {
1361 for (auto id : ids) {
1362 if (resolved_ids.find(id) == resolved_ids.end())
1363 if (ResolveFunction(id, include_inlines, sc_list))
1364 resolved_ids.insert(id);
1365 }
1366 }
1367 };
1368 ResolveFn(m_func_full_names);
1369 ResolveFn(m_func_base_names);
1370 }
1371
GetMangledNamesForFunction(const std::string & scope_qualified_name,std::vector<lldb_private::ConstString> & mangled_names)1372 void SymbolFilePDB::GetMangledNamesForFunction(
1373 const std::string &scope_qualified_name,
1374 std::vector<lldb_private::ConstString> &mangled_names) {}
1375
AddSymbols(lldb_private::Symtab & symtab)1376 void SymbolFilePDB::AddSymbols(lldb_private::Symtab &symtab) {
1377 std::set<lldb::addr_t> sym_addresses;
1378 for (size_t i = 0; i < symtab.GetNumSymbols(); i++)
1379 sym_addresses.insert(symtab.SymbolAtIndex(i)->GetFileAddress());
1380
1381 auto results = m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>();
1382 if (!results)
1383 return;
1384
1385 auto section_list = m_objfile_sp->GetSectionList();
1386 if (!section_list)
1387 return;
1388
1389 while (auto pub_symbol = results->getNext()) {
1390 auto section_id = pub_symbol->getAddressSection();
1391
1392 auto section = section_list->FindSectionByID(section_id);
1393 if (!section)
1394 continue;
1395
1396 auto offset = pub_symbol->getAddressOffset();
1397
1398 auto file_addr = section->GetFileAddress() + offset;
1399 if (sym_addresses.find(file_addr) != sym_addresses.end())
1400 continue;
1401 sym_addresses.insert(file_addr);
1402
1403 auto size = pub_symbol->getLength();
1404 symtab.AddSymbol(
1405 Symbol(pub_symbol->getSymIndexId(), // symID
1406 pub_symbol->getName().c_str(), // name
1407 pub_symbol->isCode() ? eSymbolTypeCode : eSymbolTypeData, // type
1408 true, // external
1409 false, // is_debug
1410 false, // is_trampoline
1411 false, // is_artificial
1412 section, // section_sp
1413 offset, // value
1414 size, // size
1415 size != 0, // size_is_valid
1416 false, // contains_linker_annotations
1417 0 // flags
1418 ));
1419 }
1420
1421 symtab.CalculateSymbolSizes();
1422 symtab.Finalize();
1423 }
1424
FindTypes(lldb_private::ConstString name,const CompilerDeclContext & parent_decl_ctx,uint32_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,lldb_private::TypeMap & types)1425 void SymbolFilePDB::FindTypes(
1426 lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
1427 uint32_t max_matches,
1428 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1429 lldb_private::TypeMap &types) {
1430 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1431 if (!name)
1432 return;
1433 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
1434 return;
1435
1436 searched_symbol_files.clear();
1437 searched_symbol_files.insert(this);
1438
1439 // There is an assumption 'name' is not a regex
1440 FindTypesByName(name.GetStringRef(), parent_decl_ctx, max_matches, types);
1441 }
1442
DumpClangAST(Stream & s)1443 void SymbolFilePDB::DumpClangAST(Stream &s) {
1444 auto type_system_or_err =
1445 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1446 if (auto err = type_system_or_err.takeError()) {
1447 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1448 std::move(err), "Unable to dump ClangAST");
1449 return;
1450 }
1451
1452 auto *clang_type_system =
1453 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
1454 if (!clang_type_system)
1455 return;
1456 clang_type_system->Dump(s);
1457 }
1458
FindTypesByRegex(const lldb_private::RegularExpression & regex,uint32_t max_matches,lldb_private::TypeMap & types)1459 void SymbolFilePDB::FindTypesByRegex(
1460 const lldb_private::RegularExpression ®ex, uint32_t max_matches,
1461 lldb_private::TypeMap &types) {
1462 // When searching by regex, we need to go out of our way to limit the search
1463 // space as much as possible since this searches EVERYTHING in the PDB,
1464 // manually doing regex comparisons. PDB library isn't optimized for regex
1465 // searches or searches across multiple symbol types at the same time, so the
1466 // best we can do is to search enums, then typedefs, then classes one by one,
1467 // and do a regex comparison against each of them.
1468 PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
1469 PDB_SymType::UDT};
1470 std::unique_ptr<IPDBEnumSymbols> results;
1471
1472 uint32_t matches = 0;
1473
1474 for (auto tag : tags_to_search) {
1475 results = m_global_scope_up->findAllChildren(tag);
1476 if (!results)
1477 continue;
1478
1479 while (auto result = results->getNext()) {
1480 if (max_matches > 0 && matches >= max_matches)
1481 break;
1482
1483 std::string type_name;
1484 if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
1485 type_name = enum_type->getName();
1486 else if (auto typedef_type =
1487 llvm::dyn_cast<PDBSymbolTypeTypedef>(result.get()))
1488 type_name = typedef_type->getName();
1489 else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
1490 type_name = class_type->getName();
1491 else {
1492 // We're looking only for types that have names. Skip symbols, as well
1493 // as unnamed types such as arrays, pointers, etc.
1494 continue;
1495 }
1496
1497 if (!regex.Execute(type_name))
1498 continue;
1499
1500 // This should cause the type to get cached and stored in the `m_types`
1501 // lookup.
1502 if (!ResolveTypeUID(result->getSymIndexId()))
1503 continue;
1504
1505 auto iter = m_types.find(result->getSymIndexId());
1506 if (iter == m_types.end())
1507 continue;
1508 types.Insert(iter->second);
1509 ++matches;
1510 }
1511 }
1512 }
1513
FindTypesByName(llvm::StringRef name,const lldb_private::CompilerDeclContext & parent_decl_ctx,uint32_t max_matches,lldb_private::TypeMap & types)1514 void SymbolFilePDB::FindTypesByName(
1515 llvm::StringRef name,
1516 const lldb_private::CompilerDeclContext &parent_decl_ctx,
1517 uint32_t max_matches, lldb_private::TypeMap &types) {
1518 std::unique_ptr<IPDBEnumSymbols> results;
1519 if (name.empty())
1520 return;
1521 results = m_global_scope_up->findAllChildren(PDB_SymType::None);
1522 if (!results)
1523 return;
1524
1525 uint32_t matches = 0;
1526
1527 while (auto result = results->getNext()) {
1528 if (max_matches > 0 && matches >= max_matches)
1529 break;
1530
1531 if (MSVCUndecoratedNameParser::DropScope(
1532 result->getRawSymbol().getName()) != name)
1533 continue;
1534
1535 switch (result->getSymTag()) {
1536 case PDB_SymType::Enum:
1537 case PDB_SymType::UDT:
1538 case PDB_SymType::Typedef:
1539 break;
1540 default:
1541 // We're looking only for types that have names. Skip symbols, as well
1542 // as unnamed types such as arrays, pointers, etc.
1543 continue;
1544 }
1545
1546 // This should cause the type to get cached and stored in the `m_types`
1547 // lookup.
1548 if (!ResolveTypeUID(result->getSymIndexId()))
1549 continue;
1550
1551 if (parent_decl_ctx.IsValid() &&
1552 GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
1553 continue;
1554
1555 auto iter = m_types.find(result->getSymIndexId());
1556 if (iter == m_types.end())
1557 continue;
1558 types.Insert(iter->second);
1559 ++matches;
1560 }
1561 }
1562
FindTypes(llvm::ArrayRef<CompilerContext> pattern,LanguageSet languages,llvm::DenseSet<SymbolFile * > & searched_symbol_files,lldb_private::TypeMap & types)1563 void SymbolFilePDB::FindTypes(
1564 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
1565 llvm::DenseSet<SymbolFile *> &searched_symbol_files,
1566 lldb_private::TypeMap &types) {}
1567
GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol & pdb_symbol,uint32_t type_mask,TypeCollection & type_collection)1568 void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
1569 uint32_t type_mask,
1570 TypeCollection &type_collection) {
1571 bool can_parse = false;
1572 switch (pdb_symbol.getSymTag()) {
1573 case PDB_SymType::ArrayType:
1574 can_parse = ((type_mask & eTypeClassArray) != 0);
1575 break;
1576 case PDB_SymType::BuiltinType:
1577 can_parse = ((type_mask & eTypeClassBuiltin) != 0);
1578 break;
1579 case PDB_SymType::Enum:
1580 can_parse = ((type_mask & eTypeClassEnumeration) != 0);
1581 break;
1582 case PDB_SymType::Function:
1583 case PDB_SymType::FunctionSig:
1584 can_parse = ((type_mask & eTypeClassFunction) != 0);
1585 break;
1586 case PDB_SymType::PointerType:
1587 can_parse = ((type_mask & (eTypeClassPointer | eTypeClassBlockPointer |
1588 eTypeClassMemberPointer)) != 0);
1589 break;
1590 case PDB_SymType::Typedef:
1591 can_parse = ((type_mask & eTypeClassTypedef) != 0);
1592 break;
1593 case PDB_SymType::UDT: {
1594 auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&pdb_symbol);
1595 assert(udt);
1596 can_parse = (udt->getUdtKind() != PDB_UdtType::Interface &&
1597 ((type_mask & (eTypeClassClass | eTypeClassStruct |
1598 eTypeClassUnion)) != 0));
1599 } break;
1600 default:
1601 break;
1602 }
1603
1604 if (can_parse) {
1605 if (auto *type = ResolveTypeUID(pdb_symbol.getSymIndexId())) {
1606 auto result =
1607 std::find(type_collection.begin(), type_collection.end(), type);
1608 if (result == type_collection.end())
1609 type_collection.push_back(type);
1610 }
1611 }
1612
1613 auto results_up = pdb_symbol.findAllChildren();
1614 while (auto symbol_up = results_up->getNext())
1615 GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
1616 }
1617
GetTypes(lldb_private::SymbolContextScope * sc_scope,TypeClass type_mask,lldb_private::TypeList & type_list)1618 void SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
1619 TypeClass type_mask,
1620 lldb_private::TypeList &type_list) {
1621 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1622 TypeCollection type_collection;
1623 CompileUnit *cu =
1624 sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
1625 if (cu) {
1626 auto compiland_up = GetPDBCompilandByUID(cu->GetID());
1627 if (!compiland_up)
1628 return;
1629 GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
1630 } else {
1631 for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
1632 auto cu_sp = ParseCompileUnitAtIndex(cu_idx);
1633 if (cu_sp) {
1634 if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
1635 GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
1636 }
1637 }
1638 }
1639
1640 for (auto type : type_collection) {
1641 type->GetForwardCompilerType();
1642 type_list.Insert(type->shared_from_this());
1643 }
1644 }
1645
1646 llvm::Expected<lldb_private::TypeSystem &>
GetTypeSystemForLanguage(lldb::LanguageType language)1647 SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
1648 auto type_system_or_err =
1649 m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
1650 if (type_system_or_err) {
1651 type_system_or_err->SetSymbolFile(this);
1652 }
1653 return type_system_or_err;
1654 }
1655
GetPDBAstParser()1656 PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
1657 auto type_system_or_err =
1658 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1659 if (auto err = type_system_or_err.takeError()) {
1660 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1661 std::move(err), "Unable to get PDB AST parser");
1662 return nullptr;
1663 }
1664
1665 auto *clang_type_system =
1666 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
1667 if (!clang_type_system)
1668 return nullptr;
1669
1670 return clang_type_system->GetPDBParser();
1671 }
1672
1673 lldb_private::CompilerDeclContext
FindNamespace(lldb_private::ConstString name,const CompilerDeclContext & parent_decl_ctx)1674 SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
1675 const CompilerDeclContext &parent_decl_ctx) {
1676 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1677 auto type_system_or_err =
1678 GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
1679 if (auto err = type_system_or_err.takeError()) {
1680 LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1681 std::move(err), "Unable to find namespace {}",
1682 name.AsCString());
1683 return CompilerDeclContext();
1684 }
1685
1686 auto *clang_type_system =
1687 llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
1688 if (!clang_type_system)
1689 return CompilerDeclContext();
1690
1691 PDBASTParser *pdb = clang_type_system->GetPDBParser();
1692 if (!pdb)
1693 return CompilerDeclContext();
1694
1695 clang::DeclContext *decl_context = nullptr;
1696 if (parent_decl_ctx)
1697 decl_context = static_cast<clang::DeclContext *>(
1698 parent_decl_ctx.GetOpaqueDeclContext());
1699
1700 auto namespace_decl =
1701 pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
1702 if (!namespace_decl)
1703 return CompilerDeclContext();
1704
1705 return clang_type_system->CreateDeclContext(namespace_decl);
1706 }
1707
GetPluginName()1708 lldb_private::ConstString SymbolFilePDB::GetPluginName() {
1709 static ConstString g_name("pdb");
1710 return g_name;
1711 }
1712
GetPluginVersion()1713 uint32_t SymbolFilePDB::GetPluginVersion() { return 1; }
1714
GetPDBSession()1715 IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }
1716
GetPDBSession() const1717 const IPDBSession &SymbolFilePDB::GetPDBSession() const {
1718 return *m_session_up;
1719 }
1720
ParseCompileUnitForUID(uint32_t id,uint32_t index)1721 lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
1722 uint32_t index) {
1723 auto found_cu = m_comp_units.find(id);
1724 if (found_cu != m_comp_units.end())
1725 return found_cu->second;
1726
1727 auto compiland_up = GetPDBCompilandByUID(id);
1728 if (!compiland_up)
1729 return CompUnitSP();
1730
1731 lldb::LanguageType lang;
1732 auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
1733 if (!details)
1734 lang = lldb::eLanguageTypeC_plus_plus;
1735 else
1736 lang = TranslateLanguage(details->getLanguage());
1737
1738 if (lang == lldb::LanguageType::eLanguageTypeUnknown)
1739 return CompUnitSP();
1740
1741 std::string path = compiland_up->getSourceFileFullPath();
1742 if (path.empty())
1743 return CompUnitSP();
1744
1745 // Don't support optimized code for now, DebugInfoPDB does not return this
1746 // information.
1747 LazyBool optimized = eLazyBoolNo;
1748 auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
1749 path.c_str(), id, lang, optimized);
1750
1751 if (!cu_sp)
1752 return CompUnitSP();
1753
1754 m_comp_units.insert(std::make_pair(id, cu_sp));
1755 if (index == UINT32_MAX)
1756 GetCompileUnitIndex(*compiland_up, index);
1757 lldbassert(index != UINT32_MAX);
1758 SetCompileUnitAtIndex(index, cu_sp);
1759 return cu_sp;
1760 }
1761
ParseCompileUnitLineTable(CompileUnit & comp_unit,uint32_t match_line)1762 bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
1763 uint32_t match_line) {
1764 auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
1765 if (!compiland_up)
1766 return false;
1767
1768 // LineEntry needs the *index* of the file into the list of support files
1769 // returned by ParseCompileUnitSupportFiles. But the underlying SDK gives us
1770 // a globally unique idenfitifier in the namespace of the PDB. So, we have
1771 // to do a mapping so that we can hand out indices.
1772 llvm::DenseMap<uint32_t, uint32_t> index_map;
1773 BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
1774 auto line_table = std::make_unique<LineTable>(&comp_unit);
1775
1776 // Find contributions to `compiland` from all source and header files.
1777 auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
1778 if (!files)
1779 return false;
1780
1781 // For each source and header file, create a LineSequence for contributions
1782 // to the compiland from that file, and add the sequence.
1783 while (auto file = files->getNext()) {
1784 std::unique_ptr<LineSequence> sequence(
1785 line_table->CreateLineSequenceContainer());
1786 auto lines = m_session_up->findLineNumbers(*compiland_up, *file);
1787 if (!lines)
1788 continue;
1789 int entry_count = lines->getChildCount();
1790
1791 uint64_t prev_addr;
1792 uint32_t prev_length;
1793 uint32_t prev_line;
1794 uint32_t prev_source_idx;
1795
1796 for (int i = 0; i < entry_count; ++i) {
1797 auto line = lines->getChildAtIndex(i);
1798
1799 uint64_t lno = line->getLineNumber();
1800 uint64_t addr = line->getVirtualAddress();
1801 uint32_t length = line->getLength();
1802 uint32_t source_id = line->getSourceFileId();
1803 uint32_t col = line->getColumnNumber();
1804 uint32_t source_idx = index_map[source_id];
1805
1806 // There was a gap between the current entry and the previous entry if
1807 // the addresses don't perfectly line up.
1808 bool is_gap = (i > 0) && (prev_addr + prev_length < addr);
1809
1810 // Before inserting the current entry, insert a terminal entry at the end
1811 // of the previous entry's address range if the current entry resulted in
1812 // a gap from the previous entry.
1813 if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) {
1814 line_table->AppendLineEntryToSequence(
1815 sequence.get(), prev_addr + prev_length, prev_line, 0,
1816 prev_source_idx, false, false, false, false, true);
1817
1818 line_table->InsertSequence(sequence.release());
1819 sequence = line_table->CreateLineSequenceContainer();
1820 }
1821
1822 if (ShouldAddLine(match_line, lno, length)) {
1823 bool is_statement = line->isStatement();
1824 bool is_prologue = false;
1825 bool is_epilogue = false;
1826 auto func =
1827 m_session_up->findSymbolByAddress(addr, PDB_SymType::Function);
1828 if (func) {
1829 auto prologue = func->findOneChild<PDBSymbolFuncDebugStart>();
1830 if (prologue)
1831 is_prologue = (addr == prologue->getVirtualAddress());
1832
1833 auto epilogue = func->findOneChild<PDBSymbolFuncDebugEnd>();
1834 if (epilogue)
1835 is_epilogue = (addr == epilogue->getVirtualAddress());
1836 }
1837
1838 line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
1839 source_idx, is_statement, false,
1840 is_prologue, is_epilogue, false);
1841 }
1842
1843 prev_addr = addr;
1844 prev_length = length;
1845 prev_line = lno;
1846 prev_source_idx = source_idx;
1847 }
1848
1849 if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
1850 // The end is always a terminal entry, so insert it regardless.
1851 line_table->AppendLineEntryToSequence(
1852 sequence.get(), prev_addr + prev_length, prev_line, 0,
1853 prev_source_idx, false, false, false, false, true);
1854 }
1855
1856 line_table->InsertSequence(sequence.get());
1857 }
1858
1859 if (line_table->GetSize()) {
1860 comp_unit.SetLineTable(line_table.release());
1861 return true;
1862 }
1863 return false;
1864 }
1865
BuildSupportFileIdToSupportFileIndexMap(const PDBSymbolCompiland & compiland,llvm::DenseMap<uint32_t,uint32_t> & index_map) const1866 void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
1867 const PDBSymbolCompiland &compiland,
1868 llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
1869 // This is a hack, but we need to convert the source id into an index into
1870 // the support files array. We don't want to do path comparisons to avoid
1871 // basename / full path issues that may or may not even be a problem, so we
1872 // use the globally unique source file identifiers. Ideally we could use the
1873 // global identifiers everywhere, but LineEntry currently assumes indices.
1874 auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
1875 if (!source_files)
1876 return;
1877
1878 int index = 0;
1879 while (auto file = source_files->getNext()) {
1880 uint32_t source_id = file->getUniqueId();
1881 index_map[source_id] = index++;
1882 }
1883 }
1884
GetCompileUnitContainsAddress(const lldb_private::Address & so_addr)1885 lldb::CompUnitSP SymbolFilePDB::GetCompileUnitContainsAddress(
1886 const lldb_private::Address &so_addr) {
1887 lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1888 if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
1889 return nullptr;
1890
1891 // If it is a PDB function's vm addr, this is the first sure bet.
1892 if (auto lines =
1893 m_session_up->findLineNumbersByAddress(file_vm_addr, /*Length=*/1)) {
1894 if (auto first_line = lines->getNext())
1895 return ParseCompileUnitForUID(first_line->getCompilandId());
1896 }
1897
1898 // Otherwise we resort to section contributions.
1899 if (auto sec_contribs = m_session_up->getSectionContribs()) {
1900 while (auto section = sec_contribs->getNext()) {
1901 auto va = section->getVirtualAddress();
1902 if (file_vm_addr >= va && file_vm_addr < va + section->getLength())
1903 return ParseCompileUnitForUID(section->getCompilandId());
1904 }
1905 }
1906 return nullptr;
1907 }
1908
1909 Mangled
GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc & pdb_func)1910 SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
1911 Mangled mangled;
1912 auto func_name = pdb_func.getName();
1913 auto func_undecorated_name = pdb_func.getUndecoratedName();
1914 std::string func_decorated_name;
1915
1916 // Seek from public symbols for non-static function's decorated name if any.
1917 // For static functions, they don't have undecorated names and aren't exposed
1918 // in Public Symbols either.
1919 if (!func_undecorated_name.empty()) {
1920 auto result_up = m_global_scope_up->findChildren(
1921 PDB_SymType::PublicSymbol, func_undecorated_name,
1922 PDB_NameSearchFlags::NS_UndecoratedName);
1923 if (result_up) {
1924 while (auto symbol_up = result_up->getNext()) {
1925 // For a public symbol, it is unique.
1926 lldbassert(result_up->getChildCount() == 1);
1927 if (auto *pdb_public_sym =
1928 llvm::dyn_cast_or_null<PDBSymbolPublicSymbol>(
1929 symbol_up.get())) {
1930 if (pdb_public_sym->isFunction()) {
1931 func_decorated_name = pdb_public_sym->getName();
1932 break;
1933 }
1934 }
1935 }
1936 }
1937 }
1938 if (!func_decorated_name.empty()) {
1939 mangled.SetMangledName(ConstString(func_decorated_name));
1940
1941 // For MSVC, format of C funciton's decorated name depends on calling
1942 // convention. Unfortunately none of the format is recognized by current
1943 // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
1944 // `__purecall` is retrieved as both its decorated and undecorated name
1945 // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
1946 // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
1947 // Mangled::GetDemangledName method will fail internally and caches an
1948 // empty string as its undecorated name. So we will face a contradiction
1949 // here for the same symbol:
1950 // non-empty undecorated name from PDB
1951 // empty undecorated name from LLDB
1952 if (!func_undecorated_name.empty() && mangled.GetDemangledName().IsEmpty())
1953 mangled.SetDemangledName(ConstString(func_undecorated_name));
1954
1955 // LLDB uses several flags to control how a C++ decorated name is
1956 // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So the
1957 // yielded name could be different from what we retrieve from
1958 // PDB source unless we also apply same flags in getting undecorated
1959 // name through PDBSymbolFunc::getUndecoratedNameEx method.
1960 if (!func_undecorated_name.empty() &&
1961 mangled.GetDemangledName() != ConstString(func_undecorated_name))
1962 mangled.SetDemangledName(ConstString(func_undecorated_name));
1963 } else if (!func_undecorated_name.empty()) {
1964 mangled.SetDemangledName(ConstString(func_undecorated_name));
1965 } else if (!func_name.empty())
1966 mangled.SetValue(ConstString(func_name), false);
1967
1968 return mangled;
1969 }
1970
DeclContextMatchesThisSymbolFile(const lldb_private::CompilerDeclContext & decl_ctx)1971 bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
1972 const lldb_private::CompilerDeclContext &decl_ctx) {
1973 if (!decl_ctx.IsValid())
1974 return true;
1975
1976 TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
1977 if (!decl_ctx_type_system)
1978 return false;
1979 auto type_system_or_err = GetTypeSystemForLanguage(
1980 decl_ctx_type_system->GetMinimumLanguage(nullptr));
1981 if (auto err = type_system_or_err.takeError()) {
1982 LLDB_LOG_ERROR(
1983 lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
1984 std::move(err),
1985 "Unable to determine if DeclContext matches this symbol file");
1986 return false;
1987 }
1988
1989 if (decl_ctx_type_system == &type_system_or_err.get())
1990 return true; // The type systems match, return true
1991
1992 return false;
1993 }
1994
GetCompilandId(const llvm::pdb::PDBSymbolData & data)1995 uint32_t SymbolFilePDB::GetCompilandId(const llvm::pdb::PDBSymbolData &data) {
1996 static const auto pred_upper = [](uint32_t lhs, SecContribInfo rhs) {
1997 return lhs < rhs.Offset;
1998 };
1999
2000 // Cache section contributions
2001 if (m_sec_contribs.empty()) {
2002 if (auto SecContribs = m_session_up->getSectionContribs()) {
2003 while (auto SectionContrib = SecContribs->getNext()) {
2004 auto comp_id = SectionContrib->getCompilandId();
2005 if (!comp_id)
2006 continue;
2007
2008 auto sec = SectionContrib->getAddressSection();
2009 auto &sec_cs = m_sec_contribs[sec];
2010
2011 auto offset = SectionContrib->getAddressOffset();
2012 auto it =
2013 std::upper_bound(sec_cs.begin(), sec_cs.end(), offset, pred_upper);
2014
2015 auto size = SectionContrib->getLength();
2016 sec_cs.insert(it, {offset, size, comp_id});
2017 }
2018 }
2019 }
2020
2021 // Check by line number
2022 if (auto Lines = data.getLineNumbers()) {
2023 if (auto FirstLine = Lines->getNext())
2024 return FirstLine->getCompilandId();
2025 }
2026
2027 // Retrieve section + offset
2028 uint32_t DataSection = data.getAddressSection();
2029 uint32_t DataOffset = data.getAddressOffset();
2030 if (DataSection == 0) {
2031 if (auto RVA = data.getRelativeVirtualAddress())
2032 m_session_up->addressForRVA(RVA, DataSection, DataOffset);
2033 }
2034
2035 if (DataSection) {
2036 // Search by section contributions
2037 auto &sec_cs = m_sec_contribs[DataSection];
2038 auto it =
2039 std::upper_bound(sec_cs.begin(), sec_cs.end(), DataOffset, pred_upper);
2040 if (it != sec_cs.begin()) {
2041 --it;
2042 if (DataOffset < it->Offset + it->Size)
2043 return it->CompilandId;
2044 }
2045 } else {
2046 // Search in lexical tree
2047 auto LexParentId = data.getLexicalParentId();
2048 while (auto LexParent = m_session_up->getSymbolById(LexParentId)) {
2049 if (LexParent->getSymTag() == PDB_SymType::Exe)
2050 break;
2051 if (LexParent->getSymTag() == PDB_SymType::Compiland)
2052 return LexParentId;
2053 LexParentId = LexParent->getRawSymbol().getLexicalParentId();
2054 }
2055 }
2056
2057 return 0;
2058 }
2059