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 ®ex, 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 ®ex, 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 = [®ex, 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 ®ex, 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