diff --git a/lldb/lit/SymbolFile/PDB/Inputs/CompilandsTest.cpp b/lldb/lit/SymbolFile/PDB/Inputs/CompilandsTest.cpp new file mode 100644 index 000000000000..4cce7f667ff7 --- /dev/null +++ b/lldb/lit/SymbolFile/PDB/Inputs/CompilandsTest.cpp @@ -0,0 +1,3 @@ +int main() { + return 0; +} diff --git a/lldb/lit/SymbolFile/PDB/compilands.test b/lldb/lit/SymbolFile/PDB/compilands.test new file mode 100644 index 000000000000..2e7b014fe966 --- /dev/null +++ b/lldb/lit/SymbolFile/PDB/compilands.test @@ -0,0 +1,9 @@ +REQUIRES: windows +RUN: clang-cl /Z7 %S/Inputs/CompilandsTest.cpp /o %T/CompilandsTest.cpp.exe +RUN: lldb-test symbols %T/CompilandsTest.cpp.exe | FileCheck %s + +; Link default libraries + +CHECK: Module [[CU:.*]] +CHECK: {{^[0-9A-F]+}}: SymbolVendor ([[CU]]) +CHECK: {{^[0-9A-F]+}}: CompileUnit{{[{]0x[0-9a-f]+[}]}}, language = "c++", file = '{{.*}}\CompilandsTest.cpp' diff --git a/lldb/lit/SymbolFile/PDB/lit.local.cfg b/lldb/lit/SymbolFile/PDB/lit.local.cfg new file mode 100644 index 000000000000..df9b335dd131 --- /dev/null +++ b/lldb/lit/SymbolFile/PDB/lit.local.cfg @@ -0,0 +1 @@ +config.suffixes = ['.test'] diff --git a/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp b/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp index 7802d6f0d859..266804e8534c 100644 --- a/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp +++ b/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp @@ -1,238 +1,236 @@ //===-- PDBASTParser.cpp ----------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "PDBASTParser.h" #include "clang/AST/CharUnits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangUtil.h" #include "lldb/Symbol/Declaration.h" #include "lldb/Symbol/SymbolFile.h" #include "lldb/Symbol/TypeSystem.h" #include "llvm/DebugInfo/PDB/PDBSymbol.h" #include "llvm/DebugInfo/PDB/PDBSymbolData.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h" using namespace lldb; using namespace lldb_private; using namespace llvm; using namespace llvm::pdb; namespace { int TranslateUdtKind(PDB_UdtType pdb_kind) { switch (pdb_kind) { case PDB_UdtType::Class: return clang::TTK_Class; case PDB_UdtType::Struct: return clang::TTK_Struct; case PDB_UdtType::Union: return clang::TTK_Union; case PDB_UdtType::Interface: return clang::TTK_Interface; } return clang::TTK_Class; } lldb::Encoding TranslateBuiltinEncoding(PDB_BuiltinType type) { switch (type) { case PDB_BuiltinType::Float: return lldb::eEncodingIEEE754; case PDB_BuiltinType::Int: case PDB_BuiltinType::Long: case PDB_BuiltinType::Char: return lldb::eEncodingSint; case PDB_BuiltinType::Bool: case PDB_BuiltinType::UInt: case PDB_BuiltinType::ULong: case PDB_BuiltinType::HResult: return lldb::eEncodingUint; default: return lldb::eEncodingInvalid; } } } PDBASTParser::PDBASTParser(lldb_private::ClangASTContext &ast) : m_ast(ast) {} PDBASTParser::~PDBASTParser() {} // DebugInfoASTParser interface lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) { // PDB doesn't maintain enough information to robustly rebuild the entire // tree, and this is most problematic when it comes to figure out the // right DeclContext to put a type in. So for now, everything goes in // the translation unit decl as a fully qualified type. clang::DeclContext *tu_decl_ctx = m_ast.GetTranslationUnitDecl(); Declaration decl; if (auto udt = llvm::dyn_cast(&type)) { AccessType access = lldb::eAccessPublic; PDB_UdtType udt_kind = udt->getUdtKind(); if (udt_kind == PDB_UdtType::Class) access = lldb::eAccessPrivate; CompilerType clang_type = m_ast.CreateRecordType( tu_decl_ctx, access, udt->getName().c_str(), TranslateUdtKind(udt_kind), lldb::eLanguageTypeC_plus_plus, nullptr); m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true); return std::make_shared( type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(udt->getName()), udt->getLength(), nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, clang_type, lldb_private::Type::eResolveStateForward); } else if (auto enum_type = llvm::dyn_cast(&type)) { std::string name = enum_type->getName(); lldb::Encoding encoding = TranslateBuiltinEncoding(enum_type->getBuiltinType()); uint64_t bytes = enum_type->getLength(); CompilerType builtin_type = m_ast.GetBuiltinTypeForEncodingAndBitSize(encoding, bytes * 8); CompilerType ast_enum = m_ast.CreateEnumerationType( name.c_str(), tu_decl_ctx, decl, builtin_type, false); auto enum_values = enum_type->findAllChildren(); while (auto enum_value = enum_values->getNext()) { if (enum_value->getDataKind() != PDB_DataKind::Constant) continue; AddEnumValue(ast_enum, *enum_value); } return std::make_shared( type.getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, ast_enum, lldb_private::Type::eResolveStateFull); } else if (auto type_def = llvm::dyn_cast(&type)) { lldb_private::Type *target_type = m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId()); if (!target_type) return nullptr; std::string name = type_def->getName(); uint64_t bytes = type_def->getLength(); - if (!target_type) - return nullptr; CompilerType target_ast_type = target_type->GetFullCompilerType(); CompilerDeclContext target_decl_ctx = m_ast.GetSymbolFile()->GetDeclContextForUID(target_type->GetID()); CompilerType ast_typedef = m_ast.CreateTypedefType(target_ast_type, name.c_str(), target_decl_ctx); return std::make_shared( type_def->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(name), bytes, nullptr, target_type->GetID(), lldb_private::Type::eEncodingIsTypedefUID, decl, ast_typedef, lldb_private::Type::eResolveStateFull); } else if (auto func_sig = llvm::dyn_cast(&type)) { auto arg_enum = func_sig->getArguments(); uint32_t num_args = arg_enum->getChildCount(); std::vector arg_list(num_args); while (auto arg = arg_enum->getNext()) { lldb_private::Type *arg_type = m_ast.GetSymbolFile()->ResolveTypeUID(arg->getSymIndexId()); // If there's some error looking up one of the dependent types of this // function signature, bail. if (!arg_type) return nullptr; CompilerType arg_ast_type = arg_type->GetFullCompilerType(); arg_list.push_back(arg_ast_type); } auto pdb_return_type = func_sig->getReturnType(); lldb_private::Type *return_type = m_ast.GetSymbolFile()->ResolveTypeUID(pdb_return_type->getSymIndexId()); // If there's some error looking up one of the dependent types of this // function signature, bail. if (!return_type) return nullptr; CompilerType return_ast_type = return_type->GetFullCompilerType(); uint32_t type_quals = 0; if (func_sig->isConstType()) type_quals |= clang::Qualifiers::Const; if (func_sig->isVolatileType()) type_quals |= clang::Qualifiers::Volatile; CompilerType func_sig_ast_type = m_ast.CreateFunctionType( return_ast_type, &arg_list[0], num_args, false, type_quals); return std::make_shared( func_sig->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), 0, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, func_sig_ast_type, lldb_private::Type::eResolveStateFull); } else if (auto array_type = llvm::dyn_cast(&type)) { uint32_t num_elements = array_type->getCount(); uint32_t element_uid = array_type->getElementType()->getSymIndexId(); uint32_t bytes = array_type->getLength(); lldb_private::Type *element_type = m_ast.GetSymbolFile()->ResolveTypeUID(element_uid); if (!element_type) return nullptr; CompilerType element_ast_type = element_type->GetFullCompilerType(); CompilerType array_ast_type = m_ast.CreateArrayType(element_ast_type, num_elements, false); return std::make_shared( array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(), bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID, decl, array_ast_type, lldb_private::Type::eResolveStateFull); } return nullptr; } bool PDBASTParser::AddEnumValue(CompilerType enum_type, const PDBSymbolData &enum_value) const { Declaration decl; Variant v = enum_value.getValue(); std::string name = enum_value.getName(); int64_t raw_value; switch (v.Type) { case PDB_VariantType::Int8: raw_value = v.Value.Int8; break; case PDB_VariantType::Int16: raw_value = v.Value.Int16; break; case PDB_VariantType::Int32: raw_value = v.Value.Int32; break; case PDB_VariantType::Int64: raw_value = v.Value.Int64; break; case PDB_VariantType::UInt8: raw_value = v.Value.UInt8; break; case PDB_VariantType::UInt16: raw_value = v.Value.UInt16; break; case PDB_VariantType::UInt32: raw_value = v.Value.UInt32; break; case PDB_VariantType::UInt64: raw_value = v.Value.UInt64; break; default: return false; } CompilerType underlying_type = m_ast.GetEnumerationIntegerType(enum_type.GetOpaqueQualType()); uint32_t byte_size = m_ast.getASTContext()->getTypeSize( ClangUtil::GetQualType(underlying_type)); return m_ast.AddEnumerationValueToEnumerationType( enum_type.GetOpaqueQualType(), underlying_type, decl, name.c_str(), raw_value, byte_size * 8); } diff --git a/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp b/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp index de9b9f024fc7..ee0f8a1967ce 100644 --- a/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp +++ b/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp @@ -1,716 +1,848 @@ //===-- SymbolFilePDB.cpp ---------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "SymbolFilePDB.h" #include "clang/Lex/Lexer.h" #include "lldb/Core/Module.h" #include "lldb/Core/PluginManager.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/CompileUnit.h" #include "lldb/Symbol/LineTable.h" #include "lldb/Symbol/ObjectFile.h" #include "lldb/Symbol/SymbolContext.h" +#include "lldb/Symbol/SymbolVendor.h" #include "lldb/Symbol/TypeMap.h" #include "lldb/Utility/RegularExpression.h" #include "llvm/DebugInfo/PDB/GenericError.h" #include "llvm/DebugInfo/PDB/IPDBDataStream.h" #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h" #include "llvm/DebugInfo/PDB/IPDBLineNumber.h" #include "llvm/DebugInfo/PDB/IPDBSourceFile.h" #include "llvm/DebugInfo/PDB/IPDBTable.h" #include "llvm/DebugInfo/PDB/PDBSymbol.h" #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h" #include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h" #include "llvm/DebugInfo/PDB/PDBSymbolData.h" #include "llvm/DebugInfo/PDB/PDBSymbolExe.h" #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h" #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h" #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h" #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h" #include "Plugins/SymbolFile/PDB/PDBASTParser.h" #include +using namespace lldb; using namespace lldb_private; using namespace llvm::pdb; namespace { lldb::LanguageType TranslateLanguage(PDB_Lang lang) { switch (lang) { case PDB_Lang::Cpp: return lldb::LanguageType::eLanguageTypeC_plus_plus; case PDB_Lang::C: return lldb::LanguageType::eLanguageTypeC; default: return lldb::LanguageType::eLanguageTypeUnknown; } } bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line, uint32_t addr_length) { return ((requested_line == 0 || actual_line == requested_line) && addr_length > 0); } } void SymbolFilePDB::Initialize() { PluginManager::RegisterPlugin(GetPluginNameStatic(), GetPluginDescriptionStatic(), CreateInstance, DebuggerInitialize); } void SymbolFilePDB::Terminate() { PluginManager::UnregisterPlugin(CreateInstance); } void SymbolFilePDB::DebuggerInitialize(lldb_private::Debugger &debugger) {} lldb_private::ConstString SymbolFilePDB::GetPluginNameStatic() { static ConstString g_name("pdb"); return g_name; } const char *SymbolFilePDB::GetPluginDescriptionStatic() { return "Microsoft PDB debug symbol file reader."; } lldb_private::SymbolFile * SymbolFilePDB::CreateInstance(lldb_private::ObjectFile *obj_file) { return new SymbolFilePDB(obj_file); } SymbolFilePDB::SymbolFilePDB(lldb_private::ObjectFile *object_file) - : SymbolFile(object_file), m_cached_compile_unit_count(0) {} + : SymbolFile(object_file), m_session_up(), m_global_scope_up(), + m_cached_compile_unit_count(0), m_tu_decl_ctx_up() {} SymbolFilePDB::~SymbolFilePDB() {} uint32_t SymbolFilePDB::CalculateAbilities() { uint32_t abilities = 0; if (!m_obj_file) return 0; if (!m_session_up) { // Lazily load and match the PDB file, but only do this once. std::string exePath = m_obj_file->GetFileSpec().GetPath(); auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath), m_session_up); if (error) { llvm::consumeError(std::move(error)); auto module_sp = m_obj_file->GetModule(); if (!module_sp) return 0; // See if any symbol file is specified through `--symfile` option. FileSpec symfile = module_sp->GetSymbolFileFileSpec(); if (!symfile) return 0; error = loadDataForPDB(PDB_ReaderType::DIA, llvm::StringRef(symfile.GetPath()), m_session_up); if (error) { llvm::consumeError(std::move(error)); return 0; } } } if (!m_session_up.get()) return 0; auto enum_tables_up = m_session_up->getEnumTables(); if (!enum_tables_up) return 0; while (auto table_up = enum_tables_up->getNext()) { if (table_up->getItemCount() == 0) continue; auto type = table_up->getTableType(); switch (type) { case PDB_TableType::Symbols: // This table represents a store of symbols with types listed in // PDBSym_Type abilities |= (CompileUnits | Functions | Blocks | GlobalVariables | LocalVariables | VariableTypes); break; case PDB_TableType::LineNumbers: abilities |= LineTables; break; default: break; } } return abilities; } void SymbolFilePDB::InitializeObject() { lldb::addr_t obj_load_address = m_obj_file->GetFileOffset(); + lldbassert(obj_load_address && + obj_load_address != LLDB_INVALID_ADDRESS); m_session_up->setLoadAddress(obj_load_address); + if (!m_global_scope_up) + m_global_scope_up = m_session_up->getGlobalScope(); + lldbassert(m_global_scope_up.get()); TypeSystem *type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); ClangASTContext *clang_type_system = llvm::dyn_cast_or_null(type_system); + lldbassert(clang_type_system); m_tu_decl_ctx_up = llvm::make_unique( type_system, clang_type_system->GetTranslationUnitDecl()); } uint32_t SymbolFilePDB::GetNumCompileUnits() { if (m_cached_compile_unit_count == 0) { - auto global = m_session_up->getGlobalScope(); - auto compilands = global->findAllChildren(); + auto compilands = m_global_scope_up->findAllChildren(); + if (!compilands) + return 0; + + // The linker could link *.dll (compiland language = LINK), or import + // *.dll. For example, a compiland with name `Import:KERNEL32.dll` + // could be found as a child of the global scope (PDB executable). + // Usually, such compilands contain `thunk` symbols in which we are not + // interested for now. However we still count them in the compiland list. + // If we perform any compiland related activity, like finding symbols + // through llvm::pdb::IPDBSession methods, such compilands will all be + // searched automatically no matter whether we include them or not. m_cached_compile_unit_count = compilands->getChildCount(); // The linker can inject an additional "dummy" compilation unit into the // PDB. Ignore this special compile unit for our purposes, if it is there. // It is always the last one. - auto last_cu = compilands->getChildAtIndex(m_cached_compile_unit_count - 1); - std::string name = last_cu->getName(); + auto last_compiland_up = + compilands->getChildAtIndex(m_cached_compile_unit_count - 1); + lldbassert(last_compiland_up.get()); + std::string name = last_compiland_up->getName(); if (name == "* Linker *") --m_cached_compile_unit_count; } return m_cached_compile_unit_count; } -lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) { - auto global = m_session_up->getGlobalScope(); - auto compilands = global->findAllChildren(); - auto cu = compilands->getChildAtIndex(index); +void SymbolFilePDB::GetCompileUnitIndex( + const llvm::pdb::PDBSymbolCompiland *pdb_compiland, + uint32_t &index) { + if (!pdb_compiland) + return; - uint32_t id = cu->getSymIndexId(); + auto results_up = m_global_scope_up->findAllChildren(); + if (!results_up) + return; + auto uid = pdb_compiland->getSymIndexId(); + for (int cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) { + auto compiland_up = results_up->getChildAtIndex(cu_idx); + if (!compiland_up) + continue; + if (compiland_up->getSymIndexId() == uid) { + index = cu_idx; + return; + } + } + index = UINT32_MAX; + return; +} + +std::unique_ptr +SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) { + return m_session_up->getConcreteSymbolById(uid); +} + +lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) { + if (index >= GetNumCompileUnits()) + return CompUnitSP(); - return ParseCompileUnitForSymIndex(id); + // Assuming we always retrieve same compilands listed in same order through + // `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a + // compile unit makes no sense. + auto results = m_global_scope_up->findAllChildren(); + if (!results) + return CompUnitSP(); + auto compiland_up = results->getChildAtIndex(index); + if (!compiland_up) + return CompUnitSP(); + return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index); } lldb::LanguageType SymbolFilePDB::ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) { // What fields should I expect to be filled out on the SymbolContext? Is it // safe to assume that `sc.comp_unit` is valid? if (!sc.comp_unit) return lldb::eLanguageTypeUnknown; - auto cu = m_session_up->getConcreteSymbolById( - sc.comp_unit->GetID()); - if (!cu) + auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID()); + if (!compiland_up) return lldb::eLanguageTypeUnknown; - auto details = cu->findOneChild(); + auto details = compiland_up->findOneChild(); if (!details) return lldb::eLanguageTypeUnknown; return TranslateLanguage(details->getLanguage()); } size_t SymbolFilePDB::ParseCompileUnitFunctions( const lldb_private::SymbolContext &sc) { // TODO: Implement this return size_t(); } bool SymbolFilePDB::ParseCompileUnitLineTable( const lldb_private::SymbolContext &sc) { + lldbassert(sc.comp_unit); + if (sc.comp_unit->GetLineTable()) + return true; return ParseCompileUnitLineTable(sc, 0); } bool SymbolFilePDB::ParseCompileUnitDebugMacros( const lldb_private::SymbolContext &sc) { // PDB doesn't contain information about macros return false; } bool SymbolFilePDB::ParseCompileUnitSupportFiles( const lldb_private::SymbolContext &sc, lldb_private::FileSpecList &support_files) { - if (!sc.comp_unit) - return false; + lldbassert(sc.comp_unit); // In theory this is unnecessary work for us, because all of this information // is easily (and quickly) accessible from DebugInfoPDB, so caching it a // second time seems like a waste. Unfortunately, there's no good way around // this short of a moderate refactor since SymbolVendor depends on being able // to cache this list. - auto cu = m_session_up->getConcreteSymbolById( - sc.comp_unit->GetID()); - if (!cu) + auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID()); + if (!compiland_up) return false; - auto files = m_session_up->getSourceFilesForCompiland(*cu); + auto files = m_session_up->getSourceFilesForCompiland(*compiland_up); if (!files || files->getChildCount() == 0) return false; while (auto file = files->getNext()) { - FileSpec spec(file->getFileName(), false); - support_files.Append(spec); + FileSpec spec(file->getFileName(), false, FileSpec::ePathSyntaxWindows); + support_files.AppendIfUnique(spec); } return true; } bool SymbolFilePDB::ParseImportedModules( const lldb_private::SymbolContext &sc, std::vector &imported_modules) { // PDB does not yet support module debug info return false; } size_t SymbolFilePDB::ParseFunctionBlocks(const lldb_private::SymbolContext &sc) { // TODO: Implement this return size_t(); } size_t SymbolFilePDB::ParseTypes(const lldb_private::SymbolContext &sc) { // TODO: Implement this return size_t(); } size_t SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) { // TODO: Implement this return size_t(); } lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) { auto find_result = m_types.find(type_uid); if (find_result != m_types.end()) return find_result->second.get(); TypeSystem *type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); ClangASTContext *clang_type_system = llvm::dyn_cast_or_null(type_system); if (!clang_type_system) return nullptr; PDBASTParser *pdb = llvm::dyn_cast(clang_type_system->GetPDBParser()); if (!pdb) return nullptr; auto pdb_type = m_session_up->getSymbolById(type_uid); if (pdb_type == nullptr) return nullptr; lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type); if (result.get()) m_types.insert(std::make_pair(type_uid, result)); return result.get(); } bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) { // TODO: Implement this return false; } lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) { return lldb_private::CompilerDecl(); } lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) { // PDB always uses the translation unit decl context for everything. We can // improve this later but it's not easy because PDB doesn't provide a high // enough level of type fidelity in this area. return *m_tu_decl_ctx_up; } lldb_private::CompilerDeclContext SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) { return *m_tu_decl_ctx_up; } void SymbolFilePDB::ParseDeclsForContext( lldb_private::CompilerDeclContext decl_ctx) {} uint32_t SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr, uint32_t resolve_scope, lldb_private::SymbolContext &sc) { return uint32_t(); } +std::string SymbolFilePDB::GetSourceFileNameForPDBCompiland( + const PDBSymbolCompiland *pdb_compiland) { + if (!pdb_compiland) + return std::string(); + + std::string source_file_name; + // `getSourceFileName` returns the basename of the original source file + // used to generate this compiland. It does not return the full path. + // Currently the only way to get that is to do a basename lookup to get the + // IPDBSourceFile, but this is ambiguous in the case of two source files + // with the same name contributing to the same compiland. This is an edge + // case that we ignore for now, although we need to a long-term solution. + std::string file_name = pdb_compiland->getSourceFileName(); + if (!file_name.empty()) { + auto one_src_file_up = + m_session_up->findOneSourceFile(pdb_compiland, file_name, + PDB_NameSearchFlags::NS_CaseInsensitive); + if (one_src_file_up) + source_file_name = one_src_file_up->getFileName(); + } + // For some reason, source file name could be empty, so we will walk through + // all source files of this compiland, and determine the right source file + // if any that is used to generate this compiland based on language + // indicated in compilanddetails language field. + if (!source_file_name.empty()) + return source_file_name; + + auto details_up = pdb_compiland->findOneChild(); + PDB_Lang pdb_lang = details_up ? details_up->getLanguage() : PDB_Lang::Cpp; + auto src_files_up = + m_session_up->getSourceFilesForCompiland(*pdb_compiland); + if (src_files_up) { + while (auto file_up = src_files_up->getNext()) { + FileSpec file_spec(file_up->getFileName(), false, + FileSpec::ePathSyntaxWindows); + auto file_extension = file_spec.GetFileNameExtension(); + if (pdb_lang == PDB_Lang::Cpp || pdb_lang == PDB_Lang::C) { + static const char* exts[] = { "cpp", "c", "cc", "cxx" }; + if (llvm::is_contained(exts, file_extension.GetStringRef().lower())) + source_file_name = file_up->getFileName(); + break; + } else if (pdb_lang == PDB_Lang::Masm && + ConstString::Compare(file_extension, ConstString("ASM"), + false) == 0) { + source_file_name = file_up->getFileName(); + break; + } + } + } + return source_file_name; +} + uint32_t SymbolFilePDB::ResolveSymbolContext( const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList &sc_list) { + const size_t old_size = sc_list.GetSize(); if (resolve_scope & lldb::eSymbolContextCompUnit) { // Locate all compilation units with line numbers referencing the specified // file. For example, if `file_spec` is , then this should return // all source files and header files that reference , either // directly or indirectly. auto compilands = m_session_up->findCompilandsForSourceFile( file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive); + if (!compilands) + return 0; + // For each one, either find its previously parsed data or parse it afresh // and add it to the symbol context list. while (auto compiland = compilands->getNext()) { // If we're not checking inlines, then don't add line information for this // file unless the FileSpec matches. if (!check_inlines) { // `getSourceFileName` returns the basename of the original source file // used to generate this compiland. It does not return the full path. // Currently the only way to get that is to do a basename lookup to get // the IPDBSourceFile, but this is ambiguous in the case of two source // files with the same name contributing to the same compiland. This is // a moderately extreme edge case, so we consider this OK for now, // although we need to find a long-term solution. - std::string source_file = compiland->getSourceFileName(); - auto pdb_file = m_session_up->findOneSourceFile( - compiland.get(), source_file, - PDB_NameSearchFlags::NS_CaseInsensitive); - source_file = pdb_file->getFileName(); + std::string source_file = + GetSourceFileNameForPDBCompiland(compiland.get()); + if (source_file.empty()) + continue; FileSpec this_spec(source_file, false, FileSpec::ePathSyntaxWindows); - if (!file_spec.FileEquals(this_spec)) + bool need_full_match = !file_spec.GetDirectory().IsEmpty(); + if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0) continue; } SymbolContext sc; - auto cu = ParseCompileUnitForSymIndex(compiland->getSymIndexId()); + auto cu = ParseCompileUnitForUID(compiland->getSymIndexId()); + if (!cu.get()) + continue; sc.comp_unit = cu.get(); sc.module_sp = cu->GetModule(); sc_list.Append(sc); // If we were asked to resolve line entries, add all entries to the line // table that match the requested line (or all lines if `line` == 0). if (resolve_scope & lldb::eSymbolContextLineEntry) ParseCompileUnitLineTable(sc, line); } } - return sc_list.GetSize(); + return sc_list.GetSize() - old_size; } uint32_t SymbolFilePDB::FindGlobalVariables( const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::VariableList &variables) { return uint32_t(); } uint32_t SymbolFilePDB::FindGlobalVariables(const lldb_private::RegularExpression ®ex, bool append, uint32_t max_matches, lldb_private::VariableList &variables) { return uint32_t(); } uint32_t SymbolFilePDB::FindFunctions( const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList &sc_list) { return uint32_t(); } uint32_t SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression ®ex, bool include_inlines, bool append, lldb_private::SymbolContextList &sc_list) { return uint32_t(); } void SymbolFilePDB::GetMangledNamesForFunction( const std::string &scope_qualified_name, std::vector &mangled_names) {} uint32_t SymbolFilePDB::FindTypes( const lldb_private::SymbolContext &sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, llvm::DenseSet &searched_symbol_files, lldb_private::TypeMap &types) { if (!append) types.Clear(); if (!name) return 0; searched_symbol_files.clear(); searched_symbol_files.insert(this); std::string name_str = name.AsCString(); // There is an assumption 'name' is not a regex FindTypesByName(name_str, max_matches, types); return types.GetSize(); } void SymbolFilePDB::FindTypesByRegex(const lldb_private::RegularExpression ®ex, uint32_t max_matches, lldb_private::TypeMap &types) { // When searching by regex, we need to go out of our way to limit the search // space as much as possible since this searches EVERYTHING in the PDB, // manually doing regex comparisons. PDB library isn't optimized for regex // searches or searches across multiple symbol types at the same time, so the // best we can do is to search enums, then typedefs, then classes one by one, // and do a regex comparison against each of them. PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef, PDB_SymType::UDT}; - auto global = m_session_up->getGlobalScope(); std::unique_ptr results; uint32_t matches = 0; for (auto tag : tags_to_search) { - results = global->findAllChildren(tag); + results = m_global_scope_up->findAllChildren(tag); + if (!results) + continue; + while (auto result = results->getNext()) { if (max_matches > 0 && matches >= max_matches) break; std::string type_name; if (auto enum_type = llvm::dyn_cast(result.get())) type_name = enum_type->getName(); else if (auto typedef_type = llvm::dyn_cast(result.get())) type_name = typedef_type->getName(); else if (auto class_type = llvm::dyn_cast(result.get())) type_name = class_type->getName(); else { // We're looking only for types that have names. Skip symbols, as well // as unnamed types such as arrays, pointers, etc. continue; } if (!regex.Execute(type_name)) continue; // This should cause the type to get cached and stored in the `m_types` // lookup. if (!ResolveTypeUID(result->getSymIndexId())) continue; auto iter = m_types.find(result->getSymIndexId()); if (iter == m_types.end()) continue; types.Insert(iter->second); ++matches; } } } void SymbolFilePDB::FindTypesByName(const std::string &name, uint32_t max_matches, lldb_private::TypeMap &types) { - auto global = m_session_up->getGlobalScope(); std::unique_ptr results; - results = global->findChildren(PDB_SymType::None, name, - PDB_NameSearchFlags::NS_Default); + results = m_global_scope_up->findChildren(PDB_SymType::None, name, + PDB_NameSearchFlags::NS_Default); + if (!results) + return; uint32_t matches = 0; while (auto result = results->getNext()) { if (max_matches > 0 && matches >= max_matches) break; switch (result->getSymTag()) { case PDB_SymType::Enum: case PDB_SymType::UDT: case PDB_SymType::Typedef: break; default: // We're looking only for types that have names. Skip symbols, as well as // unnamed types such as arrays, pointers, etc. continue; } // This should cause the type to get cached and stored in the `m_types` // lookup. if (!ResolveTypeUID(result->getSymIndexId())) continue; auto iter = m_types.find(result->getSymIndexId()); if (iter == m_types.end()) continue; types.Insert(iter->second); ++matches; } } size_t SymbolFilePDB::FindTypes( const std::vector &contexts, bool append, lldb_private::TypeMap &types) { return 0; } lldb_private::TypeList *SymbolFilePDB::GetTypeList() { return nullptr; } size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope, uint32_t type_mask, lldb_private::TypeList &type_list) { return size_t(); } lldb_private::TypeSystem * SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { auto type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language); if (type_system) type_system->SetSymbolFile(this); return type_system; } lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace( const lldb_private::SymbolContext &sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx) { return lldb_private::CompilerDeclContext(); } lldb_private::ConstString SymbolFilePDB::GetPluginName() { static ConstString g_name("pdb"); return g_name; } uint32_t SymbolFilePDB::GetPluginVersion() { return 1; } IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; } const IPDBSession &SymbolFilePDB::GetPDBSession() const { return *m_session_up; } -lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForSymIndex(uint32_t id) { +lldb::CompUnitSP +SymbolFilePDB::ParseCompileUnitForUID(uint32_t id, uint32_t index) { auto found_cu = m_comp_units.find(id); if (found_cu != m_comp_units.end()) return found_cu->second; - auto cu = m_session_up->getConcreteSymbolById(id); - - // `getSourceFileName` returns the basename of the original source file used - // to generate this compiland. It does not return the full path. Currently - // the only way to get that is to do a basename lookup to get the - // IPDBSourceFile, but this is ambiguous in the case of two source files with - // the same name contributing to the same compiland. This is a moderately - // extreme edge case, so we consider this OK for now, although we need to find - // a long-term solution. - auto file = - m_session_up->findOneSourceFile(cu.get(), cu->getSourceFileName(), - PDB_NameSearchFlags::NS_CaseInsensitive); - std::string path = file->getFileName(); + auto compiland_up = GetPDBCompilandByUID(id); + if (!compiland_up) + return CompUnitSP(); + std::string path = GetSourceFileNameForPDBCompiland(compiland_up.get()); + if (path.empty()) + return CompUnitSP(); lldb::LanguageType lang; - auto details = cu->findOneChild(); + auto details = compiland_up->findOneChild(); if (!details) lang = lldb::eLanguageTypeC_plus_plus; else lang = TranslateLanguage(details->getLanguage()); // Don't support optimized code for now, DebugInfoPDB does not return this // information. LazyBool optimized = eLazyBoolNo; - auto result = std::make_shared( + auto cu_sp = std::make_shared( m_obj_file->GetModule(), nullptr, path.c_str(), id, lang, optimized); - m_comp_units.insert(std::make_pair(id, result)); - return result; + + if (!cu_sp) + return CompUnitSP(); + + m_comp_units.insert(std::make_pair(id, cu_sp)); + if (index == UINT32_MAX) + GetCompileUnitIndex(compiland_up.get(), index); + lldbassert(index != UINT32_MAX); + m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex( + index, cu_sp); + return cu_sp; } bool SymbolFilePDB::ParseCompileUnitLineTable( const lldb_private::SymbolContext &sc, uint32_t match_line) { - auto global = m_session_up->getGlobalScope(); - auto cu = m_session_up->getConcreteSymbolById( - sc.comp_unit->GetID()); + lldbassert(sc.comp_unit); + + auto compiland_up = GetPDBCompilandByUID(sc.comp_unit->GetID()); + if (!compiland_up) + return false; // LineEntry needs the *index* of the file into the list of support files // returned by ParseCompileUnitSupportFiles. But the underlying SDK gives us // a globally unique idenfitifier in the namespace of the PDB. So, we have to // do a mapping so that we can hand out indices. llvm::DenseMap index_map; - BuildSupportFileIdToSupportFileIndexMap(*cu, index_map); + BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map); auto line_table = llvm::make_unique(sc.comp_unit); - // Find contributions to `cu` from all source and header files. + // Find contributions to `compiland` from all source and header files. std::string path = sc.comp_unit->GetPath(); - auto files = m_session_up->getSourceFilesForCompiland(*cu); + auto files = m_session_up->getSourceFilesForCompiland(*compiland_up); + if (!files) + return false; // For each source and header file, create a LineSequence for contributions to - // the cu from that file, and add the sequence. + // the compiland from that file, and add the sequence. while (auto file = files->getNext()) { std::unique_ptr sequence( line_table->CreateLineSequenceContainer()); - auto lines = m_session_up->findLineNumbers(*cu, *file); + auto lines = m_session_up->findLineNumbers(*compiland_up, *file); + if (!lines) + continue; int entry_count = lines->getChildCount(); uint64_t prev_addr; uint32_t prev_length; uint32_t prev_line; uint32_t prev_source_idx; for (int i = 0; i < entry_count; ++i) { auto line = lines->getChildAtIndex(i); uint64_t lno = line->getLineNumber(); uint64_t addr = line->getVirtualAddress(); uint32_t length = line->getLength(); uint32_t source_id = line->getSourceFileId(); uint32_t col = line->getColumnNumber(); uint32_t source_idx = index_map[source_id]; // There was a gap between the current entry and the previous entry if the // addresses don't perfectly line up. bool is_gap = (i > 0) && (prev_addr + prev_length < addr); // Before inserting the current entry, insert a terminal entry at the end // of the previous entry's address range if the current entry resulted in // a gap from the previous entry. if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) { line_table->AppendLineEntryToSequence( sequence.get(), prev_addr + prev_length, prev_line, 0, prev_source_idx, false, false, false, false, true); } if (ShouldAddLine(match_line, lno, length)) { bool is_statement = line->isStatement(); bool is_prologue = false; bool is_epilogue = false; auto func = m_session_up->findSymbolByAddress(addr, PDB_SymType::Function); if (func) { auto prologue = func->findOneChild(); - is_prologue = (addr == prologue->getVirtualAddress()); + if (prologue) + is_prologue = (addr == prologue->getVirtualAddress()); auto epilogue = func->findOneChild(); - is_epilogue = (addr == epilogue->getVirtualAddress()); + if (epilogue) + is_epilogue = (addr == epilogue->getVirtualAddress()); } line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col, source_idx, is_statement, false, is_prologue, is_epilogue, false); } prev_addr = addr; prev_length = length; prev_line = lno; prev_source_idx = source_idx; } if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) { // The end is always a terminal entry, so insert it regardless. line_table->AppendLineEntryToSequence( sequence.get(), prev_addr + prev_length, prev_line, 0, prev_source_idx, false, false, false, false, true); } line_table->InsertSequence(sequence.release()); } - sc.comp_unit->SetLineTable(line_table.release()); - return true; + if (line_table->GetSize()) { + sc.comp_unit->SetLineTable(line_table.release()); + return true; + } + return false; } void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap( - const PDBSymbolCompiland &cu, + const PDBSymbolCompiland &compiland, llvm::DenseMap &index_map) const { // This is a hack, but we need to convert the source id into an index into the // support files array. We don't want to do path comparisons to avoid // basename / full path issues that may or may not even be a problem, so we // use the globally unique source file identifiers. Ideally we could use the // global identifiers everywhere, but LineEntry currently assumes indices. - auto source_files = m_session_up->getSourceFilesForCompiland(cu); + auto source_files = m_session_up->getSourceFilesForCompiland(compiland); + if (!source_files) + return; int index = 0; while (auto file = source_files->getNext()) { uint32_t source_id = file->getUniqueId(); index_map[source_id] = index++; } } diff --git a/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h b/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h index eef96be8d1fe..1d5f1b6fa8ae 100644 --- a/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h +++ b/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h @@ -1,191 +1,203 @@ //===-- SymbolFilePDB.h -------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_ #define lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_ #include "lldb/Symbol/SymbolFile.h" #include "lldb/Utility/UserID.h" #include "llvm/ADT/DenseMap.h" #include "llvm/DebugInfo/PDB/IPDBSession.h" #include "llvm/DebugInfo/PDB/PDB.h" +#include "llvm/DebugInfo/PDB/PDBSymbolExe.h" class SymbolFilePDB : public lldb_private::SymbolFile { public: //------------------------------------------------------------------ // Static Functions //------------------------------------------------------------------ static void Initialize(); static void Terminate(); static void DebuggerInitialize(lldb_private::Debugger &debugger); static lldb_private::ConstString GetPluginNameStatic(); static const char *GetPluginDescriptionStatic(); static lldb_private::SymbolFile * CreateInstance(lldb_private::ObjectFile *obj_file); //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ SymbolFilePDB(lldb_private::ObjectFile *ofile); ~SymbolFilePDB() override; uint32_t CalculateAbilities() override; void InitializeObject() override; //------------------------------------------------------------------ // Compile Unit function calls //------------------------------------------------------------------ uint32_t GetNumCompileUnits() override; lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override; lldb::LanguageType ParseCompileUnitLanguage(const lldb_private::SymbolContext &sc) override; size_t ParseCompileUnitFunctions(const lldb_private::SymbolContext &sc) override; bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc) override; bool ParseCompileUnitDebugMacros(const lldb_private::SymbolContext &sc) override; bool ParseCompileUnitSupportFiles( const lldb_private::SymbolContext &sc, lldb_private::FileSpecList &support_files) override; bool ParseImportedModules( const lldb_private::SymbolContext &sc, std::vector &imported_modules) override; size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override; size_t ParseTypes(const lldb_private::SymbolContext &sc) override; size_t ParseVariablesForContext(const lldb_private::SymbolContext &sc) override; lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override; bool CompleteType(lldb_private::CompilerType &compiler_type) override; lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override; lldb_private::CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) override; lldb_private::CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) override; void ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override; uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, uint32_t resolve_scope, lldb_private::SymbolContext &sc) override; uint32_t ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList &sc_list) override; uint32_t FindGlobalVariables(const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::VariableList &variables) override; uint32_t FindGlobalVariables(const lldb_private::RegularExpression ®ex, bool append, uint32_t max_matches, lldb_private::VariableList &variables) override; uint32_t FindFunctions(const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList &sc_list) override; uint32_t FindFunctions(const lldb_private::RegularExpression ®ex, bool include_inlines, bool append, lldb_private::SymbolContextList &sc_list) override; void GetMangledNamesForFunction( const std::string &scope_qualified_name, std::vector &mangled_names) override; uint32_t FindTypes(const lldb_private::SymbolContext &sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, llvm::DenseSet &searched_symbol_files, lldb_private::TypeMap &types) override; size_t FindTypes(const std::vector &context, bool append, lldb_private::TypeMap &types) override; void FindTypesByRegex(const lldb_private::RegularExpression ®ex, uint32_t max_matches, lldb_private::TypeMap &types); lldb_private::TypeList *GetTypeList() override; size_t GetTypes(lldb_private::SymbolContextScope *sc_scope, uint32_t type_mask, lldb_private::TypeList &type_list) override; lldb_private::TypeSystem * GetTypeSystemForLanguage(lldb::LanguageType language) override; lldb_private::CompilerDeclContext FindNamespace( const lldb_private::SymbolContext &sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx) override; lldb_private::ConstString GetPluginName() override; uint32_t GetPluginVersion() override; llvm::pdb::IPDBSession &GetPDBSession(); const llvm::pdb::IPDBSession &GetPDBSession() const; private: - lldb::CompUnitSP ParseCompileUnitForSymIndex(uint32_t id); + lldb::CompUnitSP + ParseCompileUnitForUID(uint32_t id, uint32_t index = UINT32_MAX); bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc, uint32_t match_line); void BuildSupportFileIdToSupportFileIndexMap( - const llvm::pdb::PDBSymbolCompiland &cu, + const llvm::pdb::PDBSymbolCompiland &pdb_compiland, llvm::DenseMap &index_map) const; void FindTypesByName(const std::string &name, uint32_t max_matches, lldb_private::TypeMap &types); + void GetCompileUnitIndex(const llvm::pdb::PDBSymbolCompiland *pdb_compiland, + uint32_t &index); + + std::string GetSourceFileNameForPDBCompiland( + const llvm::pdb::PDBSymbolCompiland *pdb_compiland); + + std::unique_ptr + GetPDBCompilandByUID(uint32_t uid); + llvm::DenseMap m_comp_units; llvm::DenseMap m_types; std::vector m_builtin_types; std::unique_ptr m_session_up; + std::unique_ptr m_global_scope_up; uint32_t m_cached_compile_unit_count; std::unique_ptr m_tu_decl_ctx_up; }; #endif // lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_