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