maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Add support for reading line tables from PDB files. 

PDB is Microsoft's debug information format, and although we
cannot yet generate it, we still must be able to consume it.
Reason for this is that debug information for system libraries
(e.g. kernel32, C Runtime Library, etc) only have debug info
in PDB format, so in order to be able to support debugging
of system code, we must support it.

Currently this code should compile on every platform, but on
non-Windows platforms the PDB plugin will return 0 capabilities,
meaning that for now PDB is only supported on Windows.  This
may change in the future, but the API is designed in such a way
that this will require few (if any) changes on the LLDB side.
In the future we can just flip a switch and everything will
work.

This patch only adds support for line tables.  It does not return
information about functions, types, global variables, or anything
else.  This functionality will be added in a followup patch.

Differential Revision: http://reviews.llvm.org/D17363
Reviewed by: Greg Clayton

llvm-svn: 262528
This commit is contained in:
Zachary Turner 2016-03-02 22:05:52 +00:00
parent 6470f7615c
commit 74e08ca05c
24 changed files with 1249 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lldb/cmake/LLDBDependencies.cmake
View File

@ -15,6 +15,7 @@ set( LLDB_USED_LIBS
# Plugins
lldbPluginDisassemblerLLVM
lldbPluginSymbolFileDWARF
lldbPluginSymbolFilePDB
lldbPluginSymbolFileSymtab
lldbPluginDynamicLoaderStatic
lldbPluginDynamicLoaderPosixDYLD
@ -174,7 +175,7 @@ if (LLVM_BUILD_STATIC)
endif()
endif()
set( LLVM_LINK_COMPONENTS
set(LLVM_LINK_COMPONENTS
${LLVM_TARGETS_TO_BUILD}
interpreter
asmparser

2
lldb/cmake/modules/AddLLDB.cmake
View File

@ -68,7 +68,7 @@ macro(add_lldb_library name)
target_link_libraries(${name} ${cmake_2_8_12_PUBLIC} ${CLANG_USED_LIBS})
endif()
endif()
llvm_config(${name} ${LLVM_LINK_COMPONENTS})
llvm_config(${name} ${LLVM_LINK_COMPONENTS} ${LLVM_PRIVATE_LINK_COMPONENTS})
if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "liblldb")
if (PARAM_SHARED)

6
lldb/include/lldb/Host/FileSpec.h
View File

@ -117,6 +117,12 @@ public:
//------------------------------------------------------------------
~FileSpec ();
bool
DirectoryEquals(const FileSpec &other) const;
bool
FileEquals(const FileSpec &other) const;
//------------------------------------------------------------------
/// Assignment operator.
///

26
lldb/include/lldb/Host/windows/HostInfoWindows.h
View File

@ -26,14 +26,26 @@ class HostInfoWindows : public HostInfoBase
~HostInfoWindows();
public:
static size_t GetPageSize();
static void
Initialize();
static void
Terminate();
static bool GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
static bool GetOSBuildString(std::string &s);
static bool GetOSKernelDescription(std::string &s);
static bool GetHostname(std::string &s);
static FileSpec GetProgramFileSpec();
static FileSpec GetDefaultShell();
static size_t
GetPageSize();
static bool
GetOSVersion(uint32_t &major, uint32_t &minor, uint32_t &update);
static bool
GetOSBuildString(std::string &s);
static bool
GetOSKernelDescription(std::string &s);
static bool
GetHostname(std::string &s);
static FileSpec
GetProgramFileSpec();
static FileSpec
GetDefaultShell();
protected:
static bool ComputePythonDirectory(FileSpec &file_spec);

17
lldb/source/API/SystemInitializerFull.cpp
View File

@ -28,18 +28,18 @@
#include "lldb/Symbol/GoASTContext.h"
#include "lldb/Symbol/JavaASTContext.h"
#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
#include "Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h"
#include "Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h"
#include "Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h"
#include "Plugins/ABI/SysV-arm/ABISysV_arm.h"
#include "Plugins/ABI/SysV-arm64/ABISysV_arm64.h"
#include "Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h"
#include "Plugins/ABI/SysV-i386/ABISysV_i386.h"
#include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
#include "Plugins/ABI/SysV-ppc/ABISysV_ppc.h"
#include "Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h"
#include "Plugins/ABI/SysV-mips/ABISysV_mips.h"
#include "Plugins/ABI/SysV-mips64/ABISysV_mips64.h"
#include "Plugins/ABI/SysV-ppc/ABISysV_ppc.h"
#include "Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h"
#include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
#include "Plugins/Disassembler/llvm/DisassemblerLLVMC.h"
#include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
#include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
@ -51,10 +51,10 @@
#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
#include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
#include "Plugins/LanguageRuntime/Go/GoLanguageRuntime.h"
#include "Plugins/LanguageRuntime/Java/JavaLanguageRuntime.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
#include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
#include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
#include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
#include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
@ -63,11 +63,12 @@
#include "Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
#include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
#include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
#include "Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h"
#include "Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h"
#include "Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h"
#include "Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h"
#if defined(__APPLE__)
#include "Plugins/Process/mach-core/ProcessMachCore.h"
@ -301,6 +302,7 @@ SystemInitializerFull::Initialize()
SymbolVendorELF::Initialize();
SymbolFileDWARF::Initialize();
SymbolFilePDB::Initialize();
SymbolFileSymtab::Initialize();
UnwindAssemblyInstEmulation::Initialize();
UnwindAssembly_x86::Initialize();
@ -422,6 +424,7 @@ SystemInitializerFull::Terminate()
AddressSanitizerRuntime::Terminate();
SymbolVendorELF::Terminate();
SymbolFileDWARF::Terminate();
SymbolFilePDB::Terminate();
SymbolFileSymtab::Terminate();
UnwindAssembly_x86::Terminate();
UnwindAssemblyInstEmulation::Terminate();

24
lldb/source/Host/common/FileSpec.cpp
View File

@ -390,19 +390,29 @@ FileSpec::operator!() const
return !m_directory && !m_filename;
}
bool
FileSpec::DirectoryEquals(const FileSpec &rhs) const
{
const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
return ConstString::Equals(m_directory, rhs.m_directory, case_sensitive);
}
bool
FileSpec::FileEquals(const FileSpec &rhs) const
{
const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
return ConstString::Equals(m_filename, rhs.m_filename, case_sensitive);
}
//------------------------------------------------------------------
// Equal to operator
//------------------------------------------------------------------
bool
FileSpec::operator== (const FileSpec& rhs) const
{
// case sensitivity of equality test
const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
if (!ConstString::Equals(m_filename, rhs.m_filename, case_sensitive))
if (!FileEquals(rhs))
return false;
if (ConstString::Equals(m_directory, rhs.m_directory, case_sensitive))
if (DirectoryEquals(rhs))
return true;
// TODO: determine if we want to keep this code in here.
@ -451,7 +461,7 @@ FileSpec::operator== (const FileSpec& rhs) const
// If we reach this point in the code we were able to resolve both paths
// and since we only resolve the paths if the basenames are equal, then
// we can just check if both directories are equal...
return ConstString::Equals(m_directory, rhs.m_directory, case_sensitive);
return DirectoryEquals(rhs);
}
//------------------------------------------------------------------

16
lldb/source/Host/windows/HostInfoWindows.cpp
View File

@ -9,6 +9,8 @@
#include "lldb/Host/windows/windows.h"
#include <objbase.h>
#include <mutex> // std::once
#include "lldb/Host/windows/HostInfoWindows.h"
@ -21,6 +23,20 @@ using namespace lldb_private;
FileSpec HostInfoWindows::m_program_filespec;
void
HostInfoWindows::Initialize()
{
::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
HostInfoBase::Initialize();
}
void
HostInfoWindows::Terminate()
{
HostInfoBase::Terminate();
::CoUninitialize();
}
size_t
HostInfoWindows::GetPageSize()
{

2
lldb/source/Initialization/SystemInitializerCommon.cpp
View File

@ -49,8 +49,8 @@
#endif
#if defined(_MSC_VER)
#include "lldb/Host/windows/windows.h"
#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
#include "lldb/Host/windows/windows.h"
#endif
#include "llvm/Support/TargetSelect.h"

1
lldb/source/Plugins/SymbolFile/CMakeLists.txt
View File

@ -1,2 +1,3 @@
add_subdirectory(DWARF)
add_subdirectory(Symtab)
add_subdirectory(PDB)

6
lldb/source/Plugins/SymbolFile/PDB/CMakeLists.txt Normal file
View File

@ -0,0 +1,6 @@
set(LLVM_PRIVATE_LINK_COMPONENTS
DebugInfoPDB)
add_lldb_library(lldbPluginSymbolFilePDB
SymbolFilePDB.cpp
)

549
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp Normal file
View File

@ -0,0 +1,549 @@
//===-- 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 "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContext.h"
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.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"
using namespace lldb_private;
namespace
{
lldb::LanguageType TranslateLanguage(llvm::PDB_Lang lang)
{
switch (lang)
{
case llvm::PDB_Lang::Cpp:
return lldb::LanguageType::eLanguageTypeC_plus_plus;
case llvm::PDB_Lang::C:
return lldb::LanguageType::eLanguageTypeC;
default:
return lldb::LanguageType::eLanguageTypeUnknown;
}
}
}
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)
{
}
SymbolFilePDB::~SymbolFilePDB()
{
}
uint32_t
SymbolFilePDB::CalculateAbilities()
{
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 = llvm::loadDataForEXE(llvm::PDB_ReaderType::DIA, llvm::StringRef(exePath), m_session_up);
if (error != llvm::PDB_ErrorCode::Success)
return 0;
}
return CompileUnits | LineTables;
}
void
SymbolFilePDB::InitializeObject()
{
lldb::addr_t obj_load_address = m_obj_file->GetFileOffset();
m_session_up->setLoadAddress(obj_load_address);
}
uint32_t
SymbolFilePDB::GetNumCompileUnits()
{
if (m_cached_compile_unit_count == 0)
{
auto global = m_session_up->getGlobalScope();
auto compilands = global->findAllChildren<llvm::PDBSymbolCompiland>();
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();
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<llvm::PDBSymbolCompiland>();
auto cu = compilands->getChildAtIndex(index);
uint32_t id = cu->getSymIndexId();
return ParseCompileUnitForSymIndex(id);
}
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<llvm::PDBSymbolCompiland>(sc.comp_unit->GetID());
if (!cu)
return lldb::eLanguageTypeUnknown;
auto details = cu->findOneChild<llvm::PDBSymbolCompilandDetails>();
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)
{
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;
// 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<llvm::PDBSymbolCompiland>(sc.comp_unit->GetID());
if (!cu)
return false;
auto files = m_session_up->getSourceFilesForCompiland(*cu);
if (!files || files->getChildCount() == 0)
return false;
while (auto file = files->getNext())
{
FileSpec spec(file->getFileName(), false);
support_files.Append(spec);
}
return true;
}
bool
SymbolFilePDB::ParseImportedModules(const lldb_private::SymbolContext &sc,
std::vector<lldb_private::ConstString> &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)
{
return nullptr;
}
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)
{
return lldb_private::CompilerDeclContext();
}
lldb_private::CompilerDeclContext
SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid)
{
return lldb_private::CompilerDeclContext();
}
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();
}
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)
{
if (resolve_scope & lldb::eSymbolContextCompUnit)
{
// Locate all compilation units with line numbers referencing the specified file. For example, if
// `file_spec` is <vector>, then this should return all source files and header files that reference
// <vector>, either directly or indirectly.
auto compilands =
m_session_up->findCompilandsForSourceFile(file_spec.GetPath(), llvm::PDB_NameSearchFlags::NS_CaseInsensitive);
// For each one, either find get 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,
llvm::PDB_NameSearchFlags::NS_CaseInsensitive);
source_file = pdb_file->getFileName();
FileSpec this_spec(source_file, false, FileSpec::ePathSyntaxWindows);
if (!file_spec.FileEquals(this_spec))
continue;
}
SymbolContext sc;
auto cu = ParseCompileUnitForSymIndex(compiland->getSymIndexId());
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();
}
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 &regex, 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 &regex, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list)
{
return uint32_t();
}
void
SymbolFilePDB::GetMangledNamesForFunction(const std::string &scope_qualified_name,
std::vector<lldb_private::ConstString> &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<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types)
{
return uint32_t();
}
size_t
SymbolFilePDB::FindTypes(const std::vector<lldb_private::CompilerContext> &context, bool append,
lldb_private::TypeMap &types)
{
return size_t();
}
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;
}
lldb::CompUnitSP
SymbolFilePDB::ParseCompileUnitForSymIndex(uint32_t id)
{
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<llvm::PDBSymbolCompiland>(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(),
llvm::PDB_NameSearchFlags::NS_CaseInsensitive);
std::string path = file->getFileName();
lldb::LanguageType lang;
auto details = cu->findOneChild<llvm::PDBSymbolCompilandDetails>();
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.
bool optimized = false;
auto result = std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr, path.c_str(), id, lang, optimized);
m_comp_units.insert(std::make_pair(id, result));
return result;
}
bool
SymbolFilePDB::ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc, uint32_t match_line)
{
auto global = m_session_up->getGlobalScope();
auto cu = m_session_up->getConcreteSymbolById<llvm::PDBSymbolCompiland>(sc.comp_unit->GetID());
// 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.
std::unordered_map<uint32_t, uint32_t> index_map;
BuildSupportFileIdToSupportFileIndexMap(*cu, index_map);
auto line_table = llvm::make_unique<LineTable>(sc.comp_unit);
// Find contributions to `cu` from all source and header files.
std::string path = sc.comp_unit->GetPath();
auto files = m_session_up->getSourceFilesForCompiland(*cu);
// For each source and header file, create a LineSequence for contributions to the cu
// from that file, and add the sequence.
while (auto file = files->getNext())
{
std::unique_ptr<LineSequence> sequence(line_table->CreateLineSequenceContainer());
auto lines = m_session_up->findLineNumbers(*cu, *file);
int entry_count = lines->getChildCount();
for (int i = 0; i < entry_count; ++i)
{
auto line = lines->getChildAtIndex(i);
uint32_t lno = line->getLineNumber();
// If `match_line` == 0 we add any line no matter what. Otherwise, we only add
// lines that match the requested line number.
if (match_line != 0 && lno != match_line)
continue;
uint64_t va = line->getVirtualAddress();
uint32_t cno = line->getColumnNumber();
uint32_t source_id = line->getSourceFileId();
uint32_t source_idx = index_map[source_id];
bool is_basic_block = false; // PDB doesn't even have this concept, but LLDB doesn't use it anyway.
bool is_prologue = false;
bool is_epilogue = false;
bool is_statement = line->isStatement();
auto func = m_session_up->findSymbolByAddress(va, llvm::PDB_SymType::Function);
if (func)
{
auto prologue = func->findOneChild<llvm::PDBSymbolFuncDebugStart>();
is_prologue = (va == prologue->getVirtualAddress());
auto epilogue = func->findOneChild<llvm::PDBSymbolFuncDebugEnd>();
is_epilogue = (va == epilogue->getVirtualAddress());
if (is_epilogue)
{
// Once per function, add a termination entry after the last byte of the function.
// TODO: This makes the assumption that all functions are laid out contiguously in
// memory and have no gaps. This is a wrong assumption in the general case, but is
// good enough to allow simple scenarios to work. This needs to be revisited.
auto concrete_func = llvm::dyn_cast<llvm::PDBSymbolFunc>(func.get());
lldb::addr_t end_addr = concrete_func->getVirtualAddress() + concrete_func->getLength();
line_table->InsertLineEntry(end_addr, lno, 0, source_idx, false, false, false, false, true);
}
}
line_table->InsertLineEntry(va, lno, cno, source_idx, is_statement, is_basic_block, is_prologue,
is_epilogue, false);
}
}
sc.comp_unit->SetLineTable(line_table.release());
return true;
}
void
SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(const llvm::PDBSymbolCompiland &cu,
std::unordered_map<uint32_t, uint32_t> &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);
int index = 0;
while (auto file = source_files->getNext())
{
uint32_t source_id = file->getUniqueId();
index_map[source_id] = index++;
}
}

190
lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h Normal file
View File

@ -0,0 +1,190 @@
//===-- 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 <unordered_map>
#include "lldb/Core/UserID.h"
#include "lldb/Symbol/SymbolFile.h"
#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/PDB.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<lldb_private::ConstString> &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 &regex, 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 &regex, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) override;
void
GetMangledNamesForFunction(const std::string &scope_qualified_name,
std::vector<lldb_private::ConstString> &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<lldb_private::SymbolFile *> &searched_symbol_files, lldb_private::TypeMap &types) override;
size_t
FindTypes(const std::vector<lldb_private::CompilerContext> &context, bool append,
lldb_private::TypeMap &types) override;
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;
private:
lldb::CompUnitSP
ParseCompileUnitForSymIndex(uint32_t id);
bool
ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc, uint32_t match_line);
void
BuildSupportFileIdToSupportFileIndexMap(const llvm::PDBSymbolCompiland &cu,
std::unordered_map<uint32_t, uint32_t> &index_map) const;
std::unordered_map<uint32_t, lldb::CompUnitSP> m_comp_units;
std::unique_ptr<llvm::IPDBSession> m_session_up;
uint32_t m_cached_compile_unit_count;
};
#endif // lldb_Plugins_SymbolFile_PDB_SymbolFilePDB_h_

16
lldb/unittests/CMakeLists.txt
View File

@ -18,15 +18,31 @@ function(add_lldb_unittest test_name)
${ARGN}
)
add_custom_command(
TARGET ${test_name}
POST_BUILD
COMMAND "${CMAKE_COMMAND}" -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/Inputs)
lldb_link_common_libs(${test_name} EXE)
target_link_libraries(${test_name} ${CLANG_USED_LIBS} ${LLDB_SYSTEM_LIBS})
llvm_config(${test_name} ${LLVM_LINK_COMPONENTS})
endfunction()
function(add_unittest_inputs test_name inputs)
foreach (INPUT ${inputs})
add_custom_command(
TARGET ${test_name}
POST_BUILD
COMMAND "${CMAKE_COMMAND}" -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Inputs/${INPUT} ${CMAKE_CURRENT_BINARY_DIR}/Inputs
COMMENT "Copying ${INPUT} to binary directory.")
endforeach()
endfunction()
add_subdirectory(Core)
add_subdirectory(Editline)
add_subdirectory(Expression)
add_subdirectory(Host)
add_subdirectory(Interpreter)
add_subdirectory(ScriptInterpreter)
add_subdirectory(SymbolFile)
add_subdirectory(Utility)

1
lldb/unittests/SymbolFile/CMakeLists.txt Normal file
View File

@ -0,0 +1 @@
add_subdirectory(PDB)

10
lldb/unittests/SymbolFile/PDB/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
add_lldb_unittest(SymbolFilePDBTests
SymbolFilePDBTests.cpp
)
set(test_inputs
test-pdb.exe
test-pdb.pdb
test-dwarf.exe)
add_unittest_inputs(SymbolFilePDBTests "${test_inputs}")

14
lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.cpp Normal file
View File

@ -0,0 +1,14 @@
// Compile with "cl /c /Zi /GR- test.cpp"
// Link with "link test.obj /debug /nodefaultlib /entry:main /out:test.exe"
int __cdecl _purecall(void)
{
return 0;
}
int
main(int argc, char **argv)
{
return 0;
}

BIN
lldb/unittests/SymbolFile/PDB/Inputs/test-dwarf.exe Normal file
View File

Binary file not shown.

9
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-alt.cpp Normal file
View File

@ -0,0 +1,9 @@
// Compile with "cl /c /Zi /GR- test-pdb-alt.cpp"
// Link with "link test-pdb.obj test-pdb-alt.obj /debug /nodefaultlib /entry:main /out:test-pdb.exe"
#include "test-pdb.h"
int bar(int n)
{
return n-1;
}

9
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb-nested.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef TEST_PDB_NESTED_H
#define TEST_PDB_NESTED_H
inline int baz(int n)
{
return n+1;
}
#endif

15
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.cpp Normal file
View File

@ -0,0 +1,15 @@
// Compile with "cl /c /Zi /GR- test-pdb.cpp"
// Link with "link test-pdb.obj /debug /nodefaultlib /entry:main /out:test-pdb.exe"
#include "test-pdb.h"
int __cdecl _purecall(void)
{
return 0;
}
int
main(int argc, char **argv)
{
return foo(argc) + bar(argc);
}

BIN
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.exe Normal file
View File

Binary file not shown.

13
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef TEST_PDB_H
#define TEST_PDB_H
#include "test-pdb-nested.h"
int bar(int n);
inline int foo(int n)
{
return baz(n)+1;
}
#endif

BIN
lldb/unittests/SymbolFile/PDB/Inputs/test-pdb.pdb Normal file
View File

Binary file not shown.

344
lldb/unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp Normal file
View File

@ -0,0 +1,344 @@
//===-- PythonDataObjectsTests.cpp ------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Config/config.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
#if defined(_MSC_VER)
#include <objbase.h>
#endif
extern const char *TestMainArgv0;
using namespace lldb_private;
class SymbolFilePDBTests : public testing::Test
{
public:
void
SetUp() override
{
#if defined(_MSC_VER)
::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
#endif
HostInfoBase::Initialize();
ObjectFilePECOFF::Initialize();
SymbolFileDWARF::Initialize();
SymbolFilePDB::Initialize();
llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
llvm::SmallString<128> inputs_folder = exe_folder;
llvm::sys::path::append(inputs_folder, "Inputs");
m_pdb_test_exe = inputs_folder;
m_dwarf_test_exe = inputs_folder;
llvm::sys::path::append(m_pdb_test_exe, "test-pdb.exe");
llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
}
void
TearDown() override
{
#if defined(_MSC_VER)
::CoUninitialize();
#endif
SymbolFilePDB::Terminate();
SymbolFileDWARF::Terminate();
ObjectFilePECOFF::Terminate();
}
protected:
llvm::SmallString<128> m_pdb_test_exe;
llvm::SmallString<128> m_dwarf_test_exe;
bool
FileSpecMatchesAsBaseOrFull(const FileSpec &left, const FileSpec &right) const
{
// If the filenames don't match, the paths can't be equal
if (!left.FileEquals(right))
return false;
// If BOTH have a directory, also compare the directories.
if (left.GetDirectory() && right.GetDirectory())
return left.DirectoryEquals(right);
// If one has a directory but not the other, they match.
return true;
}
void
VerifyLineEntry(lldb::ModuleSP module, const SymbolContext &sc, const FileSpec &spec, LineTable &lt, uint32_t line,
lldb::addr_t addr)
{
LineEntry entry;
Address address;
EXPECT_TRUE(module->ResolveFileAddress(addr, address));
EXPECT_TRUE(lt.FindLineEntryByAddress(address, entry));
EXPECT_EQ(line, entry.line);
EXPECT_EQ(address, entry.range.GetBaseAddress());
EXPECT_TRUE(FileSpecMatchesAsBaseOrFull(spec, entry.file));
}
bool
ContainsCompileUnit(const SymbolContextList &sc_list, const FileSpec &spec) const
{
for (int i = 0; i < sc_list.GetSize(); ++i)
{
const SymbolContext &sc = sc_list[i];
if (FileSpecMatchesAsBaseOrFull(*sc.comp_unit, spec))
return true;
}
return false;
}
};
#if defined(HAVE_DIA_SDK)
#define REQUIRES_DIA_SDK(TestName) TestName
#else
#define REQUIRES_DIA_SDK(TestName) DISABLED_##TestName
#endif
TEST_F(SymbolFilePDBTests, TestAbilitiesForDWARF)
{
// Test that when we have Dwarf debug info, SymbolFileDWARF is used.
FileSpec fspec(m_dwarf_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
EXPECT_NE(nullptr, symfile);
EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
uint32_t expected_abilities = SymbolFile::kAllAbilities;
EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestAbilitiesForPDB))
{
// Test that when we have PDB debug info, SymbolFilePDB is used.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
EXPECT_NE(nullptr, symfile);
EXPECT_EQ(symfile->GetPluginName(), SymbolFilePDB::GetPluginNameStatic());
uint32_t expected_abilities = SymbolFile::CompileUnits | SymbolFile::LineTables;
EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextBasename))
{
// Test that attempting to call ResolveSymbolContext with only a basename finds all full paths
// with the same basename
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec header_spec("test-pdb.cpp", false);
SymbolContextList sc_list;
uint32_t result_count = symfile->ResolveSymbolContext(header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
EXPECT_EQ(1, result_count);
EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestResolveSymbolContextFullPath))
{
// Test that attempting to call ResolveSymbolContext with a full path only finds the one source
// file that matches the full path.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec header_spec(R"spec(D:\src\llvm\tools\lldb\unittests\SymbolFile\PDB\Inputs\test-pdb.cpp)spec", false);
SymbolContextList sc_list;
uint32_t result_count = symfile->ResolveSymbolContext(header_spec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
EXPECT_GE(1, result_count);
EXPECT_TRUE(ContainsCompileUnit(sc_list, header_spec));
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithInlines))
{
// Test that when looking up a header file via ResolveSymbolContext (i.e. a file that was not by itself
// compiled, but only contributes to the combined code of other source files), a SymbolContext is returned
// for each compiland which has line contributions from the requested header.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec header_specs[] = {FileSpec("test-pdb.h", false), FileSpec("test-pdb-nested.h", false)};
FileSpec main_cpp_spec("test-pdb.cpp", false);
FileSpec alt_cpp_spec("test-pdb-alt.cpp", false);
for (const auto &hspec : header_specs)
{
SymbolContextList sc_list;
uint32_t result_count = symfile->ResolveSymbolContext(hspec, 0, true, lldb::eSymbolContextCompUnit, sc_list);
EXPECT_EQ(2, result_count);
EXPECT_TRUE(ContainsCompileUnit(sc_list, main_cpp_spec));
EXPECT_TRUE(ContainsCompileUnit(sc_list, alt_cpp_spec));
}
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLookupOfHeaderFileWithNoInlines))
{
// Test that when looking up a header file via ResolveSymbolContext (i.e. a file that was not by itself
// compiled, but only contributes to the combined code of other source files), that if check_inlines
// is false, no SymbolContexts are returned.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
EXPECT_NE(nullptr, plugin);
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec header_specs[] = {FileSpec("test-pdb.h", false), FileSpec("test-pdb-nested.h", false)};
for (const auto &hspec : header_specs)
{
SymbolContextList sc_list;
uint32_t result_count = symfile->ResolveSymbolContext(hspec, 0, false, lldb::eSymbolContextCompUnit, sc_list);
EXPECT_EQ(0, result_count);
}
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchAll))
{
// Test that when calling ResolveSymbolContext with a line number of 0, all line entries from
// the specified files are returned.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec source_file("test-pdb.cpp", false);
FileSpec header1("test-pdb.h", false);
FileSpec header2("test-pdb-nested.h", false);
uint32_t cus = symfile->GetNumCompileUnits();
EXPECT_EQ(2, cus);
SymbolContextList sc_list;
uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
uint32_t count = symfile->ResolveSymbolContext(source_file, 0, true, scope, sc_list);
EXPECT_EQ(1, count);
SymbolContext sc;
EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
LineTable *lt = sc.comp_unit->GetLineTable();
EXPECT_NE(nullptr, lt);
count = lt->GetSize();
// We expect one extra entry for termination (per function)
EXPECT_EQ(16, count);
VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
VerifyLineEntry(module, sc, source_file, *lt, 8, 0x401043);
VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
VerifyLineEntry(module, sc, source_file, *lt, 13, 0x401050);
VerifyLineEntry(module, sc, source_file, *lt, 14, 0x401054);
VerifyLineEntry(module, sc, source_file, *lt, 15, 0x401070);
VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
VerifyLineEntry(module, sc, header1, *lt, 10, 0x401093);
VerifyLineEntry(module, sc, header1, *lt, 11, 0x4010a2);
VerifyLineEntry(module, sc, header2, *lt, 5, 0x401080);
VerifyLineEntry(module, sc, header2, *lt, 6, 0x401083);
VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
}
TEST_F(SymbolFilePDBTests, REQUIRES_DIA_SDK(TestLineTablesMatchSpecific))
{
// Test that when calling ResolveSymbolContext with a specific line number, only line entries
// which match the requested line are returned.
FileSpec fspec(m_pdb_test_exe.c_str(), false);
ArchSpec aspec("i686-pc-windows");
lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
SymbolVendor *plugin = module->GetSymbolVendor();
SymbolFile *symfile = plugin->GetSymbolFile();
FileSpec source_file("test-pdb.cpp", false);
FileSpec header1("test-pdb.h", false);
FileSpec header2("test-pdb-nested.h", false);
uint32_t cus = symfile->GetNumCompileUnits();
EXPECT_EQ(2, cus);
SymbolContextList sc_list;
uint32_t scope = lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry;
// First test with line 7, and verify that only line 7 entries are added.
uint32_t count = symfile->ResolveSymbolContext(source_file, 7, true, scope, sc_list);
EXPECT_EQ(1, count);
SymbolContext sc;
EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
LineTable *lt = sc.comp_unit->GetLineTable();
EXPECT_NE(nullptr, lt);
count = lt->GetSize();
// We expect one extra entry for termination
EXPECT_EQ(3, count);
VerifyLineEntry(module, sc, source_file, *lt, 7, 0x401040);
VerifyLineEntry(module, sc, header2, *lt, 7, 0x401089);
sc_list.Clear();
// Then test with line 9, and verify that only line 9 entries are added.
count = symfile->ResolveSymbolContext(source_file, 9, true, scope, sc_list);
EXPECT_EQ(1, count);
EXPECT_TRUE(sc_list.GetContextAtIndex(0, sc));
lt = sc.comp_unit->GetLineTable();
EXPECT_NE(nullptr, lt);
count = lt->GetSize();
// We expect one extra entry for termination
EXPECT_EQ(3, count);
VerifyLineEntry(module, sc, source_file, *lt, 9, 0x401045);
VerifyLineEntry(module, sc, header1, *lt, 9, 0x401090);
}