xref: /freebsd-src/contrib/llvm-project/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583)
15ffd83dbSDimitry Andric //===-- SymbolFilePDB.cpp -------------------------------------------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric 
90b57cec5SDimitry Andric #include "SymbolFilePDB.h"
100b57cec5SDimitry Andric 
110b57cec5SDimitry Andric #include "PDBASTParser.h"
120b57cec5SDimitry Andric #include "PDBLocationToDWARFExpression.h"
130b57cec5SDimitry Andric 
140b57cec5SDimitry Andric #include "clang/Lex/Lexer.h"
150b57cec5SDimitry Andric 
165ffd83dbSDimitry Andric #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
170b57cec5SDimitry Andric #include "lldb/Core/Module.h"
180b57cec5SDimitry Andric #include "lldb/Core/PluginManager.h"
190b57cec5SDimitry Andric #include "lldb/Symbol/CompileUnit.h"
200b57cec5SDimitry Andric #include "lldb/Symbol/LineTable.h"
210b57cec5SDimitry Andric #include "lldb/Symbol/ObjectFile.h"
220b57cec5SDimitry Andric #include "lldb/Symbol/SymbolContext.h"
230b57cec5SDimitry Andric #include "lldb/Symbol/SymbolVendor.h"
240b57cec5SDimitry Andric #include "lldb/Symbol/TypeList.h"
250b57cec5SDimitry Andric #include "lldb/Symbol/TypeMap.h"
260b57cec5SDimitry Andric #include "lldb/Symbol/Variable.h"
2781ad6265SDimitry Andric #include "lldb/Utility/LLDBLog.h"
289dba64beSDimitry Andric #include "lldb/Utility/Log.h"
290b57cec5SDimitry Andric #include "lldb/Utility/RegularExpression.h"
300b57cec5SDimitry Andric 
3181ad6265SDimitry Andric #include "llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h"
320b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/GenericError.h"
330b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
340b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
350b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
360b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
370b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
380b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/IPDBTable.h"
390b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbol.h"
400b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
410b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
420b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
430b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
440b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
450b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
460b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
470b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
480b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
4981ad6265SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
500b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
5181ad6265SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
520b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
530b57cec5SDimitry Andric #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
540b57cec5SDimitry Andric 
550b57cec5SDimitry Andric #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
560b57cec5SDimitry Andric #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
570b57cec5SDimitry Andric #include "Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h"
580b57cec5SDimitry Andric 
59349cc55cSDimitry Andric #if defined(_WIN32)
6081ad6265SDimitry Andric #include "llvm/Config/llvm-config.h"
61bdd1243dSDimitry Andric #include <optional>
62349cc55cSDimitry Andric #endif
63349cc55cSDimitry Andric 
640b57cec5SDimitry Andric using namespace lldb;
650b57cec5SDimitry Andric using namespace lldb_private;
660b57cec5SDimitry Andric using namespace llvm::pdb;
670b57cec5SDimitry Andric 
685ffd83dbSDimitry Andric LLDB_PLUGIN_DEFINE(SymbolFilePDB)
695ffd83dbSDimitry Andric 
70480093f4SDimitry Andric char SymbolFilePDB::ID;
71480093f4SDimitry Andric 
720b57cec5SDimitry Andric namespace {
730b57cec5SDimitry Andric lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
740b57cec5SDimitry Andric   switch (lang) {
750b57cec5SDimitry Andric   case PDB_Lang::Cpp:
760b57cec5SDimitry Andric     return lldb::LanguageType::eLanguageTypeC_plus_plus;
770b57cec5SDimitry Andric   case PDB_Lang::C:
780b57cec5SDimitry Andric     return lldb::LanguageType::eLanguageTypeC;
790b57cec5SDimitry Andric   case PDB_Lang::Swift:
800b57cec5SDimitry Andric     return lldb::LanguageType::eLanguageTypeSwift;
8181ad6265SDimitry Andric   case PDB_Lang::Rust:
8281ad6265SDimitry Andric     return lldb::LanguageType::eLanguageTypeRust;
8306c3fb27SDimitry Andric   case PDB_Lang::ObjC:
8406c3fb27SDimitry Andric     return lldb::LanguageType::eLanguageTypeObjC;
8506c3fb27SDimitry Andric   case PDB_Lang::ObjCpp:
8606c3fb27SDimitry Andric     return lldb::LanguageType::eLanguageTypeObjC_plus_plus;
870b57cec5SDimitry Andric   default:
880b57cec5SDimitry Andric     return lldb::LanguageType::eLanguageTypeUnknown;
890b57cec5SDimitry Andric   }
900b57cec5SDimitry Andric }
910b57cec5SDimitry Andric 
920b57cec5SDimitry Andric bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
930b57cec5SDimitry Andric                    uint32_t addr_length) {
940b57cec5SDimitry Andric   return ((requested_line == 0 || actual_line == requested_line) &&
950b57cec5SDimitry Andric           addr_length > 0);
960b57cec5SDimitry Andric }
970b57cec5SDimitry Andric } // namespace
980b57cec5SDimitry Andric 
990b57cec5SDimitry Andric static bool ShouldUseNativeReader() {
1000b57cec5SDimitry Andric #if defined(_WIN32)
101349cc55cSDimitry Andric #if LLVM_ENABLE_DIA_SDK
1020b57cec5SDimitry Andric   llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
103349cc55cSDimitry Andric   if (!use_native.equals_insensitive("on") &&
104349cc55cSDimitry Andric       !use_native.equals_insensitive("yes") &&
105349cc55cSDimitry Andric       !use_native.equals_insensitive("1") &&
106349cc55cSDimitry Andric       !use_native.equals_insensitive("true"))
107349cc55cSDimitry Andric     return false;
1080b57cec5SDimitry Andric #endif
109349cc55cSDimitry Andric #endif
110349cc55cSDimitry Andric   return true;
1110b57cec5SDimitry Andric }
1120b57cec5SDimitry Andric 
1130b57cec5SDimitry Andric void SymbolFilePDB::Initialize() {
1140b57cec5SDimitry Andric   if (ShouldUseNativeReader()) {
1150b57cec5SDimitry Andric     npdb::SymbolFileNativePDB::Initialize();
1160b57cec5SDimitry Andric   } else {
1170b57cec5SDimitry Andric     PluginManager::RegisterPlugin(GetPluginNameStatic(),
1180b57cec5SDimitry Andric                                   GetPluginDescriptionStatic(), CreateInstance,
1190b57cec5SDimitry Andric                                   DebuggerInitialize);
1200b57cec5SDimitry Andric   }
1210b57cec5SDimitry Andric }
1220b57cec5SDimitry Andric 
1230b57cec5SDimitry Andric void SymbolFilePDB::Terminate() {
1240b57cec5SDimitry Andric   if (ShouldUseNativeReader()) {
1250b57cec5SDimitry Andric     npdb::SymbolFileNativePDB::Terminate();
1260b57cec5SDimitry Andric   } else {
1270b57cec5SDimitry Andric     PluginManager::UnregisterPlugin(CreateInstance);
1280b57cec5SDimitry Andric   }
1290b57cec5SDimitry Andric }
1300b57cec5SDimitry Andric 
1310b57cec5SDimitry Andric void SymbolFilePDB::DebuggerInitialize(lldb_private::Debugger &debugger) {}
1320b57cec5SDimitry Andric 
133349cc55cSDimitry Andric llvm::StringRef SymbolFilePDB::GetPluginDescriptionStatic() {
1340b57cec5SDimitry Andric   return "Microsoft PDB debug symbol file reader.";
1350b57cec5SDimitry Andric }
1360b57cec5SDimitry Andric 
1370b57cec5SDimitry Andric lldb_private::SymbolFile *
1389dba64beSDimitry Andric SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
1399dba64beSDimitry Andric   return new SymbolFilePDB(std::move(objfile_sp));
1400b57cec5SDimitry Andric }
1410b57cec5SDimitry Andric 
1429dba64beSDimitry Andric SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
14381ad6265SDimitry Andric     : SymbolFileCommon(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
1440b57cec5SDimitry Andric 
145fe6060f1SDimitry Andric SymbolFilePDB::~SymbolFilePDB() = default;
1460b57cec5SDimitry Andric 
1470b57cec5SDimitry Andric uint32_t SymbolFilePDB::CalculateAbilities() {
1480b57cec5SDimitry Andric   uint32_t abilities = 0;
1499dba64beSDimitry Andric   if (!m_objfile_sp)
1500b57cec5SDimitry Andric     return 0;
1510b57cec5SDimitry Andric 
1520b57cec5SDimitry Andric   if (!m_session_up) {
1530b57cec5SDimitry Andric     // Lazily load and match the PDB file, but only do this once.
1549dba64beSDimitry Andric     std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
1550b57cec5SDimitry Andric     auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath),
1560b57cec5SDimitry Andric                                 m_session_up);
1570b57cec5SDimitry Andric     if (error) {
1580b57cec5SDimitry Andric       llvm::consumeError(std::move(error));
1599dba64beSDimitry Andric       auto module_sp = m_objfile_sp->GetModule();
1600b57cec5SDimitry Andric       if (!module_sp)
1610b57cec5SDimitry Andric         return 0;
1620b57cec5SDimitry Andric       // See if any symbol file is specified through `--symfile` option.
1630b57cec5SDimitry Andric       FileSpec symfile = module_sp->GetSymbolFileFileSpec();
1640b57cec5SDimitry Andric       if (!symfile)
1650b57cec5SDimitry Andric         return 0;
1660b57cec5SDimitry Andric       error = loadDataForPDB(PDB_ReaderType::DIA,
1670b57cec5SDimitry Andric                              llvm::StringRef(symfile.GetPath()), m_session_up);
1680b57cec5SDimitry Andric       if (error) {
1690b57cec5SDimitry Andric         llvm::consumeError(std::move(error));
1700b57cec5SDimitry Andric         return 0;
1710b57cec5SDimitry Andric       }
1720b57cec5SDimitry Andric     }
1730b57cec5SDimitry Andric   }
1740b57cec5SDimitry Andric   if (!m_session_up)
1750b57cec5SDimitry Andric     return 0;
1760b57cec5SDimitry Andric 
1770b57cec5SDimitry Andric   auto enum_tables_up = m_session_up->getEnumTables();
1780b57cec5SDimitry Andric   if (!enum_tables_up)
1790b57cec5SDimitry Andric     return 0;
1800b57cec5SDimitry Andric   while (auto table_up = enum_tables_up->getNext()) {
1810b57cec5SDimitry Andric     if (table_up->getItemCount() == 0)
1820b57cec5SDimitry Andric       continue;
1830b57cec5SDimitry Andric     auto type = table_up->getTableType();
1840b57cec5SDimitry Andric     switch (type) {
1850b57cec5SDimitry Andric     case PDB_TableType::Symbols:
1860b57cec5SDimitry Andric       // This table represents a store of symbols with types listed in
1870b57cec5SDimitry Andric       // PDBSym_Type
1880b57cec5SDimitry Andric       abilities |= (CompileUnits | Functions | Blocks | GlobalVariables |
1890b57cec5SDimitry Andric                     LocalVariables | VariableTypes);
1900b57cec5SDimitry Andric       break;
1910b57cec5SDimitry Andric     case PDB_TableType::LineNumbers:
1920b57cec5SDimitry Andric       abilities |= LineTables;
1930b57cec5SDimitry Andric       break;
1940b57cec5SDimitry Andric     default:
1950b57cec5SDimitry Andric       break;
1960b57cec5SDimitry Andric     }
1970b57cec5SDimitry Andric   }
1980b57cec5SDimitry Andric   return abilities;
1990b57cec5SDimitry Andric }
2000b57cec5SDimitry Andric 
2010b57cec5SDimitry Andric void SymbolFilePDB::InitializeObject() {
2029dba64beSDimitry Andric   lldb::addr_t obj_load_address =
2039dba64beSDimitry Andric       m_objfile_sp->GetBaseAddress().GetFileAddress();
2040b57cec5SDimitry Andric   lldbassert(obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS);
2050b57cec5SDimitry Andric   m_session_up->setLoadAddress(obj_load_address);
2060b57cec5SDimitry Andric   if (!m_global_scope_up)
2070b57cec5SDimitry Andric     m_global_scope_up = m_session_up->getGlobalScope();
2080b57cec5SDimitry Andric   lldbassert(m_global_scope_up.get());
2090b57cec5SDimitry Andric }
2100b57cec5SDimitry Andric 
2119dba64beSDimitry Andric uint32_t SymbolFilePDB::CalculateNumCompileUnits() {
2120b57cec5SDimitry Andric   auto compilands = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
2130b57cec5SDimitry Andric   if (!compilands)
2140b57cec5SDimitry Andric     return 0;
2150b57cec5SDimitry Andric 
2160b57cec5SDimitry Andric   // The linker could link *.dll (compiland language = LINK), or import
2170b57cec5SDimitry Andric   // *.dll. For example, a compiland with name `Import:KERNEL32.dll` could be
2180b57cec5SDimitry Andric   // found as a child of the global scope (PDB executable). Usually, such
2190b57cec5SDimitry Andric   // compilands contain `thunk` symbols in which we are not interested for
2200b57cec5SDimitry Andric   // now. However we still count them in the compiland list. If we perform
2210b57cec5SDimitry Andric   // any compiland related activity, like finding symbols through
2220b57cec5SDimitry Andric   // llvm::pdb::IPDBSession methods, such compilands will all be searched
2230b57cec5SDimitry Andric   // automatically no matter whether we include them or not.
2249dba64beSDimitry Andric   uint32_t compile_unit_count = compilands->getChildCount();
2250b57cec5SDimitry Andric 
2260b57cec5SDimitry Andric   // The linker can inject an additional "dummy" compilation unit into the
2270b57cec5SDimitry Andric   // PDB. Ignore this special compile unit for our purposes, if it is there.
2280b57cec5SDimitry Andric   // It is always the last one.
2299dba64beSDimitry Andric   auto last_compiland_up = compilands->getChildAtIndex(compile_unit_count - 1);
2300b57cec5SDimitry Andric   lldbassert(last_compiland_up.get());
2310b57cec5SDimitry Andric   std::string name = last_compiland_up->getName();
2320b57cec5SDimitry Andric   if (name == "* Linker *")
2339dba64beSDimitry Andric     --compile_unit_count;
2349dba64beSDimitry Andric   return compile_unit_count;
2350b57cec5SDimitry Andric }
2360b57cec5SDimitry Andric 
2370b57cec5SDimitry Andric void SymbolFilePDB::GetCompileUnitIndex(
2380b57cec5SDimitry Andric     const llvm::pdb::PDBSymbolCompiland &pdb_compiland, uint32_t &index) {
2390b57cec5SDimitry Andric   auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
2400b57cec5SDimitry Andric   if (!results_up)
2410b57cec5SDimitry Andric     return;
2420b57cec5SDimitry Andric   auto uid = pdb_compiland.getSymIndexId();
2430b57cec5SDimitry Andric   for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
2440b57cec5SDimitry Andric     auto compiland_up = results_up->getChildAtIndex(cu_idx);
2450b57cec5SDimitry Andric     if (!compiland_up)
2460b57cec5SDimitry Andric       continue;
2470b57cec5SDimitry Andric     if (compiland_up->getSymIndexId() == uid) {
2480b57cec5SDimitry Andric       index = cu_idx;
2490b57cec5SDimitry Andric       return;
2500b57cec5SDimitry Andric     }
2510b57cec5SDimitry Andric   }
2520b57cec5SDimitry Andric   index = UINT32_MAX;
2530b57cec5SDimitry Andric }
2540b57cec5SDimitry Andric 
2550b57cec5SDimitry Andric std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
2560b57cec5SDimitry Andric SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) {
2570b57cec5SDimitry Andric   return m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(uid);
2580b57cec5SDimitry Andric }
2590b57cec5SDimitry Andric 
2600b57cec5SDimitry Andric lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
2610b57cec5SDimitry Andric   if (index >= GetNumCompileUnits())
2620b57cec5SDimitry Andric     return CompUnitSP();
2630b57cec5SDimitry Andric 
2640b57cec5SDimitry Andric   // Assuming we always retrieve same compilands listed in same order through
2650b57cec5SDimitry Andric   // `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a
2660b57cec5SDimitry Andric   // compile unit makes no sense.
2670b57cec5SDimitry Andric   auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
2680b57cec5SDimitry Andric   if (!results)
2690b57cec5SDimitry Andric     return CompUnitSP();
2700b57cec5SDimitry Andric   auto compiland_up = results->getChildAtIndex(index);
2710b57cec5SDimitry Andric   if (!compiland_up)
2720b57cec5SDimitry Andric     return CompUnitSP();
2730b57cec5SDimitry Andric   return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
2740b57cec5SDimitry Andric }
2750b57cec5SDimitry Andric 
2760b57cec5SDimitry Andric lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
2779dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2780b57cec5SDimitry Andric   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
2790b57cec5SDimitry Andric   if (!compiland_up)
2800b57cec5SDimitry Andric     return lldb::eLanguageTypeUnknown;
2810b57cec5SDimitry Andric   auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
2820b57cec5SDimitry Andric   if (!details)
2830b57cec5SDimitry Andric     return lldb::eLanguageTypeUnknown;
2840b57cec5SDimitry Andric   return TranslateLanguage(details->getLanguage());
2850b57cec5SDimitry Andric }
2860b57cec5SDimitry Andric 
2870b57cec5SDimitry Andric lldb_private::Function *
2880b57cec5SDimitry Andric SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
2890b57cec5SDimitry Andric                                                   CompileUnit &comp_unit) {
2900b57cec5SDimitry Andric   if (FunctionSP result = comp_unit.FindFunctionByUID(pdb_func.getSymIndexId()))
2910b57cec5SDimitry Andric     return result.get();
2920b57cec5SDimitry Andric 
2930b57cec5SDimitry Andric   auto file_vm_addr = pdb_func.getVirtualAddress();
2940b57cec5SDimitry Andric   if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
2950b57cec5SDimitry Andric     return nullptr;
2960b57cec5SDimitry Andric 
2970b57cec5SDimitry Andric   auto func_length = pdb_func.getLength();
2980b57cec5SDimitry Andric   AddressRange func_range =
2990b57cec5SDimitry Andric       AddressRange(file_vm_addr, func_length,
3000b57cec5SDimitry Andric                    GetObjectFile()->GetModule()->GetSectionList());
3010b57cec5SDimitry Andric   if (!func_range.GetBaseAddress().IsValid())
3020b57cec5SDimitry Andric     return nullptr;
3030b57cec5SDimitry Andric 
3040b57cec5SDimitry Andric   lldb_private::Type *func_type = ResolveTypeUID(pdb_func.getSymIndexId());
3050b57cec5SDimitry Andric   if (!func_type)
3060b57cec5SDimitry Andric     return nullptr;
3070b57cec5SDimitry Andric 
3080b57cec5SDimitry Andric   user_id_t func_type_uid = pdb_func.getSignatureId();
3090b57cec5SDimitry Andric 
3100b57cec5SDimitry Andric   Mangled mangled = GetMangledForPDBFunc(pdb_func);
3110b57cec5SDimitry Andric 
3120b57cec5SDimitry Andric   FunctionSP func_sp =
3130b57cec5SDimitry Andric       std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
3140b57cec5SDimitry Andric                                  func_type_uid, mangled, func_type, func_range);
3150b57cec5SDimitry Andric 
3160b57cec5SDimitry Andric   comp_unit.AddFunction(func_sp);
3170b57cec5SDimitry Andric 
3180b57cec5SDimitry Andric   LanguageType lang = ParseLanguage(comp_unit);
3199dba64beSDimitry Andric   auto type_system_or_err = GetTypeSystemForLanguage(lang);
3209dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
32181ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
32206c3fb27SDimitry Andric                    "Unable to parse PDBFunc: {0}");
3230b57cec5SDimitry Andric     return nullptr;
3249dba64beSDimitry Andric   }
3259dba64beSDimitry Andric 
326bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
3275ffd83dbSDimitry Andric   TypeSystemClang *clang_type_system =
328bdd1243dSDimitry Andric     llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
3290b57cec5SDimitry Andric   if (!clang_type_system)
3300b57cec5SDimitry Andric     return nullptr;
3310b57cec5SDimitry Andric   clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
3320b57cec5SDimitry Andric 
3330b57cec5SDimitry Andric   return func_sp.get();
3340b57cec5SDimitry Andric }
3350b57cec5SDimitry Andric 
3360b57cec5SDimitry Andric size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
3379dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3380b57cec5SDimitry Andric   size_t func_added = 0;
3390b57cec5SDimitry Andric   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
3400b57cec5SDimitry Andric   if (!compiland_up)
3410b57cec5SDimitry Andric     return 0;
3420b57cec5SDimitry Andric   auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
3430b57cec5SDimitry Andric   if (!results_up)
3440b57cec5SDimitry Andric     return 0;
3450b57cec5SDimitry Andric   while (auto pdb_func_up = results_up->getNext()) {
3460b57cec5SDimitry Andric     auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
3470b57cec5SDimitry Andric     if (!func_sp) {
3480b57cec5SDimitry Andric       if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
3490b57cec5SDimitry Andric         ++func_added;
3500b57cec5SDimitry Andric     }
3510b57cec5SDimitry Andric   }
3520b57cec5SDimitry Andric   return func_added;
3530b57cec5SDimitry Andric }
3540b57cec5SDimitry Andric 
3550b57cec5SDimitry Andric bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
3569dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3570b57cec5SDimitry Andric   if (comp_unit.GetLineTable())
3580b57cec5SDimitry Andric     return true;
3590b57cec5SDimitry Andric   return ParseCompileUnitLineTable(comp_unit, 0);
3600b57cec5SDimitry Andric }
3610b57cec5SDimitry Andric 
3620b57cec5SDimitry Andric bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
3630b57cec5SDimitry Andric   // PDB doesn't contain information about macros
3640b57cec5SDimitry Andric   return false;
3650b57cec5SDimitry Andric }
3660b57cec5SDimitry Andric 
3670b57cec5SDimitry Andric bool SymbolFilePDB::ParseSupportFiles(
3681db9f3b2SDimitry Andric     CompileUnit &comp_unit, lldb_private::SupportFileList &support_files) {
3690b57cec5SDimitry Andric 
3700b57cec5SDimitry Andric   // In theory this is unnecessary work for us, because all of this information
3710b57cec5SDimitry Andric   // is easily (and quickly) accessible from DebugInfoPDB, so caching it a
3720b57cec5SDimitry Andric   // second time seems like a waste.  Unfortunately, there's no good way around
3730b57cec5SDimitry Andric   // this short of a moderate refactor since SymbolVendor depends on being able
3740b57cec5SDimitry Andric   // to cache this list.
3759dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3760b57cec5SDimitry Andric   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
3770b57cec5SDimitry Andric   if (!compiland_up)
3780b57cec5SDimitry Andric     return false;
3790b57cec5SDimitry Andric   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
3800b57cec5SDimitry Andric   if (!files || files->getChildCount() == 0)
3810b57cec5SDimitry Andric     return false;
3820b57cec5SDimitry Andric 
3830b57cec5SDimitry Andric   while (auto file = files->getNext()) {
3840b57cec5SDimitry Andric     FileSpec spec(file->getFileName(), FileSpec::Style::windows);
3850b57cec5SDimitry Andric     support_files.AppendIfUnique(spec);
3860b57cec5SDimitry Andric   }
3870b57cec5SDimitry Andric 
3880b57cec5SDimitry Andric   return true;
3890b57cec5SDimitry Andric }
3900b57cec5SDimitry Andric 
3910b57cec5SDimitry Andric bool SymbolFilePDB::ParseImportedModules(
3920b57cec5SDimitry Andric     const lldb_private::SymbolContext &sc,
3930b57cec5SDimitry Andric     std::vector<SourceModule> &imported_modules) {
3940b57cec5SDimitry Andric   // PDB does not yet support module debug info
3950b57cec5SDimitry Andric   return false;
3960b57cec5SDimitry Andric }
3970b57cec5SDimitry Andric 
3980b57cec5SDimitry Andric static size_t ParseFunctionBlocksForPDBSymbol(
3990b57cec5SDimitry Andric     uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
4000b57cec5SDimitry Andric     lldb_private::Block *parent_block, bool is_top_parent) {
4010b57cec5SDimitry Andric   assert(pdb_symbol && parent_block);
4020b57cec5SDimitry Andric 
4030b57cec5SDimitry Andric   size_t num_added = 0;
4040b57cec5SDimitry Andric   switch (pdb_symbol->getSymTag()) {
4050b57cec5SDimitry Andric   case PDB_SymType::Block:
4060b57cec5SDimitry Andric   case PDB_SymType::Function: {
4070b57cec5SDimitry Andric     Block *block = nullptr;
4080b57cec5SDimitry Andric     auto &raw_sym = pdb_symbol->getRawSymbol();
4090b57cec5SDimitry Andric     if (auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(pdb_symbol)) {
4100b57cec5SDimitry Andric       if (pdb_func->hasNoInlineAttribute())
4110b57cec5SDimitry Andric         break;
4120b57cec5SDimitry Andric       if (is_top_parent)
4130b57cec5SDimitry Andric         block = parent_block;
4140b57cec5SDimitry Andric       else
4150b57cec5SDimitry Andric         break;
4160eae32dcSDimitry Andric     } else if (llvm::isa<PDBSymbolBlock>(pdb_symbol)) {
4170b57cec5SDimitry Andric       auto uid = pdb_symbol->getSymIndexId();
4180b57cec5SDimitry Andric       if (parent_block->FindBlockByID(uid))
4190b57cec5SDimitry Andric         break;
4200b57cec5SDimitry Andric       if (raw_sym.getVirtualAddress() < func_file_vm_addr)
4210b57cec5SDimitry Andric         break;
4220b57cec5SDimitry Andric 
4230b57cec5SDimitry Andric       auto block_sp = std::make_shared<Block>(pdb_symbol->getSymIndexId());
4240b57cec5SDimitry Andric       parent_block->AddChild(block_sp);
4250b57cec5SDimitry Andric       block = block_sp.get();
4260b57cec5SDimitry Andric     } else
4270b57cec5SDimitry Andric       llvm_unreachable("Unexpected PDB symbol!");
4280b57cec5SDimitry Andric 
4290b57cec5SDimitry Andric     block->AddRange(Block::Range(
4300b57cec5SDimitry Andric         raw_sym.getVirtualAddress() - func_file_vm_addr, raw_sym.getLength()));
4310b57cec5SDimitry Andric     block->FinalizeRanges();
4320b57cec5SDimitry Andric     ++num_added;
4330b57cec5SDimitry Andric 
4340b57cec5SDimitry Andric     auto results_up = pdb_symbol->findAllChildren();
4350b57cec5SDimitry Andric     if (!results_up)
4360b57cec5SDimitry Andric       break;
4370b57cec5SDimitry Andric     while (auto symbol_up = results_up->getNext()) {
4380b57cec5SDimitry Andric       num_added += ParseFunctionBlocksForPDBSymbol(
4390b57cec5SDimitry Andric           func_file_vm_addr, symbol_up.get(), block, false);
4400b57cec5SDimitry Andric     }
4410b57cec5SDimitry Andric   } break;
4420b57cec5SDimitry Andric   default:
4430b57cec5SDimitry Andric     break;
4440b57cec5SDimitry Andric   }
4450b57cec5SDimitry Andric   return num_added;
4460b57cec5SDimitry Andric }
4470b57cec5SDimitry Andric 
4480b57cec5SDimitry Andric size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
4499dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
4500b57cec5SDimitry Andric   size_t num_added = 0;
4510b57cec5SDimitry Andric   auto uid = func.GetID();
4520b57cec5SDimitry Andric   auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
4530b57cec5SDimitry Andric   if (!pdb_func_up)
4540b57cec5SDimitry Andric     return 0;
4550b57cec5SDimitry Andric   Block &parent_block = func.GetBlock(false);
4560b57cec5SDimitry Andric   num_added = ParseFunctionBlocksForPDBSymbol(
4570b57cec5SDimitry Andric       pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
4580b57cec5SDimitry Andric   return num_added;
4590b57cec5SDimitry Andric }
4600b57cec5SDimitry Andric 
4610b57cec5SDimitry Andric size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
4629dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
4630b57cec5SDimitry Andric 
4640b57cec5SDimitry Andric   size_t num_added = 0;
4650b57cec5SDimitry Andric   auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
4660b57cec5SDimitry Andric   if (!compiland)
4670b57cec5SDimitry Andric     return 0;
4680b57cec5SDimitry Andric 
4690b57cec5SDimitry Andric   auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
4700b57cec5SDimitry Andric     std::unique_ptr<IPDBEnumSymbols> results;
4710b57cec5SDimitry Andric     PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
4720b57cec5SDimitry Andric                                     PDB_SymType::UDT};
4730b57cec5SDimitry Andric     for (auto tag : tags_to_search) {
4740b57cec5SDimitry Andric       results = raw_sym.findAllChildren(tag);
4750b57cec5SDimitry Andric       if (!results || results->getChildCount() == 0)
4760b57cec5SDimitry Andric         continue;
4770b57cec5SDimitry Andric       while (auto symbol = results->getNext()) {
4780b57cec5SDimitry Andric         switch (symbol->getSymTag()) {
4790b57cec5SDimitry Andric         case PDB_SymType::Enum:
4800b57cec5SDimitry Andric         case PDB_SymType::UDT:
4810b57cec5SDimitry Andric         case PDB_SymType::Typedef:
4820b57cec5SDimitry Andric           break;
4830b57cec5SDimitry Andric         default:
4840b57cec5SDimitry Andric           continue;
4850b57cec5SDimitry Andric         }
4860b57cec5SDimitry Andric 
4870b57cec5SDimitry Andric         // This should cause the type to get cached and stored in the `m_types`
4880b57cec5SDimitry Andric         // lookup.
4890b57cec5SDimitry Andric         if (auto type = ResolveTypeUID(symbol->getSymIndexId())) {
4900b57cec5SDimitry Andric           // Resolve the type completely to avoid a completion
4910b57cec5SDimitry Andric           // (and so a list change, which causes an iterators invalidation)
4920b57cec5SDimitry Andric           // during a TypeList dumping
4930b57cec5SDimitry Andric           type->GetFullCompilerType();
4940b57cec5SDimitry Andric           ++num_added;
4950b57cec5SDimitry Andric         }
4960b57cec5SDimitry Andric       }
4970b57cec5SDimitry Andric     }
4980b57cec5SDimitry Andric   };
4990b57cec5SDimitry Andric 
5000b57cec5SDimitry Andric   ParseTypesByTagFn(*compiland);
5010b57cec5SDimitry Andric 
5020b57cec5SDimitry Andric   // Also parse global types particularly coming from this compiland.
5030b57cec5SDimitry Andric   // Unfortunately, PDB has no compiland information for each global type. We
5040b57cec5SDimitry Andric   // have to parse them all. But ensure we only do this once.
5050b57cec5SDimitry Andric   static bool parse_all_global_types = false;
5060b57cec5SDimitry Andric   if (!parse_all_global_types) {
5070b57cec5SDimitry Andric     ParseTypesByTagFn(*m_global_scope_up);
5080b57cec5SDimitry Andric     parse_all_global_types = true;
5090b57cec5SDimitry Andric   }
5100b57cec5SDimitry Andric   return num_added;
5110b57cec5SDimitry Andric }
5120b57cec5SDimitry Andric 
5130b57cec5SDimitry Andric size_t
5140b57cec5SDimitry Andric SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) {
5159dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
5160b57cec5SDimitry Andric   if (!sc.comp_unit)
5170b57cec5SDimitry Andric     return 0;
5180b57cec5SDimitry Andric 
5190b57cec5SDimitry Andric   size_t num_added = 0;
5200b57cec5SDimitry Andric   if (sc.function) {
5210b57cec5SDimitry Andric     auto pdb_func = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(
5220b57cec5SDimitry Andric         sc.function->GetID());
5230b57cec5SDimitry Andric     if (!pdb_func)
5240b57cec5SDimitry Andric       return 0;
5250b57cec5SDimitry Andric 
5260b57cec5SDimitry Andric     num_added += ParseVariables(sc, *pdb_func);
5270b57cec5SDimitry Andric     sc.function->GetBlock(false).SetDidParseVariables(true, true);
5280b57cec5SDimitry Andric   } else if (sc.comp_unit) {
5290b57cec5SDimitry Andric     auto compiland = GetPDBCompilandByUID(sc.comp_unit->GetID());
5300b57cec5SDimitry Andric     if (!compiland)
5310b57cec5SDimitry Andric       return 0;
5320b57cec5SDimitry Andric 
5330b57cec5SDimitry Andric     if (sc.comp_unit->GetVariableList(false))
5340b57cec5SDimitry Andric       return 0;
5350b57cec5SDimitry Andric 
5360b57cec5SDimitry Andric     auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
5370b57cec5SDimitry Andric     if (results && results->getChildCount()) {
5380b57cec5SDimitry Andric       while (auto result = results->getNext()) {
5390b57cec5SDimitry Andric         auto cu_id = GetCompilandId(*result);
5400b57cec5SDimitry Andric         // FIXME: We are not able to determine variable's compile unit.
5410b57cec5SDimitry Andric         if (cu_id == 0)
5420b57cec5SDimitry Andric           continue;
5430b57cec5SDimitry Andric 
5440b57cec5SDimitry Andric         if (cu_id == sc.comp_unit->GetID())
5450b57cec5SDimitry Andric           num_added += ParseVariables(sc, *result);
5460b57cec5SDimitry Andric       }
5470b57cec5SDimitry Andric     }
5480b57cec5SDimitry Andric 
5490b57cec5SDimitry Andric     // FIXME: A `file static` or `global constant` variable appears both in
5500b57cec5SDimitry Andric     // compiland's children and global scope's children with unexpectedly
5510b57cec5SDimitry Andric     // different symbol's Id making it ambiguous.
5520b57cec5SDimitry Andric 
5530b57cec5SDimitry Andric     // FIXME: 'local constant', for example, const char var[] = "abc", declared
5540b57cec5SDimitry Andric     // in a function scope, can't be found in PDB.
5550b57cec5SDimitry Andric 
5560b57cec5SDimitry Andric     // Parse variables in this compiland.
5570b57cec5SDimitry Andric     num_added += ParseVariables(sc, *compiland);
5580b57cec5SDimitry Andric   }
5590b57cec5SDimitry Andric 
5600b57cec5SDimitry Andric   return num_added;
5610b57cec5SDimitry Andric }
5620b57cec5SDimitry Andric 
5630b57cec5SDimitry Andric lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
5649dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
5650b57cec5SDimitry Andric   auto find_result = m_types.find(type_uid);
5660b57cec5SDimitry Andric   if (find_result != m_types.end())
5670b57cec5SDimitry Andric     return find_result->second.get();
5680b57cec5SDimitry Andric 
5699dba64beSDimitry Andric   auto type_system_or_err =
5700b57cec5SDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
5719dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
57281ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
57306c3fb27SDimitry Andric                    "Unable to ResolveTypeUID: {0}");
5749dba64beSDimitry Andric     return nullptr;
5759dba64beSDimitry Andric   }
5769dba64beSDimitry Andric 
577bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
5785ffd83dbSDimitry Andric   TypeSystemClang *clang_type_system =
579bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
5800b57cec5SDimitry Andric   if (!clang_type_system)
5810b57cec5SDimitry Andric     return nullptr;
5820b57cec5SDimitry Andric   PDBASTParser *pdb = clang_type_system->GetPDBParser();
5830b57cec5SDimitry Andric   if (!pdb)
5840b57cec5SDimitry Andric     return nullptr;
5850b57cec5SDimitry Andric 
5860b57cec5SDimitry Andric   auto pdb_type = m_session_up->getSymbolById(type_uid);
5870b57cec5SDimitry Andric   if (pdb_type == nullptr)
5880b57cec5SDimitry Andric     return nullptr;
5890b57cec5SDimitry Andric 
5900b57cec5SDimitry Andric   lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
5910b57cec5SDimitry Andric   if (result) {
5920b57cec5SDimitry Andric     m_types.insert(std::make_pair(type_uid, result));
5930b57cec5SDimitry Andric   }
5940b57cec5SDimitry Andric   return result.get();
5950b57cec5SDimitry Andric }
5960b57cec5SDimitry Andric 
597bdd1243dSDimitry Andric std::optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
5980b57cec5SDimitry Andric     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
599bdd1243dSDimitry Andric   return std::nullopt;
6000b57cec5SDimitry Andric }
6010b57cec5SDimitry Andric 
6020b57cec5SDimitry Andric bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
6030b57cec5SDimitry Andric   std::lock_guard<std::recursive_mutex> guard(
6040b57cec5SDimitry Andric       GetObjectFile()->GetModule()->GetMutex());
6050b57cec5SDimitry Andric 
6069dba64beSDimitry Andric   auto type_system_or_err =
6079dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
6089dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
60981ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
61006c3fb27SDimitry Andric                    "Unable to get dynamic array info for UID: {0}");
6119dba64beSDimitry Andric     return false;
6129dba64beSDimitry Andric   }
613bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
6145ffd83dbSDimitry Andric   TypeSystemClang *clang_ast_ctx =
615bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
6169dba64beSDimitry Andric 
6170b57cec5SDimitry Andric   if (!clang_ast_ctx)
6180b57cec5SDimitry Andric     return false;
6190b57cec5SDimitry Andric 
6200b57cec5SDimitry Andric   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
6210b57cec5SDimitry Andric   if (!pdb)
6220b57cec5SDimitry Andric     return false;
6230b57cec5SDimitry Andric 
6240b57cec5SDimitry Andric   return pdb->CompleteTypeFromPDB(compiler_type);
6250b57cec5SDimitry Andric }
6260b57cec5SDimitry Andric 
6270b57cec5SDimitry Andric lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
6289dba64beSDimitry Andric   auto type_system_or_err =
6299dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
6309dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
63181ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
63206c3fb27SDimitry Andric                    "Unable to get decl for UID: {0}");
6339dba64beSDimitry Andric     return CompilerDecl();
6349dba64beSDimitry Andric   }
635bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
6365ffd83dbSDimitry Andric   TypeSystemClang *clang_ast_ctx =
637bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
6380b57cec5SDimitry Andric   if (!clang_ast_ctx)
6390b57cec5SDimitry Andric     return CompilerDecl();
6400b57cec5SDimitry Andric 
6410b57cec5SDimitry Andric   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
6420b57cec5SDimitry Andric   if (!pdb)
6430b57cec5SDimitry Andric     return CompilerDecl();
6440b57cec5SDimitry Andric 
6450b57cec5SDimitry Andric   auto symbol = m_session_up->getSymbolById(uid);
6460b57cec5SDimitry Andric   if (!symbol)
6470b57cec5SDimitry Andric     return CompilerDecl();
6480b57cec5SDimitry Andric 
6490b57cec5SDimitry Andric   auto decl = pdb->GetDeclForSymbol(*symbol);
6500b57cec5SDimitry Andric   if (!decl)
6510b57cec5SDimitry Andric     return CompilerDecl();
6520b57cec5SDimitry Andric 
6535ffd83dbSDimitry Andric   return clang_ast_ctx->GetCompilerDecl(decl);
6540b57cec5SDimitry Andric }
6550b57cec5SDimitry Andric 
6560b57cec5SDimitry Andric lldb_private::CompilerDeclContext
6570b57cec5SDimitry Andric SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
6589dba64beSDimitry Andric   auto type_system_or_err =
6599dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
6609dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
66181ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
66206c3fb27SDimitry Andric                    "Unable to get DeclContext for UID: {0}");
6639dba64beSDimitry Andric     return CompilerDeclContext();
6649dba64beSDimitry Andric   }
6659dba64beSDimitry Andric 
666bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
6675ffd83dbSDimitry Andric   TypeSystemClang *clang_ast_ctx =
668bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
6690b57cec5SDimitry Andric   if (!clang_ast_ctx)
6700b57cec5SDimitry Andric     return CompilerDeclContext();
6710b57cec5SDimitry Andric 
6720b57cec5SDimitry Andric   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
6730b57cec5SDimitry Andric   if (!pdb)
6740b57cec5SDimitry Andric     return CompilerDeclContext();
6750b57cec5SDimitry Andric 
6760b57cec5SDimitry Andric   auto symbol = m_session_up->getSymbolById(uid);
6770b57cec5SDimitry Andric   if (!symbol)
6780b57cec5SDimitry Andric     return CompilerDeclContext();
6790b57cec5SDimitry Andric 
6800b57cec5SDimitry Andric   auto decl_context = pdb->GetDeclContextForSymbol(*symbol);
6810b57cec5SDimitry Andric   if (!decl_context)
6820b57cec5SDimitry Andric     return GetDeclContextContainingUID(uid);
6830b57cec5SDimitry Andric 
684480093f4SDimitry Andric   return clang_ast_ctx->CreateDeclContext(decl_context);
6850b57cec5SDimitry Andric }
6860b57cec5SDimitry Andric 
6870b57cec5SDimitry Andric lldb_private::CompilerDeclContext
6880b57cec5SDimitry Andric SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
6899dba64beSDimitry Andric   auto type_system_or_err =
6909dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
6919dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
69281ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
69306c3fb27SDimitry Andric                    "Unable to get DeclContext containing UID: {0}");
6949dba64beSDimitry Andric     return CompilerDeclContext();
6959dba64beSDimitry Andric   }
6969dba64beSDimitry Andric 
697bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
6985ffd83dbSDimitry Andric   TypeSystemClang *clang_ast_ctx =
699bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
7000b57cec5SDimitry Andric   if (!clang_ast_ctx)
7010b57cec5SDimitry Andric     return CompilerDeclContext();
7020b57cec5SDimitry Andric 
7030b57cec5SDimitry Andric   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
7040b57cec5SDimitry Andric   if (!pdb)
7050b57cec5SDimitry Andric     return CompilerDeclContext();
7060b57cec5SDimitry Andric 
7070b57cec5SDimitry Andric   auto symbol = m_session_up->getSymbolById(uid);
7080b57cec5SDimitry Andric   if (!symbol)
7090b57cec5SDimitry Andric     return CompilerDeclContext();
7100b57cec5SDimitry Andric 
7110b57cec5SDimitry Andric   auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
7120b57cec5SDimitry Andric   assert(decl_context);
7130b57cec5SDimitry Andric 
714480093f4SDimitry Andric   return clang_ast_ctx->CreateDeclContext(decl_context);
7150b57cec5SDimitry Andric }
7160b57cec5SDimitry Andric 
7170b57cec5SDimitry Andric void SymbolFilePDB::ParseDeclsForContext(
7180b57cec5SDimitry Andric     lldb_private::CompilerDeclContext decl_ctx) {
7199dba64beSDimitry Andric   auto type_system_or_err =
7209dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
7219dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
72281ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
72306c3fb27SDimitry Andric                    "Unable to parse decls for context: {0}");
7249dba64beSDimitry Andric     return;
7259dba64beSDimitry Andric   }
7269dba64beSDimitry Andric 
727bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
7285ffd83dbSDimitry Andric   TypeSystemClang *clang_ast_ctx =
729bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
7300b57cec5SDimitry Andric   if (!clang_ast_ctx)
7310b57cec5SDimitry Andric     return;
7320b57cec5SDimitry Andric 
7330b57cec5SDimitry Andric   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
7340b57cec5SDimitry Andric   if (!pdb)
7350b57cec5SDimitry Andric     return;
7360b57cec5SDimitry Andric 
7370b57cec5SDimitry Andric   pdb->ParseDeclsForDeclContext(
7380b57cec5SDimitry Andric       static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
7390b57cec5SDimitry Andric }
7400b57cec5SDimitry Andric 
7410b57cec5SDimitry Andric uint32_t
7420b57cec5SDimitry Andric SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
7430b57cec5SDimitry Andric                                     SymbolContextItem resolve_scope,
7440b57cec5SDimitry Andric                                     lldb_private::SymbolContext &sc) {
7459dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
7460b57cec5SDimitry Andric   uint32_t resolved_flags = 0;
7470b57cec5SDimitry Andric   if (resolve_scope & eSymbolContextCompUnit ||
7480b57cec5SDimitry Andric       resolve_scope & eSymbolContextVariable ||
7490b57cec5SDimitry Andric       resolve_scope & eSymbolContextFunction ||
7500b57cec5SDimitry Andric       resolve_scope & eSymbolContextBlock ||
7510b57cec5SDimitry Andric       resolve_scope & eSymbolContextLineEntry) {
7520b57cec5SDimitry Andric     auto cu_sp = GetCompileUnitContainsAddress(so_addr);
7530b57cec5SDimitry Andric     if (!cu_sp) {
7549dba64beSDimitry Andric       if (resolved_flags & eSymbolContextVariable) {
7550b57cec5SDimitry Andric         // TODO: Resolve variables
7560b57cec5SDimitry Andric       }
7570b57cec5SDimitry Andric       return 0;
7580b57cec5SDimitry Andric     }
7590b57cec5SDimitry Andric     sc.comp_unit = cu_sp.get();
7600b57cec5SDimitry Andric     resolved_flags |= eSymbolContextCompUnit;
7610b57cec5SDimitry Andric     lldbassert(sc.module_sp == cu_sp->GetModule());
7620b57cec5SDimitry Andric   }
7630b57cec5SDimitry Andric 
7640b57cec5SDimitry Andric   if (resolve_scope & eSymbolContextFunction ||
7650b57cec5SDimitry Andric       resolve_scope & eSymbolContextBlock) {
7660b57cec5SDimitry Andric     addr_t file_vm_addr = so_addr.GetFileAddress();
7670b57cec5SDimitry Andric     auto symbol_up =
7680b57cec5SDimitry Andric         m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
7690b57cec5SDimitry Andric     if (symbol_up) {
7700b57cec5SDimitry Andric       auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
7710b57cec5SDimitry Andric       assert(pdb_func);
7720b57cec5SDimitry Andric       auto func_uid = pdb_func->getSymIndexId();
7730b57cec5SDimitry Andric       sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
7740b57cec5SDimitry Andric       if (sc.function == nullptr)
7750b57cec5SDimitry Andric         sc.function =
7760b57cec5SDimitry Andric             ParseCompileUnitFunctionForPDBFunc(*pdb_func, *sc.comp_unit);
7770b57cec5SDimitry Andric       if (sc.function) {
7780b57cec5SDimitry Andric         resolved_flags |= eSymbolContextFunction;
7790b57cec5SDimitry Andric         if (resolve_scope & eSymbolContextBlock) {
7800b57cec5SDimitry Andric           auto block_symbol = m_session_up->findSymbolByAddress(
7810b57cec5SDimitry Andric               file_vm_addr, PDB_SymType::Block);
7820b57cec5SDimitry Andric           auto block_id = block_symbol ? block_symbol->getSymIndexId()
7830b57cec5SDimitry Andric                                        : sc.function->GetID();
7840b57cec5SDimitry Andric           sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
7850b57cec5SDimitry Andric           if (sc.block)
7860b57cec5SDimitry Andric             resolved_flags |= eSymbolContextBlock;
7870b57cec5SDimitry Andric         }
7880b57cec5SDimitry Andric       }
7890b57cec5SDimitry Andric     }
7900b57cec5SDimitry Andric   }
7910b57cec5SDimitry Andric 
7920b57cec5SDimitry Andric   if (resolve_scope & eSymbolContextLineEntry) {
7930b57cec5SDimitry Andric     if (auto *line_table = sc.comp_unit->GetLineTable()) {
7940b57cec5SDimitry Andric       Address addr(so_addr);
7950b57cec5SDimitry Andric       if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
7960b57cec5SDimitry Andric         resolved_flags |= eSymbolContextLineEntry;
7970b57cec5SDimitry Andric     }
7980b57cec5SDimitry Andric   }
7990b57cec5SDimitry Andric 
8000b57cec5SDimitry Andric   return resolved_flags;
8010b57cec5SDimitry Andric }
8020b57cec5SDimitry Andric 
8030b57cec5SDimitry Andric uint32_t SymbolFilePDB::ResolveSymbolContext(
804fe6060f1SDimitry Andric     const lldb_private::SourceLocationSpec &src_location_spec,
8050b57cec5SDimitry Andric     SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
8069dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
8070b57cec5SDimitry Andric   const size_t old_size = sc_list.GetSize();
808fe6060f1SDimitry Andric   const FileSpec &file_spec = src_location_spec.GetFileSpec();
80981ad6265SDimitry Andric   const uint32_t line = src_location_spec.GetLine().value_or(0);
8100b57cec5SDimitry Andric   if (resolve_scope & lldb::eSymbolContextCompUnit) {
8110b57cec5SDimitry Andric     // Locate all compilation units with line numbers referencing the specified
8120b57cec5SDimitry Andric     // file.  For example, if `file_spec` is <vector>, then this should return
8130b57cec5SDimitry Andric     // all source files and header files that reference <vector>, either
8140b57cec5SDimitry Andric     // directly or indirectly.
8150b57cec5SDimitry Andric     auto compilands = m_session_up->findCompilandsForSourceFile(
8160b57cec5SDimitry Andric         file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);
8170b57cec5SDimitry Andric 
8180b57cec5SDimitry Andric     if (!compilands)
8190b57cec5SDimitry Andric       return 0;
8200b57cec5SDimitry Andric 
8210b57cec5SDimitry Andric     // For each one, either find its previously parsed data or parse it afresh
8220b57cec5SDimitry Andric     // and add it to the symbol context list.
8230b57cec5SDimitry Andric     while (auto compiland = compilands->getNext()) {
8240b57cec5SDimitry Andric       // If we're not checking inlines, then don't add line information for
8250b57cec5SDimitry Andric       // this file unless the FileSpec matches. For inline functions, we don't
8260b57cec5SDimitry Andric       // have to match the FileSpec since they could be defined in headers
8270b57cec5SDimitry Andric       // other than file specified in FileSpec.
828fe6060f1SDimitry Andric       if (!src_location_spec.GetCheckInlines()) {
8290b57cec5SDimitry Andric         std::string source_file = compiland->getSourceFileFullPath();
8300b57cec5SDimitry Andric         if (source_file.empty())
8310b57cec5SDimitry Andric           continue;
8320b57cec5SDimitry Andric         FileSpec this_spec(source_file, FileSpec::Style::windows);
8330b57cec5SDimitry Andric         bool need_full_match = !file_spec.GetDirectory().IsEmpty();
8340b57cec5SDimitry Andric         if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
8350b57cec5SDimitry Andric           continue;
8360b57cec5SDimitry Andric       }
8370b57cec5SDimitry Andric 
8380b57cec5SDimitry Andric       SymbolContext sc;
8390b57cec5SDimitry Andric       auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
8400b57cec5SDimitry Andric       if (!cu)
8410b57cec5SDimitry Andric         continue;
8420b57cec5SDimitry Andric       sc.comp_unit = cu.get();
8430b57cec5SDimitry Andric       sc.module_sp = cu->GetModule();
8440b57cec5SDimitry Andric 
8450b57cec5SDimitry Andric       // If we were asked to resolve line entries, add all entries to the line
8460b57cec5SDimitry Andric       // table that match the requested line (or all lines if `line` == 0).
8470b57cec5SDimitry Andric       if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
8480b57cec5SDimitry Andric                            eSymbolContextLineEntry)) {
8490b57cec5SDimitry Andric         bool has_line_table = ParseCompileUnitLineTable(*sc.comp_unit, line);
8500b57cec5SDimitry Andric 
8510b57cec5SDimitry Andric         if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
8520b57cec5SDimitry Andric           // The query asks for line entries, but we can't get them for the
8530b57cec5SDimitry Andric           // compile unit. This is not normal for `line` = 0. So just assert
8540b57cec5SDimitry Andric           // it.
8550b57cec5SDimitry Andric           assert(line && "Couldn't get all line entries!\n");
8560b57cec5SDimitry Andric 
8570b57cec5SDimitry Andric           // Current compiland does not have the requested line. Search next.
8580b57cec5SDimitry Andric           continue;
8590b57cec5SDimitry Andric         }
8600b57cec5SDimitry Andric 
8610b57cec5SDimitry Andric         if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
8620b57cec5SDimitry Andric           if (!has_line_table)
8630b57cec5SDimitry Andric             continue;
8640b57cec5SDimitry Andric 
8650b57cec5SDimitry Andric           auto *line_table = sc.comp_unit->GetLineTable();
8660b57cec5SDimitry Andric           lldbassert(line_table);
8670b57cec5SDimitry Andric 
8680b57cec5SDimitry Andric           uint32_t num_line_entries = line_table->GetSize();
8690b57cec5SDimitry Andric           // Skip the terminal line entry.
8700b57cec5SDimitry Andric           --num_line_entries;
8710b57cec5SDimitry Andric 
8720b57cec5SDimitry Andric           // If `line `!= 0, see if we can resolve function for each line entry
8730b57cec5SDimitry Andric           // in the line table.
8740b57cec5SDimitry Andric           for (uint32_t line_idx = 0; line && line_idx < num_line_entries;
8750b57cec5SDimitry Andric                ++line_idx) {
8760b57cec5SDimitry Andric             if (!line_table->GetLineEntryAtIndex(line_idx, sc.line_entry))
8770b57cec5SDimitry Andric               continue;
8780b57cec5SDimitry Andric 
8790b57cec5SDimitry Andric             auto file_vm_addr =
8800b57cec5SDimitry Andric                 sc.line_entry.range.GetBaseAddress().GetFileAddress();
8810b57cec5SDimitry Andric             if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
8820b57cec5SDimitry Andric               continue;
8830b57cec5SDimitry Andric 
8840b57cec5SDimitry Andric             auto symbol_up = m_session_up->findSymbolByAddress(
8850b57cec5SDimitry Andric                 file_vm_addr, PDB_SymType::Function);
8860b57cec5SDimitry Andric             if (symbol_up) {
8870b57cec5SDimitry Andric               auto func_uid = symbol_up->getSymIndexId();
8880b57cec5SDimitry Andric               sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
8890b57cec5SDimitry Andric               if (sc.function == nullptr) {
8900b57cec5SDimitry Andric                 auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
8910b57cec5SDimitry Andric                 assert(pdb_func);
8920b57cec5SDimitry Andric                 sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func,
8930b57cec5SDimitry Andric                                                                  *sc.comp_unit);
8940b57cec5SDimitry Andric               }
8950b57cec5SDimitry Andric               if (sc.function && (resolve_scope & eSymbolContextBlock)) {
8960b57cec5SDimitry Andric                 Block &block = sc.function->GetBlock(true);
8970b57cec5SDimitry Andric                 sc.block = block.FindBlockByID(sc.function->GetID());
8980b57cec5SDimitry Andric               }
8990b57cec5SDimitry Andric             }
9000b57cec5SDimitry Andric             sc_list.Append(sc);
9010b57cec5SDimitry Andric           }
9020b57cec5SDimitry Andric         } else if (has_line_table) {
9030b57cec5SDimitry Andric           // We can parse line table for the compile unit. But no query to
9040b57cec5SDimitry Andric           // resolve function or block. We append `sc` to the list anyway.
9050b57cec5SDimitry Andric           sc_list.Append(sc);
9060b57cec5SDimitry Andric         }
9070b57cec5SDimitry Andric       } else {
9080b57cec5SDimitry Andric         // No query for line entry, function or block. But we have a valid
9090b57cec5SDimitry Andric         // compile unit, append `sc` to the list.
9100b57cec5SDimitry Andric         sc_list.Append(sc);
9110b57cec5SDimitry Andric       }
9120b57cec5SDimitry Andric     }
9130b57cec5SDimitry Andric   }
9140b57cec5SDimitry Andric   return sc_list.GetSize() - old_size;
9150b57cec5SDimitry Andric }
9160b57cec5SDimitry Andric 
9170b57cec5SDimitry Andric std::string SymbolFilePDB::GetMangledForPDBData(const PDBSymbolData &pdb_data) {
9180b57cec5SDimitry Andric   // Cache public names at first
9190b57cec5SDimitry Andric   if (m_public_names.empty())
9200b57cec5SDimitry Andric     if (auto result_up =
9210b57cec5SDimitry Andric             m_global_scope_up->findAllChildren(PDB_SymType::PublicSymbol))
9220b57cec5SDimitry Andric       while (auto symbol_up = result_up->getNext())
9230b57cec5SDimitry Andric         if (auto addr = symbol_up->getRawSymbol().getVirtualAddress())
9240b57cec5SDimitry Andric           m_public_names[addr] = symbol_up->getRawSymbol().getName();
9250b57cec5SDimitry Andric 
9260b57cec5SDimitry Andric   // Look up the name in the cache
9270b57cec5SDimitry Andric   return m_public_names.lookup(pdb_data.getVirtualAddress());
9280b57cec5SDimitry Andric }
9290b57cec5SDimitry Andric 
9300b57cec5SDimitry Andric VariableSP SymbolFilePDB::ParseVariableForPDBData(
9310b57cec5SDimitry Andric     const lldb_private::SymbolContext &sc,
9320b57cec5SDimitry Andric     const llvm::pdb::PDBSymbolData &pdb_data) {
9330b57cec5SDimitry Andric   VariableSP var_sp;
9340b57cec5SDimitry Andric   uint32_t var_uid = pdb_data.getSymIndexId();
9350b57cec5SDimitry Andric   auto result = m_variables.find(var_uid);
9360b57cec5SDimitry Andric   if (result != m_variables.end())
9370b57cec5SDimitry Andric     return result->second;
9380b57cec5SDimitry Andric 
9390b57cec5SDimitry Andric   ValueType scope = eValueTypeInvalid;
9400b57cec5SDimitry Andric   bool is_static_member = false;
9410b57cec5SDimitry Andric   bool is_external = false;
9420b57cec5SDimitry Andric   bool is_artificial = false;
9430b57cec5SDimitry Andric 
9440b57cec5SDimitry Andric   switch (pdb_data.getDataKind()) {
9450b57cec5SDimitry Andric   case PDB_DataKind::Global:
9460b57cec5SDimitry Andric     scope = eValueTypeVariableGlobal;
9470b57cec5SDimitry Andric     is_external = true;
9480b57cec5SDimitry Andric     break;
9490b57cec5SDimitry Andric   case PDB_DataKind::Local:
9500b57cec5SDimitry Andric     scope = eValueTypeVariableLocal;
9510b57cec5SDimitry Andric     break;
9520b57cec5SDimitry Andric   case PDB_DataKind::FileStatic:
9530b57cec5SDimitry Andric     scope = eValueTypeVariableStatic;
9540b57cec5SDimitry Andric     break;
9550b57cec5SDimitry Andric   case PDB_DataKind::StaticMember:
9560b57cec5SDimitry Andric     is_static_member = true;
9570b57cec5SDimitry Andric     scope = eValueTypeVariableStatic;
9580b57cec5SDimitry Andric     break;
9590b57cec5SDimitry Andric   case PDB_DataKind::Member:
9600b57cec5SDimitry Andric     scope = eValueTypeVariableStatic;
9610b57cec5SDimitry Andric     break;
9620b57cec5SDimitry Andric   case PDB_DataKind::Param:
9630b57cec5SDimitry Andric     scope = eValueTypeVariableArgument;
9640b57cec5SDimitry Andric     break;
9650b57cec5SDimitry Andric   case PDB_DataKind::Constant:
9660b57cec5SDimitry Andric     scope = eValueTypeConstResult;
9670b57cec5SDimitry Andric     break;
9680b57cec5SDimitry Andric   default:
9690b57cec5SDimitry Andric     break;
9700b57cec5SDimitry Andric   }
9710b57cec5SDimitry Andric 
9720b57cec5SDimitry Andric   switch (pdb_data.getLocationType()) {
9730b57cec5SDimitry Andric   case PDB_LocType::TLS:
9740b57cec5SDimitry Andric     scope = eValueTypeVariableThreadLocal;
9750b57cec5SDimitry Andric     break;
9760b57cec5SDimitry Andric   case PDB_LocType::RegRel: {
9770b57cec5SDimitry Andric     // It is a `this` pointer.
9780b57cec5SDimitry Andric     if (pdb_data.getDataKind() == PDB_DataKind::ObjectPtr) {
9790b57cec5SDimitry Andric       scope = eValueTypeVariableArgument;
9800b57cec5SDimitry Andric       is_artificial = true;
9810b57cec5SDimitry Andric     }
9820b57cec5SDimitry Andric   } break;
9830b57cec5SDimitry Andric   default:
9840b57cec5SDimitry Andric     break;
9850b57cec5SDimitry Andric   }
9860b57cec5SDimitry Andric 
9870b57cec5SDimitry Andric   Declaration decl;
9880b57cec5SDimitry Andric   if (!is_artificial && !pdb_data.isCompilerGenerated()) {
9890b57cec5SDimitry Andric     if (auto lines = pdb_data.getLineNumbers()) {
9900b57cec5SDimitry Andric       if (auto first_line = lines->getNext()) {
9910b57cec5SDimitry Andric         uint32_t src_file_id = first_line->getSourceFileId();
9920b57cec5SDimitry Andric         auto src_file = m_session_up->getSourceFileById(src_file_id);
9930b57cec5SDimitry Andric         if (src_file) {
9940b57cec5SDimitry Andric           FileSpec spec(src_file->getFileName());
9950b57cec5SDimitry Andric           decl.SetFile(spec);
9960b57cec5SDimitry Andric           decl.SetColumn(first_line->getColumnNumber());
9970b57cec5SDimitry Andric           decl.SetLine(first_line->getLineNumber());
9980b57cec5SDimitry Andric         }
9990b57cec5SDimitry Andric       }
10000b57cec5SDimitry Andric     }
10010b57cec5SDimitry Andric   }
10020b57cec5SDimitry Andric 
10030b57cec5SDimitry Andric   Variable::RangeList ranges;
10040b57cec5SDimitry Andric   SymbolContextScope *context_scope = sc.comp_unit;
10050b57cec5SDimitry Andric   if (scope == eValueTypeVariableLocal || scope == eValueTypeVariableArgument) {
10060b57cec5SDimitry Andric     if (sc.function) {
10070b57cec5SDimitry Andric       Block &function_block = sc.function->GetBlock(true);
10080b57cec5SDimitry Andric       Block *block =
10090b57cec5SDimitry Andric           function_block.FindBlockByID(pdb_data.getLexicalParentId());
10100b57cec5SDimitry Andric       if (!block)
10110b57cec5SDimitry Andric         block = &function_block;
10120b57cec5SDimitry Andric 
10130b57cec5SDimitry Andric       context_scope = block;
10140b57cec5SDimitry Andric 
10150b57cec5SDimitry Andric       for (size_t i = 0, num_ranges = block->GetNumRanges(); i < num_ranges;
10160b57cec5SDimitry Andric            ++i) {
10170b57cec5SDimitry Andric         AddressRange range;
10180b57cec5SDimitry Andric         if (!block->GetRangeAtIndex(i, range))
10190b57cec5SDimitry Andric           continue;
10200b57cec5SDimitry Andric 
10210b57cec5SDimitry Andric         ranges.Append(range.GetBaseAddress().GetFileAddress(),
10220b57cec5SDimitry Andric                       range.GetByteSize());
10230b57cec5SDimitry Andric       }
10240b57cec5SDimitry Andric     }
10250b57cec5SDimitry Andric   }
10260b57cec5SDimitry Andric 
10270b57cec5SDimitry Andric   SymbolFileTypeSP type_sp =
10280b57cec5SDimitry Andric       std::make_shared<SymbolFileType>(*this, pdb_data.getTypeId());
10290b57cec5SDimitry Andric 
10300b57cec5SDimitry Andric   auto var_name = pdb_data.getName();
10310b57cec5SDimitry Andric   auto mangled = GetMangledForPDBData(pdb_data);
10320b57cec5SDimitry Andric   auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();
10330b57cec5SDimitry Andric 
10340b57cec5SDimitry Andric   bool is_constant;
1035753f127fSDimitry Andric   ModuleSP module_sp = GetObjectFile()->GetModule();
1036753f127fSDimitry Andric   DWARFExpressionList location(module_sp,
1037753f127fSDimitry Andric                                ConvertPDBLocationToDWARFExpression(
1038753f127fSDimitry Andric                                    module_sp, pdb_data, ranges, is_constant),
1039753f127fSDimitry Andric                                nullptr);
10400b57cec5SDimitry Andric 
10410b57cec5SDimitry Andric   var_sp = std::make_shared<Variable>(
10420b57cec5SDimitry Andric       var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
1043e8d8bef9SDimitry Andric       ranges, &decl, location, is_external, is_artificial, is_constant,
1044e8d8bef9SDimitry Andric       is_static_member);
10450b57cec5SDimitry Andric 
10460b57cec5SDimitry Andric   m_variables.insert(std::make_pair(var_uid, var_sp));
10470b57cec5SDimitry Andric   return var_sp;
10480b57cec5SDimitry Andric }
10490b57cec5SDimitry Andric 
10500b57cec5SDimitry Andric size_t
10510b57cec5SDimitry Andric SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
10520b57cec5SDimitry Andric                               const llvm::pdb::PDBSymbol &pdb_symbol,
10530b57cec5SDimitry Andric                               lldb_private::VariableList *variable_list) {
10540b57cec5SDimitry Andric   size_t num_added = 0;
10550b57cec5SDimitry Andric 
10560b57cec5SDimitry Andric   if (auto pdb_data = llvm::dyn_cast<PDBSymbolData>(&pdb_symbol)) {
10570b57cec5SDimitry Andric     VariableListSP local_variable_list_sp;
10580b57cec5SDimitry Andric 
10590b57cec5SDimitry Andric     auto result = m_variables.find(pdb_data->getSymIndexId());
10600b57cec5SDimitry Andric     if (result != m_variables.end()) {
10610b57cec5SDimitry Andric       if (variable_list)
10620b57cec5SDimitry Andric         variable_list->AddVariableIfUnique(result->second);
10630b57cec5SDimitry Andric     } else {
10640b57cec5SDimitry Andric       // Prepare right VariableList for this variable.
10650b57cec5SDimitry Andric       if (auto lexical_parent = pdb_data->getLexicalParent()) {
10660b57cec5SDimitry Andric         switch (lexical_parent->getSymTag()) {
10670b57cec5SDimitry Andric         case PDB_SymType::Exe:
10680b57cec5SDimitry Andric           assert(sc.comp_unit);
1069bdd1243dSDimitry Andric           [[fallthrough]];
10700b57cec5SDimitry Andric         case PDB_SymType::Compiland: {
10710b57cec5SDimitry Andric           if (sc.comp_unit) {
10720b57cec5SDimitry Andric             local_variable_list_sp = sc.comp_unit->GetVariableList(false);
10730b57cec5SDimitry Andric             if (!local_variable_list_sp) {
10740b57cec5SDimitry Andric               local_variable_list_sp = std::make_shared<VariableList>();
10750b57cec5SDimitry Andric               sc.comp_unit->SetVariableList(local_variable_list_sp);
10760b57cec5SDimitry Andric             }
10770b57cec5SDimitry Andric           }
10780b57cec5SDimitry Andric         } break;
10790b57cec5SDimitry Andric         case PDB_SymType::Block:
10800b57cec5SDimitry Andric         case PDB_SymType::Function: {
10810b57cec5SDimitry Andric           if (sc.function) {
10820b57cec5SDimitry Andric             Block *block = sc.function->GetBlock(true).FindBlockByID(
10830b57cec5SDimitry Andric                 lexical_parent->getSymIndexId());
10840b57cec5SDimitry Andric             if (block) {
10850b57cec5SDimitry Andric               local_variable_list_sp = block->GetBlockVariableList(false);
10860b57cec5SDimitry Andric               if (!local_variable_list_sp) {
10870b57cec5SDimitry Andric                 local_variable_list_sp = std::make_shared<VariableList>();
10880b57cec5SDimitry Andric                 block->SetVariableList(local_variable_list_sp);
10890b57cec5SDimitry Andric               }
10900b57cec5SDimitry Andric             }
10910b57cec5SDimitry Andric           }
10920b57cec5SDimitry Andric         } break;
10930b57cec5SDimitry Andric         default:
10940b57cec5SDimitry Andric           break;
10950b57cec5SDimitry Andric         }
10960b57cec5SDimitry Andric       }
10970b57cec5SDimitry Andric 
10980b57cec5SDimitry Andric       if (local_variable_list_sp) {
10990b57cec5SDimitry Andric         if (auto var_sp = ParseVariableForPDBData(sc, *pdb_data)) {
11000b57cec5SDimitry Andric           local_variable_list_sp->AddVariableIfUnique(var_sp);
11010b57cec5SDimitry Andric           if (variable_list)
11020b57cec5SDimitry Andric             variable_list->AddVariableIfUnique(var_sp);
11030b57cec5SDimitry Andric           ++num_added;
11040b57cec5SDimitry Andric           PDBASTParser *ast = GetPDBAstParser();
11050b57cec5SDimitry Andric           if (ast)
11060b57cec5SDimitry Andric             ast->GetDeclForSymbol(*pdb_data);
11070b57cec5SDimitry Andric         }
11080b57cec5SDimitry Andric       }
11090b57cec5SDimitry Andric     }
11100b57cec5SDimitry Andric   }
11110b57cec5SDimitry Andric 
11120b57cec5SDimitry Andric   if (auto results = pdb_symbol.findAllChildren()) {
11130b57cec5SDimitry Andric     while (auto result = results->getNext())
11140b57cec5SDimitry Andric       num_added += ParseVariables(sc, *result, variable_list);
11150b57cec5SDimitry Andric   }
11160b57cec5SDimitry Andric 
11170b57cec5SDimitry Andric   return num_added;
11180b57cec5SDimitry Andric }
11190b57cec5SDimitry Andric 
11209dba64beSDimitry Andric void SymbolFilePDB::FindGlobalVariables(
11215ffd83dbSDimitry Andric     lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
11220b57cec5SDimitry Andric     uint32_t max_matches, lldb_private::VariableList &variables) {
11239dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
11240b57cec5SDimitry Andric   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
11259dba64beSDimitry Andric     return;
11260b57cec5SDimitry Andric   if (name.IsEmpty())
11279dba64beSDimitry Andric     return;
11280b57cec5SDimitry Andric 
11290b57cec5SDimitry Andric   auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
11300b57cec5SDimitry Andric   if (!results)
11319dba64beSDimitry Andric     return;
11320b57cec5SDimitry Andric 
11330b57cec5SDimitry Andric   uint32_t matches = 0;
11340b57cec5SDimitry Andric   size_t old_size = variables.GetSize();
11350b57cec5SDimitry Andric   while (auto result = results->getNext()) {
11360b57cec5SDimitry Andric     auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
11370b57cec5SDimitry Andric     if (max_matches > 0 && matches >= max_matches)
11380b57cec5SDimitry Andric       break;
11390b57cec5SDimitry Andric 
11400b57cec5SDimitry Andric     SymbolContext sc;
11419dba64beSDimitry Andric     sc.module_sp = m_objfile_sp->GetModule();
11420b57cec5SDimitry Andric     lldbassert(sc.module_sp.get());
11430b57cec5SDimitry Andric 
1144*0fca6ea1SDimitry Andric     if (name.GetStringRef() !=
1145*0fca6ea1SDimitry Andric         MSVCUndecoratedNameParser::DropScope(pdb_data->getName()))
11460b57cec5SDimitry Andric       continue;
11470b57cec5SDimitry Andric 
11480b57cec5SDimitry Andric     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
11490b57cec5SDimitry Andric     // FIXME: We are not able to determine the compile unit.
11500b57cec5SDimitry Andric     if (sc.comp_unit == nullptr)
11510b57cec5SDimitry Andric       continue;
11520b57cec5SDimitry Andric 
11535ffd83dbSDimitry Andric     if (parent_decl_ctx.IsValid() &&
11545ffd83dbSDimitry Andric         GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
11550b57cec5SDimitry Andric       continue;
11560b57cec5SDimitry Andric 
11570b57cec5SDimitry Andric     ParseVariables(sc, *pdb_data, &variables);
11580b57cec5SDimitry Andric     matches = variables.GetSize() - old_size;
11590b57cec5SDimitry Andric   }
11600b57cec5SDimitry Andric }
11610b57cec5SDimitry Andric 
11629dba64beSDimitry Andric void SymbolFilePDB::FindGlobalVariables(
11639dba64beSDimitry Andric     const lldb_private::RegularExpression &regex, uint32_t max_matches,
11640b57cec5SDimitry Andric     lldb_private::VariableList &variables) {
11659dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
11660b57cec5SDimitry Andric   if (!regex.IsValid())
11679dba64beSDimitry Andric     return;
11680b57cec5SDimitry Andric   auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
11690b57cec5SDimitry Andric   if (!results)
11709dba64beSDimitry Andric     return;
11710b57cec5SDimitry Andric 
11720b57cec5SDimitry Andric   uint32_t matches = 0;
11730b57cec5SDimitry Andric   size_t old_size = variables.GetSize();
11740b57cec5SDimitry Andric   while (auto pdb_data = results->getNext()) {
11750b57cec5SDimitry Andric     if (max_matches > 0 && matches >= max_matches)
11760b57cec5SDimitry Andric       break;
11770b57cec5SDimitry Andric 
11780b57cec5SDimitry Andric     auto var_name = pdb_data->getName();
11790b57cec5SDimitry Andric     if (var_name.empty())
11800b57cec5SDimitry Andric       continue;
11810b57cec5SDimitry Andric     if (!regex.Execute(var_name))
11820b57cec5SDimitry Andric       continue;
11830b57cec5SDimitry Andric     SymbolContext sc;
11849dba64beSDimitry Andric     sc.module_sp = m_objfile_sp->GetModule();
11850b57cec5SDimitry Andric     lldbassert(sc.module_sp.get());
11860b57cec5SDimitry Andric 
11870b57cec5SDimitry Andric     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
11880b57cec5SDimitry Andric     // FIXME: We are not able to determine the compile unit.
11890b57cec5SDimitry Andric     if (sc.comp_unit == nullptr)
11900b57cec5SDimitry Andric       continue;
11910b57cec5SDimitry Andric 
11920b57cec5SDimitry Andric     ParseVariables(sc, *pdb_data, &variables);
11930b57cec5SDimitry Andric     matches = variables.GetSize() - old_size;
11940b57cec5SDimitry Andric   }
11950b57cec5SDimitry Andric }
11960b57cec5SDimitry Andric 
11970b57cec5SDimitry Andric bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
11980b57cec5SDimitry Andric                                     bool include_inlines,
11990b57cec5SDimitry Andric                                     lldb_private::SymbolContextList &sc_list) {
12000b57cec5SDimitry Andric   lldb_private::SymbolContext sc;
12010b57cec5SDimitry Andric   sc.comp_unit = ParseCompileUnitForUID(pdb_func.getCompilandId()).get();
12020b57cec5SDimitry Andric   if (!sc.comp_unit)
12030b57cec5SDimitry Andric     return false;
12040b57cec5SDimitry Andric   sc.module_sp = sc.comp_unit->GetModule();
12050b57cec5SDimitry Andric   sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, *sc.comp_unit);
12060b57cec5SDimitry Andric   if (!sc.function)
12070b57cec5SDimitry Andric     return false;
12080b57cec5SDimitry Andric 
12090b57cec5SDimitry Andric   sc_list.Append(sc);
12100b57cec5SDimitry Andric   return true;
12110b57cec5SDimitry Andric }
12120b57cec5SDimitry Andric 
12130b57cec5SDimitry Andric bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
12140b57cec5SDimitry Andric                                     lldb_private::SymbolContextList &sc_list) {
12150b57cec5SDimitry Andric   auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
12160b57cec5SDimitry Andric   if (!pdb_func_up && !(include_inlines && pdb_func_up->hasInlineAttribute()))
12170b57cec5SDimitry Andric     return false;
12180b57cec5SDimitry Andric   return ResolveFunction(*pdb_func_up, include_inlines, sc_list);
12190b57cec5SDimitry Andric }
12200b57cec5SDimitry Andric 
12210b57cec5SDimitry Andric void SymbolFilePDB::CacheFunctionNames() {
12220b57cec5SDimitry Andric   if (!m_func_full_names.IsEmpty())
12230b57cec5SDimitry Andric     return;
12240b57cec5SDimitry Andric 
12250b57cec5SDimitry Andric   std::map<uint64_t, uint32_t> addr_ids;
12260b57cec5SDimitry Andric 
12270b57cec5SDimitry Andric   if (auto results_up = m_global_scope_up->findAllChildren<PDBSymbolFunc>()) {
12280b57cec5SDimitry Andric     while (auto pdb_func_up = results_up->getNext()) {
12290b57cec5SDimitry Andric       if (pdb_func_up->isCompilerGenerated())
12300b57cec5SDimitry Andric         continue;
12310b57cec5SDimitry Andric 
12320b57cec5SDimitry Andric       auto name = pdb_func_up->getName();
12330b57cec5SDimitry Andric       auto demangled_name = pdb_func_up->getUndecoratedName();
12340b57cec5SDimitry Andric       if (name.empty() && demangled_name.empty())
12350b57cec5SDimitry Andric         continue;
12360b57cec5SDimitry Andric 
12370b57cec5SDimitry Andric       auto uid = pdb_func_up->getSymIndexId();
12380b57cec5SDimitry Andric       if (!demangled_name.empty() && pdb_func_up->getVirtualAddress())
12390b57cec5SDimitry Andric         addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));
12400b57cec5SDimitry Andric 
12410b57cec5SDimitry Andric       if (auto parent = pdb_func_up->getClassParent()) {
12420b57cec5SDimitry Andric 
12430b57cec5SDimitry Andric         // PDB have symbols for class/struct methods or static methods in Enum
12440b57cec5SDimitry Andric         // Class. We won't bother to check if the parent is UDT or Enum here.
12450b57cec5SDimitry Andric         m_func_method_names.Append(ConstString(name), uid);
12460b57cec5SDimitry Andric 
12470b57cec5SDimitry Andric         // To search a method name, like NS::Class:MemberFunc, LLDB searches
12480b57cec5SDimitry Andric         // its base name, i.e. MemberFunc by default. Since PDBSymbolFunc does
12495ffd83dbSDimitry Andric         // not have information of this, we extract base names and cache them
12500b57cec5SDimitry Andric         // by our own effort.
12510b57cec5SDimitry Andric         llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
12520b57cec5SDimitry Andric         if (!basename.empty())
12530b57cec5SDimitry Andric           m_func_base_names.Append(ConstString(basename), uid);
12540b57cec5SDimitry Andric         else {
12550b57cec5SDimitry Andric           m_func_base_names.Append(ConstString(name), uid);
12560b57cec5SDimitry Andric         }
12570b57cec5SDimitry Andric 
12580b57cec5SDimitry Andric         if (!demangled_name.empty())
12590b57cec5SDimitry Andric           m_func_full_names.Append(ConstString(demangled_name), uid);
12600b57cec5SDimitry Andric 
12610b57cec5SDimitry Andric       } else {
12620b57cec5SDimitry Andric         // Handle not-method symbols.
12630b57cec5SDimitry Andric 
12640b57cec5SDimitry Andric         // The function name might contain namespace, or its lexical scope.
12650b57cec5SDimitry Andric         llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
12660b57cec5SDimitry Andric         if (!basename.empty())
12670b57cec5SDimitry Andric           m_func_base_names.Append(ConstString(basename), uid);
12680b57cec5SDimitry Andric         else
12690b57cec5SDimitry Andric           m_func_base_names.Append(ConstString(name), uid);
12700b57cec5SDimitry Andric 
12710b57cec5SDimitry Andric         if (name == "main") {
12720b57cec5SDimitry Andric           m_func_full_names.Append(ConstString(name), uid);
12730b57cec5SDimitry Andric 
12740b57cec5SDimitry Andric           if (!demangled_name.empty() && name != demangled_name) {
12750b57cec5SDimitry Andric             m_func_full_names.Append(ConstString(demangled_name), uid);
12760b57cec5SDimitry Andric             m_func_base_names.Append(ConstString(demangled_name), uid);
12770b57cec5SDimitry Andric           }
12780b57cec5SDimitry Andric         } else if (!demangled_name.empty()) {
12790b57cec5SDimitry Andric           m_func_full_names.Append(ConstString(demangled_name), uid);
12800b57cec5SDimitry Andric         } else {
12810b57cec5SDimitry Andric           m_func_full_names.Append(ConstString(name), uid);
12820b57cec5SDimitry Andric         }
12830b57cec5SDimitry Andric       }
12840b57cec5SDimitry Andric     }
12850b57cec5SDimitry Andric   }
12860b57cec5SDimitry Andric 
12870b57cec5SDimitry Andric   if (auto results_up =
12880b57cec5SDimitry Andric           m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>()) {
12890b57cec5SDimitry Andric     while (auto pub_sym_up = results_up->getNext()) {
12900b57cec5SDimitry Andric       if (!pub_sym_up->isFunction())
12910b57cec5SDimitry Andric         continue;
12920b57cec5SDimitry Andric       auto name = pub_sym_up->getName();
12930b57cec5SDimitry Andric       if (name.empty())
12940b57cec5SDimitry Andric         continue;
12950b57cec5SDimitry Andric 
12960b57cec5SDimitry Andric       if (CPlusPlusLanguage::IsCPPMangledName(name.c_str())) {
12970b57cec5SDimitry Andric         auto vm_addr = pub_sym_up->getVirtualAddress();
12980b57cec5SDimitry Andric 
12990b57cec5SDimitry Andric         // PDB public symbol has mangled name for its associated function.
13000b57cec5SDimitry Andric         if (vm_addr && addr_ids.find(vm_addr) != addr_ids.end()) {
13010b57cec5SDimitry Andric           // Cache mangled name.
13020b57cec5SDimitry Andric           m_func_full_names.Append(ConstString(name), addr_ids[vm_addr]);
13030b57cec5SDimitry Andric         }
13040b57cec5SDimitry Andric       }
13050b57cec5SDimitry Andric     }
13060b57cec5SDimitry Andric   }
13070b57cec5SDimitry Andric   // Sort them before value searching is working properly
13080b57cec5SDimitry Andric   m_func_full_names.Sort();
13090b57cec5SDimitry Andric   m_func_full_names.SizeToFit();
13100b57cec5SDimitry Andric   m_func_method_names.Sort();
13110b57cec5SDimitry Andric   m_func_method_names.SizeToFit();
13120b57cec5SDimitry Andric   m_func_base_names.Sort();
13130b57cec5SDimitry Andric   m_func_base_names.SizeToFit();
13140b57cec5SDimitry Andric }
13150b57cec5SDimitry Andric 
13169dba64beSDimitry Andric void SymbolFilePDB::FindFunctions(
1317bdd1243dSDimitry Andric     const lldb_private::Module::LookupInfo &lookup_info,
13185ffd83dbSDimitry Andric     const lldb_private::CompilerDeclContext &parent_decl_ctx,
1319bdd1243dSDimitry Andric     bool include_inlines,
13200b57cec5SDimitry Andric     lldb_private::SymbolContextList &sc_list) {
13219dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1322bdd1243dSDimitry Andric   ConstString name = lookup_info.GetLookupName();
1323bdd1243dSDimitry Andric   FunctionNameType name_type_mask = lookup_info.GetNameTypeMask();
13240b57cec5SDimitry Andric   lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
13250b57cec5SDimitry Andric 
1326bdd1243dSDimitry Andric   if (name_type_mask & eFunctionNameTypeFull)
1327bdd1243dSDimitry Andric     name = lookup_info.GetName();
1328bdd1243dSDimitry Andric 
13290b57cec5SDimitry Andric   if (name_type_mask == eFunctionNameTypeNone)
13309dba64beSDimitry Andric     return;
13310b57cec5SDimitry Andric   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
13329dba64beSDimitry Andric     return;
13330b57cec5SDimitry Andric   if (name.IsEmpty())
13349dba64beSDimitry Andric     return;
13350b57cec5SDimitry Andric 
13360b57cec5SDimitry Andric   if (name_type_mask & eFunctionNameTypeFull ||
13370b57cec5SDimitry Andric       name_type_mask & eFunctionNameTypeBase ||
13380b57cec5SDimitry Andric       name_type_mask & eFunctionNameTypeMethod) {
13390b57cec5SDimitry Andric     CacheFunctionNames();
13400b57cec5SDimitry Andric 
13410b57cec5SDimitry Andric     std::set<uint32_t> resolved_ids;
13420b57cec5SDimitry Andric     auto ResolveFn = [this, &name, parent_decl_ctx, include_inlines, &sc_list,
13430b57cec5SDimitry Andric                       &resolved_ids](UniqueCStringMap<uint32_t> &Names) {
13440b57cec5SDimitry Andric       std::vector<uint32_t> ids;
13450b57cec5SDimitry Andric       if (!Names.GetValues(name, ids))
13460b57cec5SDimitry Andric         return;
13470b57cec5SDimitry Andric 
13480b57cec5SDimitry Andric       for (uint32_t id : ids) {
13490b57cec5SDimitry Andric         if (resolved_ids.find(id) != resolved_ids.end())
13500b57cec5SDimitry Andric           continue;
13510b57cec5SDimitry Andric 
13525ffd83dbSDimitry Andric         if (parent_decl_ctx.IsValid() &&
13535ffd83dbSDimitry Andric             GetDeclContextContainingUID(id) != parent_decl_ctx)
13540b57cec5SDimitry Andric           continue;
13550b57cec5SDimitry Andric 
13560b57cec5SDimitry Andric         if (ResolveFunction(id, include_inlines, sc_list))
13570b57cec5SDimitry Andric           resolved_ids.insert(id);
13580b57cec5SDimitry Andric       }
13590b57cec5SDimitry Andric     };
13600b57cec5SDimitry Andric     if (name_type_mask & eFunctionNameTypeFull) {
13610b57cec5SDimitry Andric       ResolveFn(m_func_full_names);
13620b57cec5SDimitry Andric       ResolveFn(m_func_base_names);
13630b57cec5SDimitry Andric       ResolveFn(m_func_method_names);
13640b57cec5SDimitry Andric     }
13659dba64beSDimitry Andric     if (name_type_mask & eFunctionNameTypeBase)
13660b57cec5SDimitry Andric       ResolveFn(m_func_base_names);
13679dba64beSDimitry Andric     if (name_type_mask & eFunctionNameTypeMethod)
13680b57cec5SDimitry Andric       ResolveFn(m_func_method_names);
13690b57cec5SDimitry Andric   }
13700b57cec5SDimitry Andric }
13710b57cec5SDimitry Andric 
13729dba64beSDimitry Andric void SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression &regex,
13739dba64beSDimitry Andric                                   bool include_inlines,
13740b57cec5SDimitry Andric                                   lldb_private::SymbolContextList &sc_list) {
13759dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
13760b57cec5SDimitry Andric   if (!regex.IsValid())
13779dba64beSDimitry Andric     return;
13780b57cec5SDimitry Andric 
13790b57cec5SDimitry Andric   CacheFunctionNames();
13800b57cec5SDimitry Andric 
13810b57cec5SDimitry Andric   std::set<uint32_t> resolved_ids;
13820b57cec5SDimitry Andric   auto ResolveFn = [&regex, include_inlines, &sc_list, &resolved_ids,
13830b57cec5SDimitry Andric                     this](UniqueCStringMap<uint32_t> &Names) {
13840b57cec5SDimitry Andric     std::vector<uint32_t> ids;
13850b57cec5SDimitry Andric     if (Names.GetValues(regex, ids)) {
13860b57cec5SDimitry Andric       for (auto id : ids) {
13870b57cec5SDimitry Andric         if (resolved_ids.find(id) == resolved_ids.end())
13880b57cec5SDimitry Andric           if (ResolveFunction(id, include_inlines, sc_list))
13890b57cec5SDimitry Andric             resolved_ids.insert(id);
13900b57cec5SDimitry Andric       }
13910b57cec5SDimitry Andric     }
13920b57cec5SDimitry Andric   };
13930b57cec5SDimitry Andric   ResolveFn(m_func_full_names);
13940b57cec5SDimitry Andric   ResolveFn(m_func_base_names);
13950b57cec5SDimitry Andric }
13960b57cec5SDimitry Andric 
13970b57cec5SDimitry Andric void SymbolFilePDB::GetMangledNamesForFunction(
13980b57cec5SDimitry Andric     const std::string &scope_qualified_name,
13990b57cec5SDimitry Andric     std::vector<lldb_private::ConstString> &mangled_names) {}
14000b57cec5SDimitry Andric 
14010b57cec5SDimitry Andric void SymbolFilePDB::AddSymbols(lldb_private::Symtab &symtab) {
14020b57cec5SDimitry Andric   std::set<lldb::addr_t> sym_addresses;
14030b57cec5SDimitry Andric   for (size_t i = 0; i < symtab.GetNumSymbols(); i++)
14040b57cec5SDimitry Andric     sym_addresses.insert(symtab.SymbolAtIndex(i)->GetFileAddress());
14050b57cec5SDimitry Andric 
14060b57cec5SDimitry Andric   auto results = m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>();
14070b57cec5SDimitry Andric   if (!results)
14080b57cec5SDimitry Andric     return;
14090b57cec5SDimitry Andric 
14109dba64beSDimitry Andric   auto section_list = m_objfile_sp->GetSectionList();
14110b57cec5SDimitry Andric   if (!section_list)
14120b57cec5SDimitry Andric     return;
14130b57cec5SDimitry Andric 
14140b57cec5SDimitry Andric   while (auto pub_symbol = results->getNext()) {
14150b57cec5SDimitry Andric     auto section_id = pub_symbol->getAddressSection();
14160b57cec5SDimitry Andric 
14170b57cec5SDimitry Andric     auto section = section_list->FindSectionByID(section_id);
14180b57cec5SDimitry Andric     if (!section)
14190b57cec5SDimitry Andric       continue;
14200b57cec5SDimitry Andric 
14210b57cec5SDimitry Andric     auto offset = pub_symbol->getAddressOffset();
14220b57cec5SDimitry Andric 
14230b57cec5SDimitry Andric     auto file_addr = section->GetFileAddress() + offset;
14240b57cec5SDimitry Andric     if (sym_addresses.find(file_addr) != sym_addresses.end())
14250b57cec5SDimitry Andric       continue;
14260b57cec5SDimitry Andric     sym_addresses.insert(file_addr);
14270b57cec5SDimitry Andric 
14280b57cec5SDimitry Andric     auto size = pub_symbol->getLength();
14290b57cec5SDimitry Andric     symtab.AddSymbol(
14300b57cec5SDimitry Andric         Symbol(pub_symbol->getSymIndexId(),   // symID
14310b57cec5SDimitry Andric                pub_symbol->getName().c_str(), // name
14320b57cec5SDimitry Andric                pub_symbol->isCode() ? eSymbolTypeCode : eSymbolTypeData, // type
14330b57cec5SDimitry Andric                true,      // external
14340b57cec5SDimitry Andric                false,     // is_debug
14350b57cec5SDimitry Andric                false,     // is_trampoline
14360b57cec5SDimitry Andric                false,     // is_artificial
14370b57cec5SDimitry Andric                section,   // section_sp
14380b57cec5SDimitry Andric                offset,    // value
14390b57cec5SDimitry Andric                size,      // size
14400b57cec5SDimitry Andric                size != 0, // size_is_valid
14410b57cec5SDimitry Andric                false,     // contains_linker_annotations
14420b57cec5SDimitry Andric                0          // flags
14430b57cec5SDimitry Andric                ));
14440b57cec5SDimitry Andric   }
14450b57cec5SDimitry Andric 
14460b57cec5SDimitry Andric   symtab.Finalize();
14470b57cec5SDimitry Andric }
14480b57cec5SDimitry Andric 
14490b57cec5SDimitry Andric void SymbolFilePDB::DumpClangAST(Stream &s) {
14509dba64beSDimitry Andric   auto type_system_or_err =
14519dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
14529dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
145381ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
145406c3fb27SDimitry Andric                    "Unable to dump ClangAST: {0}");
14550b57cec5SDimitry Andric     return;
14569dba64beSDimitry Andric   }
14579dba64beSDimitry Andric 
1458bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
1459bdd1243dSDimitry Andric   TypeSystemClang *clang_type_system =
1460bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
14619dba64beSDimitry Andric   if (!clang_type_system)
14629dba64beSDimitry Andric     return;
1463349cc55cSDimitry Andric   clang_type_system->Dump(s.AsRawOstream());
14640b57cec5SDimitry Andric }
14650b57cec5SDimitry Andric 
14660b57cec5SDimitry Andric void SymbolFilePDB::FindTypesByRegex(
14670b57cec5SDimitry Andric     const lldb_private::RegularExpression &regex, uint32_t max_matches,
14680b57cec5SDimitry Andric     lldb_private::TypeMap &types) {
14690b57cec5SDimitry Andric   // When searching by regex, we need to go out of our way to limit the search
14700b57cec5SDimitry Andric   // space as much as possible since this searches EVERYTHING in the PDB,
14710b57cec5SDimitry Andric   // manually doing regex comparisons.  PDB library isn't optimized for regex
14720b57cec5SDimitry Andric   // searches or searches across multiple symbol types at the same time, so the
14730b57cec5SDimitry Andric   // best we can do is to search enums, then typedefs, then classes one by one,
14740b57cec5SDimitry Andric   // and do a regex comparison against each of them.
14750b57cec5SDimitry Andric   PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
14760b57cec5SDimitry Andric                                   PDB_SymType::UDT};
14770b57cec5SDimitry Andric   std::unique_ptr<IPDBEnumSymbols> results;
14780b57cec5SDimitry Andric 
14790b57cec5SDimitry Andric   uint32_t matches = 0;
14800b57cec5SDimitry Andric 
14810b57cec5SDimitry Andric   for (auto tag : tags_to_search) {
14820b57cec5SDimitry Andric     results = m_global_scope_up->findAllChildren(tag);
14830b57cec5SDimitry Andric     if (!results)
14840b57cec5SDimitry Andric       continue;
14850b57cec5SDimitry Andric 
14860b57cec5SDimitry Andric     while (auto result = results->getNext()) {
14870b57cec5SDimitry Andric       if (max_matches > 0 && matches >= max_matches)
14880b57cec5SDimitry Andric         break;
14890b57cec5SDimitry Andric 
14900b57cec5SDimitry Andric       std::string type_name;
14910b57cec5SDimitry Andric       if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
14920b57cec5SDimitry Andric         type_name = enum_type->getName();
14930b57cec5SDimitry Andric       else if (auto typedef_type =
14940b57cec5SDimitry Andric                    llvm::dyn_cast<PDBSymbolTypeTypedef>(result.get()))
14950b57cec5SDimitry Andric         type_name = typedef_type->getName();
14960b57cec5SDimitry Andric       else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
14970b57cec5SDimitry Andric         type_name = class_type->getName();
14980b57cec5SDimitry Andric       else {
14990b57cec5SDimitry Andric         // We're looking only for types that have names.  Skip symbols, as well
15000b57cec5SDimitry Andric         // as unnamed types such as arrays, pointers, etc.
15010b57cec5SDimitry Andric         continue;
15020b57cec5SDimitry Andric       }
15030b57cec5SDimitry Andric 
15040b57cec5SDimitry Andric       if (!regex.Execute(type_name))
15050b57cec5SDimitry Andric         continue;
15060b57cec5SDimitry Andric 
15070b57cec5SDimitry Andric       // This should cause the type to get cached and stored in the `m_types`
15080b57cec5SDimitry Andric       // lookup.
15090b57cec5SDimitry Andric       if (!ResolveTypeUID(result->getSymIndexId()))
15100b57cec5SDimitry Andric         continue;
15110b57cec5SDimitry Andric 
15120b57cec5SDimitry Andric       auto iter = m_types.find(result->getSymIndexId());
15130b57cec5SDimitry Andric       if (iter == m_types.end())
15140b57cec5SDimitry Andric         continue;
15150b57cec5SDimitry Andric       types.Insert(iter->second);
15160b57cec5SDimitry Andric       ++matches;
15170b57cec5SDimitry Andric     }
15180b57cec5SDimitry Andric   }
15190b57cec5SDimitry Andric }
15200b57cec5SDimitry Andric 
15215f757f3fSDimitry Andric void SymbolFilePDB::FindTypes(const lldb_private::TypeQuery &query,
15225f757f3fSDimitry Andric                               lldb_private::TypeResults &type_results) {
15235f757f3fSDimitry Andric 
15245f757f3fSDimitry Andric   // Make sure we haven't already searched this SymbolFile before.
15255f757f3fSDimitry Andric   if (type_results.AlreadySearched(this))
15265f757f3fSDimitry Andric     return;
15275f757f3fSDimitry Andric 
15285f757f3fSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
15295f757f3fSDimitry Andric 
15300b57cec5SDimitry Andric   std::unique_ptr<IPDBEnumSymbols> results;
15315f757f3fSDimitry Andric   llvm::StringRef basename = query.GetTypeBasename().GetStringRef();
15325f757f3fSDimitry Andric   if (basename.empty())
15330b57cec5SDimitry Andric     return;
15340b57cec5SDimitry Andric   results = m_global_scope_up->findAllChildren(PDB_SymType::None);
15350b57cec5SDimitry Andric   if (!results)
15360b57cec5SDimitry Andric     return;
15370b57cec5SDimitry Andric 
15380b57cec5SDimitry Andric   while (auto result = results->getNext()) {
15390b57cec5SDimitry Andric 
15400b57cec5SDimitry Andric     switch (result->getSymTag()) {
15410b57cec5SDimitry Andric     case PDB_SymType::Enum:
15420b57cec5SDimitry Andric     case PDB_SymType::UDT:
15430b57cec5SDimitry Andric     case PDB_SymType::Typedef:
15440b57cec5SDimitry Andric       break;
15450b57cec5SDimitry Andric     default:
15460b57cec5SDimitry Andric       // We're looking only for types that have names.  Skip symbols, as well
15470b57cec5SDimitry Andric       // as unnamed types such as arrays, pointers, etc.
15480b57cec5SDimitry Andric       continue;
15490b57cec5SDimitry Andric     }
15500b57cec5SDimitry Andric 
15515f757f3fSDimitry Andric     if (MSVCUndecoratedNameParser::DropScope(
15525f757f3fSDimitry Andric             result->getRawSymbol().getName()) != basename)
15535f757f3fSDimitry Andric       continue;
15545f757f3fSDimitry Andric 
15550b57cec5SDimitry Andric     // This should cause the type to get cached and stored in the `m_types`
15560b57cec5SDimitry Andric     // lookup.
15570b57cec5SDimitry Andric     if (!ResolveTypeUID(result->getSymIndexId()))
15580b57cec5SDimitry Andric       continue;
15590b57cec5SDimitry Andric 
15600b57cec5SDimitry Andric     auto iter = m_types.find(result->getSymIndexId());
15610b57cec5SDimitry Andric     if (iter == m_types.end())
15620b57cec5SDimitry Andric       continue;
15635f757f3fSDimitry Andric     // We resolved a type. Get the fully qualified name to ensure it matches.
15645f757f3fSDimitry Andric     ConstString name = iter->second->GetQualifiedName();
15655f757f3fSDimitry Andric     TypeQuery type_match(name.GetStringRef(), TypeQueryOptions::e_exact_match);
15665f757f3fSDimitry Andric     if (query.ContextMatches(type_match.GetContextRef())) {
15675f757f3fSDimitry Andric       type_results.InsertUnique(iter->second);
15685f757f3fSDimitry Andric       if (type_results.Done(query))
15695f757f3fSDimitry Andric         return;
15700b57cec5SDimitry Andric     }
15710b57cec5SDimitry Andric   }
15725f757f3fSDimitry Andric }
15730b57cec5SDimitry Andric 
15740b57cec5SDimitry Andric void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
15750b57cec5SDimitry Andric                                          uint32_t type_mask,
15760b57cec5SDimitry Andric                                          TypeCollection &type_collection) {
15770b57cec5SDimitry Andric   bool can_parse = false;
15780b57cec5SDimitry Andric   switch (pdb_symbol.getSymTag()) {
15790b57cec5SDimitry Andric   case PDB_SymType::ArrayType:
15800b57cec5SDimitry Andric     can_parse = ((type_mask & eTypeClassArray) != 0);
15810b57cec5SDimitry Andric     break;
15820b57cec5SDimitry Andric   case PDB_SymType::BuiltinType:
15830b57cec5SDimitry Andric     can_parse = ((type_mask & eTypeClassBuiltin) != 0);
15840b57cec5SDimitry Andric     break;
15850b57cec5SDimitry Andric   case PDB_SymType::Enum:
15860b57cec5SDimitry Andric     can_parse = ((type_mask & eTypeClassEnumeration) != 0);
15870b57cec5SDimitry Andric     break;
15880b57cec5SDimitry Andric   case PDB_SymType::Function:
15890b57cec5SDimitry Andric   case PDB_SymType::FunctionSig:
15900b57cec5SDimitry Andric     can_parse = ((type_mask & eTypeClassFunction) != 0);
15910b57cec5SDimitry Andric     break;
15920b57cec5SDimitry Andric   case PDB_SymType::PointerType:
15930b57cec5SDimitry Andric     can_parse = ((type_mask & (eTypeClassPointer | eTypeClassBlockPointer |
15940b57cec5SDimitry Andric                                eTypeClassMemberPointer)) != 0);
15950b57cec5SDimitry Andric     break;
15960b57cec5SDimitry Andric   case PDB_SymType::Typedef:
15970b57cec5SDimitry Andric     can_parse = ((type_mask & eTypeClassTypedef) != 0);
15980b57cec5SDimitry Andric     break;
15990b57cec5SDimitry Andric   case PDB_SymType::UDT: {
16000b57cec5SDimitry Andric     auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&pdb_symbol);
16010b57cec5SDimitry Andric     assert(udt);
16020b57cec5SDimitry Andric     can_parse = (udt->getUdtKind() != PDB_UdtType::Interface &&
16030b57cec5SDimitry Andric                  ((type_mask & (eTypeClassClass | eTypeClassStruct |
16040b57cec5SDimitry Andric                                 eTypeClassUnion)) != 0));
16050b57cec5SDimitry Andric   } break;
16060b57cec5SDimitry Andric   default:
16070b57cec5SDimitry Andric     break;
16080b57cec5SDimitry Andric   }
16090b57cec5SDimitry Andric 
16100b57cec5SDimitry Andric   if (can_parse) {
16110b57cec5SDimitry Andric     if (auto *type = ResolveTypeUID(pdb_symbol.getSymIndexId())) {
1612bdd1243dSDimitry Andric       if (!llvm::is_contained(type_collection, type))
16130b57cec5SDimitry Andric         type_collection.push_back(type);
16140b57cec5SDimitry Andric     }
16150b57cec5SDimitry Andric   }
16160b57cec5SDimitry Andric 
16170b57cec5SDimitry Andric   auto results_up = pdb_symbol.findAllChildren();
16180b57cec5SDimitry Andric   while (auto symbol_up = results_up->getNext())
16190b57cec5SDimitry Andric     GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
16200b57cec5SDimitry Andric }
16210b57cec5SDimitry Andric 
16229dba64beSDimitry Andric void SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
16230b57cec5SDimitry Andric                              TypeClass type_mask,
16240b57cec5SDimitry Andric                              lldb_private::TypeList &type_list) {
16259dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
16260b57cec5SDimitry Andric   TypeCollection type_collection;
16270b57cec5SDimitry Andric   CompileUnit *cu =
16280b57cec5SDimitry Andric       sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
16290b57cec5SDimitry Andric   if (cu) {
16300b57cec5SDimitry Andric     auto compiland_up = GetPDBCompilandByUID(cu->GetID());
16310b57cec5SDimitry Andric     if (!compiland_up)
16329dba64beSDimitry Andric       return;
16330b57cec5SDimitry Andric     GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
16340b57cec5SDimitry Andric   } else {
16350b57cec5SDimitry Andric     for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
16360b57cec5SDimitry Andric       auto cu_sp = ParseCompileUnitAtIndex(cu_idx);
16370b57cec5SDimitry Andric       if (cu_sp) {
16380b57cec5SDimitry Andric         if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
16390b57cec5SDimitry Andric           GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
16400b57cec5SDimitry Andric       }
16410b57cec5SDimitry Andric     }
16420b57cec5SDimitry Andric   }
16430b57cec5SDimitry Andric 
16440b57cec5SDimitry Andric   for (auto type : type_collection) {
16450b57cec5SDimitry Andric     type->GetForwardCompilerType();
16460b57cec5SDimitry Andric     type_list.Insert(type->shared_from_this());
16470b57cec5SDimitry Andric   }
16480b57cec5SDimitry Andric }
16490b57cec5SDimitry Andric 
1650bdd1243dSDimitry Andric llvm::Expected<lldb::TypeSystemSP>
16510b57cec5SDimitry Andric SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
16529dba64beSDimitry Andric   auto type_system_or_err =
16539dba64beSDimitry Andric       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
16549dba64beSDimitry Andric   if (type_system_or_err) {
1655bdd1243dSDimitry Andric     if (auto ts = *type_system_or_err)
1656bdd1243dSDimitry Andric       ts->SetSymbolFile(this);
16579dba64beSDimitry Andric   }
16589dba64beSDimitry Andric   return type_system_or_err;
16590b57cec5SDimitry Andric }
16600b57cec5SDimitry Andric 
16610b57cec5SDimitry Andric PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
16629dba64beSDimitry Andric   auto type_system_or_err =
16639dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
16649dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
166581ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
166606c3fb27SDimitry Andric                    "Unable to get PDB AST parser: {0}");
16679dba64beSDimitry Andric     return nullptr;
16689dba64beSDimitry Andric   }
16699dba64beSDimitry Andric 
1670bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
16719dba64beSDimitry Andric   auto *clang_type_system =
1672bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
16730b57cec5SDimitry Andric   if (!clang_type_system)
16740b57cec5SDimitry Andric     return nullptr;
16750b57cec5SDimitry Andric 
16760b57cec5SDimitry Andric   return clang_type_system->GetPDBParser();
16770b57cec5SDimitry Andric }
16780b57cec5SDimitry Andric 
16795ffd83dbSDimitry Andric lldb_private::CompilerDeclContext
16805ffd83dbSDimitry Andric SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
168106c3fb27SDimitry Andric                              const CompilerDeclContext &parent_decl_ctx, bool) {
16829dba64beSDimitry Andric   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
16839dba64beSDimitry Andric   auto type_system_or_err =
16849dba64beSDimitry Andric       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
16859dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
168681ad6265SDimitry Andric     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
168706c3fb27SDimitry Andric                    "Unable to find namespace {1}: {0}", name.AsCString());
16889dba64beSDimitry Andric     return CompilerDeclContext();
16899dba64beSDimitry Andric   }
1690bdd1243dSDimitry Andric   auto ts = *type_system_or_err;
16919dba64beSDimitry Andric   auto *clang_type_system =
1692bdd1243dSDimitry Andric       llvm::dyn_cast_or_null<TypeSystemClang>(ts.get());
16930b57cec5SDimitry Andric   if (!clang_type_system)
16940b57cec5SDimitry Andric     return CompilerDeclContext();
16950b57cec5SDimitry Andric 
16960b57cec5SDimitry Andric   PDBASTParser *pdb = clang_type_system->GetPDBParser();
16970b57cec5SDimitry Andric   if (!pdb)
16980b57cec5SDimitry Andric     return CompilerDeclContext();
16990b57cec5SDimitry Andric 
17000b57cec5SDimitry Andric   clang::DeclContext *decl_context = nullptr;
17010b57cec5SDimitry Andric   if (parent_decl_ctx)
17020b57cec5SDimitry Andric     decl_context = static_cast<clang::DeclContext *>(
17035ffd83dbSDimitry Andric         parent_decl_ctx.GetOpaqueDeclContext());
17040b57cec5SDimitry Andric 
17050b57cec5SDimitry Andric   auto namespace_decl =
17060b57cec5SDimitry Andric       pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
17070b57cec5SDimitry Andric   if (!namespace_decl)
17080b57cec5SDimitry Andric     return CompilerDeclContext();
17090b57cec5SDimitry Andric 
1710480093f4SDimitry Andric   return clang_type_system->CreateDeclContext(namespace_decl);
17110b57cec5SDimitry Andric }
17120b57cec5SDimitry Andric 
17130b57cec5SDimitry Andric IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }
17140b57cec5SDimitry Andric 
17150b57cec5SDimitry Andric const IPDBSession &SymbolFilePDB::GetPDBSession() const {
17160b57cec5SDimitry Andric   return *m_session_up;
17170b57cec5SDimitry Andric }
17180b57cec5SDimitry Andric 
17190b57cec5SDimitry Andric lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
17200b57cec5SDimitry Andric                                                        uint32_t index) {
17210b57cec5SDimitry Andric   auto found_cu = m_comp_units.find(id);
17220b57cec5SDimitry Andric   if (found_cu != m_comp_units.end())
17230b57cec5SDimitry Andric     return found_cu->second;
17240b57cec5SDimitry Andric 
17250b57cec5SDimitry Andric   auto compiland_up = GetPDBCompilandByUID(id);
17260b57cec5SDimitry Andric   if (!compiland_up)
17270b57cec5SDimitry Andric     return CompUnitSP();
17280b57cec5SDimitry Andric 
17290b57cec5SDimitry Andric   lldb::LanguageType lang;
17300b57cec5SDimitry Andric   auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
17310b57cec5SDimitry Andric   if (!details)
17320b57cec5SDimitry Andric     lang = lldb::eLanguageTypeC_plus_plus;
17330b57cec5SDimitry Andric   else
17340b57cec5SDimitry Andric     lang = TranslateLanguage(details->getLanguage());
17350b57cec5SDimitry Andric 
17360b57cec5SDimitry Andric   if (lang == lldb::LanguageType::eLanguageTypeUnknown)
17370b57cec5SDimitry Andric     return CompUnitSP();
17380b57cec5SDimitry Andric 
17390b57cec5SDimitry Andric   std::string path = compiland_up->getSourceFileFullPath();
17400b57cec5SDimitry Andric   if (path.empty())
17410b57cec5SDimitry Andric     return CompUnitSP();
17420b57cec5SDimitry Andric 
17430b57cec5SDimitry Andric   // Don't support optimized code for now, DebugInfoPDB does not return this
17440b57cec5SDimitry Andric   // information.
17450b57cec5SDimitry Andric   LazyBool optimized = eLazyBoolNo;
17469dba64beSDimitry Andric   auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
17470b57cec5SDimitry Andric                                              path.c_str(), id, lang, optimized);
17480b57cec5SDimitry Andric 
17490b57cec5SDimitry Andric   if (!cu_sp)
17500b57cec5SDimitry Andric     return CompUnitSP();
17510b57cec5SDimitry Andric 
17520b57cec5SDimitry Andric   m_comp_units.insert(std::make_pair(id, cu_sp));
17530b57cec5SDimitry Andric   if (index == UINT32_MAX)
17540b57cec5SDimitry Andric     GetCompileUnitIndex(*compiland_up, index);
17550b57cec5SDimitry Andric   lldbassert(index != UINT32_MAX);
17569dba64beSDimitry Andric   SetCompileUnitAtIndex(index, cu_sp);
17570b57cec5SDimitry Andric   return cu_sp;
17580b57cec5SDimitry Andric }
17590b57cec5SDimitry Andric 
17600b57cec5SDimitry Andric bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
17610b57cec5SDimitry Andric                                               uint32_t match_line) {
17620b57cec5SDimitry Andric   auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
17630b57cec5SDimitry Andric   if (!compiland_up)
17640b57cec5SDimitry Andric     return false;
17650b57cec5SDimitry Andric 
17660b57cec5SDimitry Andric   // LineEntry needs the *index* of the file into the list of support files
17670b57cec5SDimitry Andric   // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
17680b57cec5SDimitry Andric   // a globally unique idenfitifier in the namespace of the PDB.  So, we have
17690b57cec5SDimitry Andric   // to do a mapping so that we can hand out indices.
17700b57cec5SDimitry Andric   llvm::DenseMap<uint32_t, uint32_t> index_map;
17710b57cec5SDimitry Andric   BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
17729dba64beSDimitry Andric   auto line_table = std::make_unique<LineTable>(&comp_unit);
17730b57cec5SDimitry Andric 
17740b57cec5SDimitry Andric   // Find contributions to `compiland` from all source and header files.
17750b57cec5SDimitry Andric   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
17760b57cec5SDimitry Andric   if (!files)
17770b57cec5SDimitry Andric     return false;
17780b57cec5SDimitry Andric 
17790b57cec5SDimitry Andric   // For each source and header file, create a LineSequence for contributions
17800b57cec5SDimitry Andric   // to the compiland from that file, and add the sequence.
17810b57cec5SDimitry Andric   while (auto file = files->getNext()) {
17820b57cec5SDimitry Andric     std::unique_ptr<LineSequence> sequence(
17830b57cec5SDimitry Andric         line_table->CreateLineSequenceContainer());
17840b57cec5SDimitry Andric     auto lines = m_session_up->findLineNumbers(*compiland_up, *file);
17850b57cec5SDimitry Andric     if (!lines)
17860b57cec5SDimitry Andric       continue;
17870b57cec5SDimitry Andric     int entry_count = lines->getChildCount();
17880b57cec5SDimitry Andric 
17890b57cec5SDimitry Andric     uint64_t prev_addr;
17900b57cec5SDimitry Andric     uint32_t prev_length;
17910b57cec5SDimitry Andric     uint32_t prev_line;
17920b57cec5SDimitry Andric     uint32_t prev_source_idx;
17930b57cec5SDimitry Andric 
17940b57cec5SDimitry Andric     for (int i = 0; i < entry_count; ++i) {
17950b57cec5SDimitry Andric       auto line = lines->getChildAtIndex(i);
17960b57cec5SDimitry Andric 
17970b57cec5SDimitry Andric       uint64_t lno = line->getLineNumber();
17980b57cec5SDimitry Andric       uint64_t addr = line->getVirtualAddress();
17990b57cec5SDimitry Andric       uint32_t length = line->getLength();
18000b57cec5SDimitry Andric       uint32_t source_id = line->getSourceFileId();
18010b57cec5SDimitry Andric       uint32_t col = line->getColumnNumber();
18020b57cec5SDimitry Andric       uint32_t source_idx = index_map[source_id];
18030b57cec5SDimitry Andric 
18040b57cec5SDimitry Andric       // There was a gap between the current entry and the previous entry if
18050b57cec5SDimitry Andric       // the addresses don't perfectly line up.
18060b57cec5SDimitry Andric       bool is_gap = (i > 0) && (prev_addr + prev_length < addr);
18070b57cec5SDimitry Andric 
18080b57cec5SDimitry Andric       // Before inserting the current entry, insert a terminal entry at the end
18090b57cec5SDimitry Andric       // of the previous entry's address range if the current entry resulted in
18100b57cec5SDimitry Andric       // a gap from the previous entry.
18110b57cec5SDimitry Andric       if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) {
18120b57cec5SDimitry Andric         line_table->AppendLineEntryToSequence(
18130b57cec5SDimitry Andric             sequence.get(), prev_addr + prev_length, prev_line, 0,
18140b57cec5SDimitry Andric             prev_source_idx, false, false, false, false, true);
18150b57cec5SDimitry Andric 
1816fe6060f1SDimitry Andric         line_table->InsertSequence(sequence.get());
18175ffd83dbSDimitry Andric         sequence = line_table->CreateLineSequenceContainer();
18180b57cec5SDimitry Andric       }
18190b57cec5SDimitry Andric 
18200b57cec5SDimitry Andric       if (ShouldAddLine(match_line, lno, length)) {
18210b57cec5SDimitry Andric         bool is_statement = line->isStatement();
18220b57cec5SDimitry Andric         bool is_prologue = false;
18230b57cec5SDimitry Andric         bool is_epilogue = false;
18240b57cec5SDimitry Andric         auto func =
18250b57cec5SDimitry Andric             m_session_up->findSymbolByAddress(addr, PDB_SymType::Function);
18260b57cec5SDimitry Andric         if (func) {
18270b57cec5SDimitry Andric           auto prologue = func->findOneChild<PDBSymbolFuncDebugStart>();
18280b57cec5SDimitry Andric           if (prologue)
18290b57cec5SDimitry Andric             is_prologue = (addr == prologue->getVirtualAddress());
18300b57cec5SDimitry Andric 
18310b57cec5SDimitry Andric           auto epilogue = func->findOneChild<PDBSymbolFuncDebugEnd>();
18320b57cec5SDimitry Andric           if (epilogue)
18330b57cec5SDimitry Andric             is_epilogue = (addr == epilogue->getVirtualAddress());
18340b57cec5SDimitry Andric         }
18350b57cec5SDimitry Andric 
18360b57cec5SDimitry Andric         line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
18370b57cec5SDimitry Andric                                               source_idx, is_statement, false,
18380b57cec5SDimitry Andric                                               is_prologue, is_epilogue, false);
18390b57cec5SDimitry Andric       }
18400b57cec5SDimitry Andric 
18410b57cec5SDimitry Andric       prev_addr = addr;
18420b57cec5SDimitry Andric       prev_length = length;
18430b57cec5SDimitry Andric       prev_line = lno;
18440b57cec5SDimitry Andric       prev_source_idx = source_idx;
18450b57cec5SDimitry Andric     }
18460b57cec5SDimitry Andric 
18470b57cec5SDimitry Andric     if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
18480b57cec5SDimitry Andric       // The end is always a terminal entry, so insert it regardless.
18490b57cec5SDimitry Andric       line_table->AppendLineEntryToSequence(
18500b57cec5SDimitry Andric           sequence.get(), prev_addr + prev_length, prev_line, 0,
18510b57cec5SDimitry Andric           prev_source_idx, false, false, false, false, true);
18520b57cec5SDimitry Andric     }
18530b57cec5SDimitry Andric 
18545ffd83dbSDimitry Andric     line_table->InsertSequence(sequence.get());
18550b57cec5SDimitry Andric   }
18560b57cec5SDimitry Andric 
18570b57cec5SDimitry Andric   if (line_table->GetSize()) {
18580b57cec5SDimitry Andric     comp_unit.SetLineTable(line_table.release());
18590b57cec5SDimitry Andric     return true;
18600b57cec5SDimitry Andric   }
18610b57cec5SDimitry Andric   return false;
18620b57cec5SDimitry Andric }
18630b57cec5SDimitry Andric 
18640b57cec5SDimitry Andric void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
18650b57cec5SDimitry Andric     const PDBSymbolCompiland &compiland,
18660b57cec5SDimitry Andric     llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
18670b57cec5SDimitry Andric   // This is a hack, but we need to convert the source id into an index into
18680b57cec5SDimitry Andric   // the support files array.  We don't want to do path comparisons to avoid
18690b57cec5SDimitry Andric   // basename / full path issues that may or may not even be a problem, so we
18700b57cec5SDimitry Andric   // use the globally unique source file identifiers.  Ideally we could use the
18710b57cec5SDimitry Andric   // global identifiers everywhere, but LineEntry currently assumes indices.
18720b57cec5SDimitry Andric   auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
18730b57cec5SDimitry Andric   if (!source_files)
18740b57cec5SDimitry Andric     return;
18750b57cec5SDimitry Andric 
1876480093f4SDimitry Andric   int index = 0;
18770b57cec5SDimitry Andric   while (auto file = source_files->getNext()) {
18780b57cec5SDimitry Andric     uint32_t source_id = file->getUniqueId();
18790b57cec5SDimitry Andric     index_map[source_id] = index++;
18800b57cec5SDimitry Andric   }
18810b57cec5SDimitry Andric }
18820b57cec5SDimitry Andric 
18830b57cec5SDimitry Andric lldb::CompUnitSP SymbolFilePDB::GetCompileUnitContainsAddress(
18840b57cec5SDimitry Andric     const lldb_private::Address &so_addr) {
18850b57cec5SDimitry Andric   lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
18860b57cec5SDimitry Andric   if (file_vm_addr == LLDB_INVALID_ADDRESS || file_vm_addr == 0)
18870b57cec5SDimitry Andric     return nullptr;
18880b57cec5SDimitry Andric 
18890b57cec5SDimitry Andric   // If it is a PDB function's vm addr, this is the first sure bet.
18900b57cec5SDimitry Andric   if (auto lines =
18910b57cec5SDimitry Andric           m_session_up->findLineNumbersByAddress(file_vm_addr, /*Length=*/1)) {
18920b57cec5SDimitry Andric     if (auto first_line = lines->getNext())
18930b57cec5SDimitry Andric       return ParseCompileUnitForUID(first_line->getCompilandId());
18940b57cec5SDimitry Andric   }
18950b57cec5SDimitry Andric 
18960b57cec5SDimitry Andric   // Otherwise we resort to section contributions.
18970b57cec5SDimitry Andric   if (auto sec_contribs = m_session_up->getSectionContribs()) {
18980b57cec5SDimitry Andric     while (auto section = sec_contribs->getNext()) {
18990b57cec5SDimitry Andric       auto va = section->getVirtualAddress();
19000b57cec5SDimitry Andric       if (file_vm_addr >= va && file_vm_addr < va + section->getLength())
19010b57cec5SDimitry Andric         return ParseCompileUnitForUID(section->getCompilandId());
19020b57cec5SDimitry Andric     }
19030b57cec5SDimitry Andric   }
19040b57cec5SDimitry Andric   return nullptr;
19050b57cec5SDimitry Andric }
19060b57cec5SDimitry Andric 
19070b57cec5SDimitry Andric Mangled
19080b57cec5SDimitry Andric SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
19090b57cec5SDimitry Andric   Mangled mangled;
19100b57cec5SDimitry Andric   auto func_name = pdb_func.getName();
19110b57cec5SDimitry Andric   auto func_undecorated_name = pdb_func.getUndecoratedName();
19120b57cec5SDimitry Andric   std::string func_decorated_name;
19130b57cec5SDimitry Andric 
19140b57cec5SDimitry Andric   // Seek from public symbols for non-static function's decorated name if any.
19150b57cec5SDimitry Andric   // For static functions, they don't have undecorated names and aren't exposed
19160b57cec5SDimitry Andric   // in Public Symbols either.
19170b57cec5SDimitry Andric   if (!func_undecorated_name.empty()) {
19180b57cec5SDimitry Andric     auto result_up = m_global_scope_up->findChildren(
19190b57cec5SDimitry Andric         PDB_SymType::PublicSymbol, func_undecorated_name,
19200b57cec5SDimitry Andric         PDB_NameSearchFlags::NS_UndecoratedName);
19210b57cec5SDimitry Andric     if (result_up) {
19220b57cec5SDimitry Andric       while (auto symbol_up = result_up->getNext()) {
19230b57cec5SDimitry Andric         // For a public symbol, it is unique.
19240b57cec5SDimitry Andric         lldbassert(result_up->getChildCount() == 1);
19250b57cec5SDimitry Andric         if (auto *pdb_public_sym =
19260b57cec5SDimitry Andric                 llvm::dyn_cast_or_null<PDBSymbolPublicSymbol>(
19270b57cec5SDimitry Andric                     symbol_up.get())) {
19280b57cec5SDimitry Andric           if (pdb_public_sym->isFunction()) {
19290b57cec5SDimitry Andric             func_decorated_name = pdb_public_sym->getName();
19300b57cec5SDimitry Andric             break;
19310b57cec5SDimitry Andric           }
19320b57cec5SDimitry Andric         }
19330b57cec5SDimitry Andric       }
19340b57cec5SDimitry Andric     }
19350b57cec5SDimitry Andric   }
19360b57cec5SDimitry Andric   if (!func_decorated_name.empty()) {
19370b57cec5SDimitry Andric     mangled.SetMangledName(ConstString(func_decorated_name));
19380b57cec5SDimitry Andric 
1939bdd1243dSDimitry Andric     // For MSVC, format of C function's decorated name depends on calling
19405ffd83dbSDimitry Andric     // convention. Unfortunately none of the format is recognized by current
19410b57cec5SDimitry Andric     // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
19420b57cec5SDimitry Andric     // `__purecall` is retrieved as both its decorated and undecorated name
19430b57cec5SDimitry Andric     // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
19440b57cec5SDimitry Andric     // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
19450b57cec5SDimitry Andric     // Mangled::GetDemangledName method will fail internally and caches an
19465ffd83dbSDimitry Andric     // empty string as its undecorated name. So we will face a contradiction
19470b57cec5SDimitry Andric     // here for the same symbol:
19480b57cec5SDimitry Andric     //   non-empty undecorated name from PDB
19490b57cec5SDimitry Andric     //   empty undecorated name from LLDB
19505ffd83dbSDimitry Andric     if (!func_undecorated_name.empty() && mangled.GetDemangledName().IsEmpty())
19510b57cec5SDimitry Andric       mangled.SetDemangledName(ConstString(func_undecorated_name));
19520b57cec5SDimitry Andric 
19530b57cec5SDimitry Andric     // LLDB uses several flags to control how a C++ decorated name is
19540b57cec5SDimitry Andric     // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So the
19550b57cec5SDimitry Andric     // yielded name could be different from what we retrieve from
19560b57cec5SDimitry Andric     // PDB source unless we also apply same flags in getting undecorated
19570b57cec5SDimitry Andric     // name through PDBSymbolFunc::getUndecoratedNameEx method.
19580b57cec5SDimitry Andric     if (!func_undecorated_name.empty() &&
19595ffd83dbSDimitry Andric         mangled.GetDemangledName() != ConstString(func_undecorated_name))
19600b57cec5SDimitry Andric       mangled.SetDemangledName(ConstString(func_undecorated_name));
19610b57cec5SDimitry Andric   } else if (!func_undecorated_name.empty()) {
19620b57cec5SDimitry Andric     mangled.SetDemangledName(ConstString(func_undecorated_name));
19630b57cec5SDimitry Andric   } else if (!func_name.empty())
196406c3fb27SDimitry Andric     mangled.SetValue(ConstString(func_name));
19650b57cec5SDimitry Andric 
19660b57cec5SDimitry Andric   return mangled;
19670b57cec5SDimitry Andric }
19680b57cec5SDimitry Andric 
19690b57cec5SDimitry Andric bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
19705ffd83dbSDimitry Andric     const lldb_private::CompilerDeclContext &decl_ctx) {
19715ffd83dbSDimitry Andric   if (!decl_ctx.IsValid())
19720b57cec5SDimitry Andric     return true;
19730b57cec5SDimitry Andric 
19745ffd83dbSDimitry Andric   TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
19750b57cec5SDimitry Andric   if (!decl_ctx_type_system)
19760b57cec5SDimitry Andric     return false;
19779dba64beSDimitry Andric   auto type_system_or_err = GetTypeSystemForLanguage(
19780b57cec5SDimitry Andric       decl_ctx_type_system->GetMinimumLanguage(nullptr));
19799dba64beSDimitry Andric   if (auto err = type_system_or_err.takeError()) {
19809dba64beSDimitry Andric     LLDB_LOG_ERROR(
198181ad6265SDimitry Andric         GetLog(LLDBLog::Symbols), std::move(err),
198206c3fb27SDimitry Andric         "Unable to determine if DeclContext matches this symbol file: {0}");
19839dba64beSDimitry Andric     return false;
19849dba64beSDimitry Andric   }
19859dba64beSDimitry Andric 
1986bdd1243dSDimitry Andric   if (decl_ctx_type_system == type_system_or_err->get())
19870b57cec5SDimitry Andric     return true; // The type systems match, return true
19880b57cec5SDimitry Andric 
19890b57cec5SDimitry Andric   return false;
19900b57cec5SDimitry Andric }
19910b57cec5SDimitry Andric 
19920b57cec5SDimitry Andric uint32_t SymbolFilePDB::GetCompilandId(const llvm::pdb::PDBSymbolData &data) {
19930b57cec5SDimitry Andric   static const auto pred_upper = [](uint32_t lhs, SecContribInfo rhs) {
19940b57cec5SDimitry Andric     return lhs < rhs.Offset;
19950b57cec5SDimitry Andric   };
19960b57cec5SDimitry Andric 
19970b57cec5SDimitry Andric   // Cache section contributions
19980b57cec5SDimitry Andric   if (m_sec_contribs.empty()) {
19990b57cec5SDimitry Andric     if (auto SecContribs = m_session_up->getSectionContribs()) {
20000b57cec5SDimitry Andric       while (auto SectionContrib = SecContribs->getNext()) {
20010b57cec5SDimitry Andric         auto comp_id = SectionContrib->getCompilandId();
20020b57cec5SDimitry Andric         if (!comp_id)
20030b57cec5SDimitry Andric           continue;
20040b57cec5SDimitry Andric 
20050b57cec5SDimitry Andric         auto sec = SectionContrib->getAddressSection();
20060b57cec5SDimitry Andric         auto &sec_cs = m_sec_contribs[sec];
20070b57cec5SDimitry Andric 
20080b57cec5SDimitry Andric         auto offset = SectionContrib->getAddressOffset();
2009bdd1243dSDimitry Andric         auto it = llvm::upper_bound(sec_cs, offset, pred_upper);
20100b57cec5SDimitry Andric 
20110b57cec5SDimitry Andric         auto size = SectionContrib->getLength();
20120b57cec5SDimitry Andric         sec_cs.insert(it, {offset, size, comp_id});
20130b57cec5SDimitry Andric       }
20140b57cec5SDimitry Andric     }
20150b57cec5SDimitry Andric   }
20160b57cec5SDimitry Andric 
20170b57cec5SDimitry Andric   // Check by line number
20180b57cec5SDimitry Andric   if (auto Lines = data.getLineNumbers()) {
20190b57cec5SDimitry Andric     if (auto FirstLine = Lines->getNext())
20200b57cec5SDimitry Andric       return FirstLine->getCompilandId();
20210b57cec5SDimitry Andric   }
20220b57cec5SDimitry Andric 
20230b57cec5SDimitry Andric   // Retrieve section + offset
20240b57cec5SDimitry Andric   uint32_t DataSection = data.getAddressSection();
20250b57cec5SDimitry Andric   uint32_t DataOffset = data.getAddressOffset();
20260b57cec5SDimitry Andric   if (DataSection == 0) {
20270b57cec5SDimitry Andric     if (auto RVA = data.getRelativeVirtualAddress())
20280b57cec5SDimitry Andric       m_session_up->addressForRVA(RVA, DataSection, DataOffset);
20290b57cec5SDimitry Andric   }
20300b57cec5SDimitry Andric 
20310b57cec5SDimitry Andric   if (DataSection) {
20320b57cec5SDimitry Andric     // Search by section contributions
20330b57cec5SDimitry Andric     auto &sec_cs = m_sec_contribs[DataSection];
2034bdd1243dSDimitry Andric     auto it = llvm::upper_bound(sec_cs, DataOffset, pred_upper);
20350b57cec5SDimitry Andric     if (it != sec_cs.begin()) {
20360b57cec5SDimitry Andric       --it;
20370b57cec5SDimitry Andric       if (DataOffset < it->Offset + it->Size)
20380b57cec5SDimitry Andric         return it->CompilandId;
20390b57cec5SDimitry Andric     }
20400b57cec5SDimitry Andric   } else {
20410b57cec5SDimitry Andric     // Search in lexical tree
20420b57cec5SDimitry Andric     auto LexParentId = data.getLexicalParentId();
20430b57cec5SDimitry Andric     while (auto LexParent = m_session_up->getSymbolById(LexParentId)) {
20440b57cec5SDimitry Andric       if (LexParent->getSymTag() == PDB_SymType::Exe)
20450b57cec5SDimitry Andric         break;
20460b57cec5SDimitry Andric       if (LexParent->getSymTag() == PDB_SymType::Compiland)
20470b57cec5SDimitry Andric         return LexParentId;
20480b57cec5SDimitry Andric       LexParentId = LexParent->getRawSymbol().getLexicalParentId();
20490b57cec5SDimitry Andric     }
20500b57cec5SDimitry Andric   }
20510b57cec5SDimitry Andric 
20520b57cec5SDimitry Andric   return 0;
20530b57cec5SDimitry Andric }
2054