mirror of
https://github.com/intel/llvm.git
synced 2026-01-14 11:57:39 +08:00
ad2b63cbaa
I changed "m_is_optimized" in lldb_private::CompileUnit over to be a lldb::LazyBool so that it can be set to eLazyBoolCalculate if it needs to be parsed later. With SymbolFileDWARFDebugMap, we don't actually open the DWARF in the .o files for each compile unit until later, and we can't tell if a compile unit is optimized ahead of time. So to avoid pulling in all .o right away just so we can answer the questions of "is this compile unit optimized" we defer it until a point where we will have the compile unit parsed. <rdar://problem/26068360> llvm-svn: 274585
578 lines
16 KiB
C++
578 lines
16 KiB
C++
//===-- SymbolVendor.mm -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Symbol/SymbolVendor.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Symbol/CompileUnit.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolFile.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// FindPlugin
|
|
//
|
|
// Platforms can register a callback to use when creating symbol
|
|
// vendors to allow for complex debug information file setups, and to
|
|
// also allow for finding separate debug information files.
|
|
//----------------------------------------------------------------------
|
|
SymbolVendor*
|
|
SymbolVendor::FindPlugin (const lldb::ModuleSP &module_sp, lldb_private::Stream *feedback_strm)
|
|
{
|
|
std::unique_ptr<SymbolVendor> instance_ap;
|
|
SymbolVendorCreateInstance create_callback;
|
|
|
|
for (size_t idx = 0; (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(idx)) != nullptr; ++idx)
|
|
{
|
|
instance_ap.reset(create_callback(module_sp, feedback_strm));
|
|
|
|
if (instance_ap.get())
|
|
{
|
|
return instance_ap.release();
|
|
}
|
|
}
|
|
// The default implementation just tries to create debug information using the
|
|
// file representation for the module.
|
|
instance_ap.reset(new SymbolVendor(module_sp));
|
|
if (instance_ap.get())
|
|
{
|
|
ObjectFile *objfile = module_sp->GetObjectFile();
|
|
if (objfile)
|
|
instance_ap->AddSymbolFileRepresentation(objfile->shared_from_this());
|
|
}
|
|
return instance_ap.release();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// SymbolVendor constructor
|
|
//----------------------------------------------------------------------
|
|
SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp) :
|
|
ModuleChild (module_sp),
|
|
m_type_list(),
|
|
m_compile_units(),
|
|
m_sym_file_ap()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
SymbolVendor::~SymbolVendor()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Add a representation given an object file.
|
|
//----------------------------------------------------------------------
|
|
void
|
|
SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (objfile_sp)
|
|
{
|
|
m_objfile_sp = objfile_sp;
|
|
m_sym_file_ap.reset(SymbolFile::FindPlugin(objfile_sp.get()));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
SymbolVendor::SetCompileUnitAtIndex (size_t idx, const CompUnitSP &cu_sp)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
const size_t num_compile_units = GetNumCompileUnits();
|
|
if (idx < num_compile_units)
|
|
{
|
|
// Fire off an assertion if this compile unit already exists for now.
|
|
// The partial parsing should take care of only setting the compile
|
|
// unit once, so if this assertion fails, we need to make sure that
|
|
// we don't have a race condition, or have a second parse of the same
|
|
// compile unit.
|
|
assert(m_compile_units[idx].get() == nullptr);
|
|
m_compile_units[idx] = cu_sp;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// This should NOT happen, and if it does, we want to crash and know
|
|
// about it
|
|
assert (idx < num_compile_units);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::GetNumCompileUnits()
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_compile_units.empty())
|
|
{
|
|
if (m_sym_file_ap.get())
|
|
{
|
|
// Resize our array of compile unit shared pointers -- which will
|
|
// each remain NULL until someone asks for the actual compile unit
|
|
// information. When this happens, the symbol file will be asked
|
|
// to parse this compile unit information.
|
|
m_compile_units.resize(m_sym_file_ap->GetNumCompileUnits());
|
|
}
|
|
}
|
|
}
|
|
return m_compile_units.size();
|
|
}
|
|
|
|
lldb::LanguageType
|
|
SymbolVendor::ParseCompileUnitLanguage (const SymbolContext& sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitLanguage(sc);
|
|
}
|
|
return eLanguageTypeUnknown;
|
|
}
|
|
|
|
|
|
size_t
|
|
SymbolVendor::ParseCompileUnitFunctions (const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitFunctions(sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
SymbolVendor::ParseCompileUnitLineTable (const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitLineTable(sc);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SymbolVendor::ParseCompileUnitDebugMacros (const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
|
|
}
|
|
return false;
|
|
}
|
|
bool
|
|
SymbolVendor::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SymbolVendor::ParseCompileUnitIsOptimized(const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseCompileUnitIsOptimized(sc);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SymbolVendor::ParseImportedModules(const SymbolContext &sc, std::vector<ConstString> &imported_modules)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseImportedModules(sc, imported_modules);
|
|
}
|
|
return false;
|
|
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::ParseFunctionBlocks (const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseFunctionBlocks(sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::ParseTypes (const SymbolContext &sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseTypes(sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::ParseVariablesForContext (const SymbolContext& sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ParseVariablesForContext(sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
Type*
|
|
SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ResolveTypeUID(type_uid);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
SymbolVendor::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint32_t
|
|
SymbolVendor::ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, VariableList& variables)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, append, max_matches, variables);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindGlobalVariables (const RegularExpression& regex, bool append, size_t max_matches, VariableList& variables)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindGlobalVariables(regex, append, max_matches, variables);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindFunctions(const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask, include_inlines, append, sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindFunctions(regex, include_inlines, append, sc_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
size_t
|
|
SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, TypeMap& types)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append, max_matches, searched_symbol_files, types);
|
|
}
|
|
if (!append)
|
|
types.Clear();
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::FindTypes (const std::vector<CompilerContext> &context, bool append, TypeMap& types)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->FindTypes(context, append, types);
|
|
}
|
|
if (!append)
|
|
types.Clear();
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
SymbolVendor::GetTypes (SymbolContextScope *sc_scope,
|
|
uint32_t type_mask,
|
|
lldb_private::TypeList &type_list)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
return m_sym_file_ap->GetTypes (sc_scope, type_mask, type_list);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
CompilerDeclContext
|
|
SymbolVendor::FindNamespace(const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx)
|
|
{
|
|
CompilerDeclContext namespace_decl_ctx;
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
if (m_sym_file_ap.get())
|
|
namespace_decl_ctx = m_sym_file_ap->FindNamespace (sc, name, parent_decl_ctx);
|
|
}
|
|
return namespace_decl_ctx;
|
|
}
|
|
|
|
void
|
|
SymbolVendor::Dump(Stream *s)
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
|
|
bool show_context = false;
|
|
|
|
s->Printf("%p: ", static_cast<void*>(this));
|
|
s->Indent();
|
|
s->PutCString("SymbolVendor");
|
|
if (m_sym_file_ap.get())
|
|
{
|
|
ObjectFile *objfile = m_sym_file_ap->GetObjectFile();
|
|
if (objfile)
|
|
{
|
|
const FileSpec &objfile_file_spec = objfile->GetFileSpec();
|
|
if (objfile_file_spec)
|
|
{
|
|
s->PutCString(" (");
|
|
objfile_file_spec.Dump(s);
|
|
s->PutChar(')');
|
|
}
|
|
}
|
|
}
|
|
s->EOL();
|
|
s->IndentMore();
|
|
m_type_list.Dump(s, show_context);
|
|
|
|
CompileUnitConstIter cu_pos, cu_end;
|
|
cu_end = m_compile_units.end();
|
|
for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos)
|
|
{
|
|
// We currently only dump the compile units that have been parsed
|
|
if (cu_pos->get())
|
|
(*cu_pos)->Dump(s, show_context);
|
|
}
|
|
|
|
s->IndentLess();
|
|
}
|
|
}
|
|
|
|
CompUnitSP
|
|
SymbolVendor::GetCompileUnitAtIndex(size_t idx)
|
|
{
|
|
CompUnitSP cu_sp;
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
|
|
const size_t num_compile_units = GetNumCompileUnits();
|
|
if (idx < num_compile_units)
|
|
{
|
|
cu_sp = m_compile_units[idx];
|
|
if (cu_sp.get() == nullptr)
|
|
{
|
|
m_compile_units[idx] = m_sym_file_ap->ParseCompileUnitAtIndex(idx);
|
|
cu_sp = m_compile_units[idx];
|
|
}
|
|
}
|
|
}
|
|
return cu_sp;
|
|
}
|
|
|
|
FileSpec
|
|
SymbolVendor::GetMainFileSpec() const
|
|
{
|
|
if (m_sym_file_ap.get())
|
|
{
|
|
const ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile();
|
|
if (symfile_objfile)
|
|
return symfile_objfile->GetFileSpec();
|
|
}
|
|
|
|
return FileSpec();
|
|
}
|
|
|
|
Symtab *
|
|
SymbolVendor::GetSymtab ()
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
ObjectFile *objfile = module_sp->GetObjectFile();
|
|
if (objfile)
|
|
{
|
|
// Get symbol table from unified section list.
|
|
return objfile->GetSymtab ();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
SymbolVendor::ClearSymtab()
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
ObjectFile *objfile = module_sp->GetObjectFile();
|
|
if (objfile)
|
|
{
|
|
// Clear symbol table from unified section list.
|
|
objfile->ClearSymtab ();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
SymbolVendor::SectionFileAddressesChanged ()
|
|
{
|
|
ModuleSP module_sp(GetModule());
|
|
if (module_sp)
|
|
{
|
|
ObjectFile *module_objfile = module_sp->GetObjectFile ();
|
|
if (m_sym_file_ap.get())
|
|
{
|
|
ObjectFile *symfile_objfile = m_sym_file_ap->GetObjectFile ();
|
|
if (symfile_objfile != module_objfile)
|
|
symfile_objfile->SectionFileAddressesChanged ();
|
|
}
|
|
Symtab *symtab = GetSymtab ();
|
|
if (symtab)
|
|
{
|
|
symtab->SectionFileAddressesChanged ();
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// PluginInterface protocol
|
|
//------------------------------------------------------------------
|
|
lldb_private::ConstString
|
|
SymbolVendor::GetPluginName()
|
|
{
|
|
static ConstString g_name("vendor-default");
|
|
return g_name;
|
|
}
|
|
|
|
uint32_t
|
|
SymbolVendor::GetPluginVersion()
|
|
{
|
|
return 1;
|
|
}
|
|
|