mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-23 13:35:42 -04:00
0c5cd90d63
intelligently. The four name types we currently have are:
eFunctionNameTypeFull = (1 << 1), // The function name.
// For C this is the same as just the name of the function
// For C++ this is the demangled version of the mangled name.
// For ObjC this is the full function signature with the + or
// - and the square brackets and the class and selector
eFunctionNameTypeBase = (1 << 2), // The function name only, no namespaces or arguments and no class
// methods or selectors will be searched.
eFunctionNameTypeMethod = (1 << 3), // Find function by method name (C++) with no namespace or arguments
eFunctionNameTypeSelector = (1 << 4) // Find function by selector name (ObjC) names
this allows much more flexibility when setting breakoints:
(lldb) breakpoint set --name main --basename
(lldb) breakpoint set --name main --fullname
(lldb) breakpoint set --name main --method
(lldb) breakpoint set --name main --selector
The default:
(lldb) breakpoint set --name main
will inspect the name "main" and look for any parens, or if the name starts
with "-[" or "+[" and if any are found then a full name search will happen.
Else a basename search will be the default.
Fixed some command option structures so not all options are required when they
shouldn't be.
Cleaned up the breakpoint output summary.
Made the "image lookup --address <addr>" output much more verbose so it shows
all the important symbol context results. Added a GetDescription method to
many of the SymbolContext objects for the more verbose output.
llvm-svn: 107075
627 lines
18 KiB
C++
627 lines
18 KiB
C++
//===-- ModuleList.cpp ------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/ModuleList.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Host/Symbols.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/VariableList.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// ModuleList constructor
|
|
//----------------------------------------------------------------------
|
|
ModuleList::ModuleList() :
|
|
m_modules(),
|
|
m_modules_mutex (Mutex::eMutexTypeRecursive)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Copy constructor
|
|
//----------------------------------------------------------------------
|
|
ModuleList::ModuleList(const ModuleList& rhs) :
|
|
m_modules(rhs.m_modules)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Assignment operator
|
|
//----------------------------------------------------------------------
|
|
const ModuleList&
|
|
ModuleList::operator= (const ModuleList& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
m_modules = rhs.m_modules;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
ModuleList::~ModuleList()
|
|
{
|
|
}
|
|
|
|
void
|
|
ModuleList::Append (ModuleSP &module_sp)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
m_modules.push_back(module_sp);
|
|
}
|
|
|
|
bool
|
|
ModuleList::AppendInNeeded (ModuleSP &module_sp)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
if (pos->get() == module_sp.get())
|
|
return false; // Already in the list
|
|
}
|
|
// Only push module_sp on the list if it wasn't already in there.
|
|
m_modules.push_back(module_sp);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ModuleList::Remove (ModuleSP &module_sp)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
if (pos->get() == module_sp.get())
|
|
{
|
|
m_modules.erase (pos);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
ModuleList::Clear()
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
m_modules.clear();
|
|
}
|
|
|
|
Module*
|
|
ModuleList::GetModulePointerAtIndex (uint32_t idx) const
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
if (idx < m_modules.size())
|
|
return m_modules[idx].get();
|
|
return NULL;
|
|
}
|
|
|
|
ModuleSP
|
|
ModuleList::GetModuleAtIndex(uint32_t idx)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
ModuleSP module_sp;
|
|
if (idx < m_modules.size())
|
|
module_sp = m_modules[idx];
|
|
return module_sp;
|
|
}
|
|
|
|
size_t
|
|
ModuleList::FindFunctions (const ConstString &name, uint32_t name_type_mask, SymbolContextList &sc_list)
|
|
{
|
|
sc_list.Clear();
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
(*pos)->FindFunctions (name, name_type_mask, true, sc_list);
|
|
}
|
|
return sc_list.GetSize();
|
|
}
|
|
|
|
uint32_t
|
|
ModuleList::FindGlobalVariables (const ConstString &name, bool append, uint32_t max_matches, VariableList& variable_list)
|
|
{
|
|
size_t initial_size = variable_list.GetSize();
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
(*pos)->FindGlobalVariables (name, append, max_matches, variable_list);
|
|
}
|
|
return variable_list.GetSize() - initial_size;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
ModuleList::FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variable_list)
|
|
{
|
|
size_t initial_size = variable_list.GetSize();
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
(*pos)->FindGlobalVariables (regex, append, max_matches, variable_list);
|
|
}
|
|
return variable_list.GetSize() - initial_size;
|
|
}
|
|
|
|
|
|
size_t
|
|
ModuleList::FindSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, SymbolContextList &sc_list)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
sc_list.Clear();
|
|
collection::iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
(*pos)->FindSymbolsWithNameAndType (name, symbol_type, sc_list);
|
|
return sc_list.GetSize();
|
|
}
|
|
|
|
class ModuleMatches
|
|
{
|
|
public:
|
|
//--------------------------------------------------------------
|
|
/// Construct with the user ID to look for.
|
|
//--------------------------------------------------------------
|
|
ModuleMatches (const FileSpec *file_spec_ptr,
|
|
const ArchSpec *arch_ptr,
|
|
const UUID *uuid_ptr,
|
|
const ConstString *object_name) :
|
|
m_file_spec_ptr (file_spec_ptr),
|
|
m_arch_ptr (arch_ptr),
|
|
m_uuid_ptr (uuid_ptr),
|
|
m_object_name (object_name)
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
/// Unary predicate function object callback.
|
|
//--------------------------------------------------------------
|
|
bool
|
|
operator () (const ModuleSP& module_sp) const
|
|
{
|
|
if (m_file_spec_ptr)
|
|
{
|
|
if (!FileSpec::Equal (*m_file_spec_ptr, module_sp->GetFileSpec(), m_file_spec_ptr->GetDirectory()))
|
|
return false;
|
|
}
|
|
|
|
if (m_arch_ptr)
|
|
{
|
|
if (module_sp->GetArchitecture() != *m_arch_ptr)
|
|
return false;
|
|
}
|
|
|
|
if (m_uuid_ptr)
|
|
{
|
|
if (module_sp->GetUUID() != *m_uuid_ptr)
|
|
return false;
|
|
}
|
|
|
|
if (m_object_name)
|
|
{
|
|
if (module_sp->GetObjectName() != *m_object_name)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
//--------------------------------------------------------------
|
|
// Member variables.
|
|
//--------------------------------------------------------------
|
|
const FileSpec * m_file_spec_ptr;
|
|
const ArchSpec * m_arch_ptr;
|
|
const UUID * m_uuid_ptr;
|
|
const ConstString * m_object_name;
|
|
};
|
|
|
|
size_t
|
|
ModuleList::FindModules
|
|
(
|
|
const FileSpec *file_spec_ptr,
|
|
const ArchSpec *arch_ptr,
|
|
const UUID *uuid_ptr,
|
|
const ConstString *object_name,
|
|
ModuleList& matching_module_list
|
|
) const
|
|
{
|
|
size_t existing_matches = matching_module_list.GetSize();
|
|
ModuleMatches matcher (file_spec_ptr, arch_ptr, uuid_ptr, object_name);
|
|
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator end = m_modules.end();
|
|
collection::const_iterator pos;
|
|
|
|
for (pos = std::find_if (m_modules.begin(), end, matcher);
|
|
pos != end;
|
|
pos = std::find_if (++pos, end, matcher))
|
|
{
|
|
ModuleSP module_sp(*pos);
|
|
matching_module_list.Append(module_sp);
|
|
}
|
|
return matching_module_list.GetSize() - existing_matches;
|
|
}
|
|
|
|
ModuleSP
|
|
ModuleList::FindModule (lldb_private::Module *module_ptr)
|
|
{
|
|
ModuleSP module_sp;
|
|
|
|
// Scope for "locker"
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
if ((*pos).get() == module_ptr)
|
|
{
|
|
module_sp = (*pos);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return module_sp;
|
|
|
|
}
|
|
|
|
|
|
ModuleSP
|
|
ModuleList::FindFirstModuleForFileSpec (const FileSpec &file_spec, const ConstString *object_name)
|
|
{
|
|
ModuleSP module_sp;
|
|
ModuleMatches matcher (&file_spec, NULL, NULL, NULL);
|
|
|
|
// Scope for "locker"
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator end = m_modules.end();
|
|
collection::const_iterator pos = m_modules.begin();
|
|
|
|
pos = std::find_if (pos, end, matcher);
|
|
if (pos != end)
|
|
module_sp = (*pos);
|
|
}
|
|
return module_sp;
|
|
|
|
}
|
|
|
|
|
|
size_t
|
|
ModuleList::GetSize() const
|
|
{
|
|
size_t size = 0;
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
size = m_modules.size();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
|
|
void
|
|
ModuleList::Dump(Stream *s) const
|
|
{
|
|
// s.Printf("%.*p: ", (int)sizeof(void*) * 2, this);
|
|
// s.Indent();
|
|
// s << "ModuleList\n";
|
|
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
(*pos)->Dump(s);
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
ModuleList::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
if ((*pos)->ResolveFileAddress (vm_addr, so_addr))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32_t
|
|
ModuleList::ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
|
|
{
|
|
// The address is already section offset so it has a module
|
|
uint32_t resolved_flags = 0;
|
|
Module *module = so_addr.GetModule();
|
|
if (module)
|
|
{
|
|
resolved_flags = module->ResolveSymbolContextForAddress (so_addr,
|
|
resolve_scope,
|
|
sc);
|
|
}
|
|
else
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
resolved_flags = (*pos)->ResolveSymbolContextForAddress (so_addr,
|
|
resolve_scope,
|
|
sc);
|
|
if (resolved_flags != 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return resolved_flags;
|
|
}
|
|
|
|
uint32_t
|
|
ModuleList::ResolveSymbolContextForFilePath (const char *file_path, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
|
|
{
|
|
FileSpec file_spec(file_path);
|
|
return ResolveSymbolContextsForFileSpec (file_spec, line, check_inlines, resolve_scope, sc_list);
|
|
}
|
|
|
|
uint32_t
|
|
ModuleList::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos, end = m_modules.end();
|
|
for (pos = m_modules.begin(); pos != end; ++pos)
|
|
{
|
|
(*pos)->ResolveSymbolContextsForFileSpec (file_spec, line, check_inlines, resolve_scope, sc_list);
|
|
}
|
|
|
|
return sc_list.GetSize();
|
|
}
|
|
|
|
uint32_t
|
|
ModuleList::GetIndexForModule (const Module *module) const
|
|
{
|
|
if (module)
|
|
{
|
|
Mutex::Locker locker(m_modules_mutex);
|
|
collection::const_iterator pos;
|
|
collection::const_iterator begin = m_modules.begin();
|
|
collection::const_iterator end = m_modules.end();
|
|
for (pos = begin; pos != end; ++pos)
|
|
{
|
|
if ((*pos).get() == module)
|
|
return std::distance (begin, pos);
|
|
}
|
|
}
|
|
return LLDB_INVALID_INDEX32;
|
|
}
|
|
|
|
static ModuleList &
|
|
GetSharedModuleList ()
|
|
{
|
|
static ModuleList g_shared_module_list;
|
|
return g_shared_module_list;
|
|
}
|
|
|
|
const lldb::ModuleSP
|
|
ModuleList::GetModuleSP (lldb_private::Module *module_ptr)
|
|
{
|
|
lldb::ModuleSP module_sp;
|
|
if (module_ptr)
|
|
{
|
|
ModuleList &shared_module_list = GetSharedModuleList ();
|
|
module_sp = shared_module_list.FindModule (module_ptr);
|
|
assert (module_sp.get()); // This might fire off a few times and we need to make sure it never fires...
|
|
}
|
|
return module_sp;
|
|
}
|
|
|
|
|
|
Error
|
|
ModuleList::GetSharedModule
|
|
(
|
|
const FileSpec& in_file_spec,
|
|
const ArchSpec& arch,
|
|
const UUID *uuid_ptr,
|
|
const ConstString *object_name_ptr,
|
|
off_t object_offset,
|
|
ModuleSP &module_sp,
|
|
ModuleSP *old_module_sp_ptr,
|
|
bool *did_create_ptr
|
|
)
|
|
{
|
|
ModuleList &shared_module_list = GetSharedModuleList ();
|
|
char path[PATH_MAX];
|
|
char uuid_cstr[64];
|
|
|
|
Error error;
|
|
|
|
module_sp.reset();
|
|
|
|
if (did_create_ptr)
|
|
*did_create_ptr = false;
|
|
if (old_module_sp_ptr)
|
|
old_module_sp_ptr->reset();
|
|
|
|
|
|
// First just try and get the file where it purports to be (path in
|
|
// in_file_spec), then check and uuid.
|
|
|
|
if (in_file_spec)
|
|
{
|
|
// Make sure no one else can try and get or create a module while this
|
|
// function is actively working on it by doing an extra lock on the
|
|
// global mutex list.
|
|
ModuleList matching_module_list;
|
|
Mutex::Locker locker(shared_module_list.m_modules_mutex);
|
|
if (shared_module_list.FindModules (&in_file_spec, &arch, uuid_ptr, object_name_ptr, matching_module_list) > 0)
|
|
{
|
|
module_sp = matching_module_list.GetModuleAtIndex(0);
|
|
|
|
// If we didn't have a UUID in mind when looking for the object file,
|
|
// then we should make sure the modification time hasn't changed!
|
|
if (uuid_ptr == NULL)
|
|
{
|
|
TimeValue file_spec_mod_time(in_file_spec.GetModificationTime());
|
|
if (file_spec_mod_time.IsValid())
|
|
{
|
|
if (file_spec_mod_time != module_sp->GetModificationTime())
|
|
{
|
|
if (old_module_sp_ptr)
|
|
*old_module_sp_ptr = module_sp;
|
|
shared_module_list.Remove (module_sp);
|
|
module_sp.reset();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (module_sp.get() == NULL)
|
|
{
|
|
module_sp.reset (new Module (in_file_spec, arch, object_name_ptr, object_offset));
|
|
if (module_sp)
|
|
{
|
|
// If we get in here we got the correct arch, now we just need
|
|
// to verify the UUID if one was given
|
|
if (uuid_ptr && *uuid_ptr != module_sp->GetUUID())
|
|
module_sp.reset();
|
|
else
|
|
{
|
|
if (did_create_ptr)
|
|
*did_create_ptr = true;
|
|
|
|
shared_module_list.Append(module_sp);
|
|
return error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Either the file didn't exist where at the path, or no path was given, so
|
|
// we now have to use more extreme measures to try and find the appropriate
|
|
// module.
|
|
|
|
// Fixup the incoming path in case the path points to a valid file, yet
|
|
// the arch or UUID (if one was passed in) don't match.
|
|
FileSpec file_spec = Symbols::LocateExecutableObjectFile (&in_file_spec, arch.IsValid() ? &arch : NULL, uuid_ptr);
|
|
|
|
// Don't look for the file if it appears to be the same one we already
|
|
// checked for above...
|
|
if (file_spec != in_file_spec)
|
|
{
|
|
if (!file_spec.Exists())
|
|
{
|
|
file_spec.GetPath(path, sizeof(path));
|
|
if (file_spec.Exists())
|
|
{
|
|
if (uuid_ptr && uuid_ptr->IsValid())
|
|
uuid_ptr->GetAsCString(uuid_cstr, sizeof (uuid_cstr));
|
|
else
|
|
uuid_cstr[0] = '\0';
|
|
|
|
|
|
if (arch.IsValid())
|
|
{
|
|
if (uuid_cstr[0])
|
|
error.SetErrorStringWithFormat("'%s' does not contain the %s architecture and UUID %s.\n", path, arch.AsCString(), uuid_cstr[0]);
|
|
else
|
|
error.SetErrorStringWithFormat("'%s' does not contain the %s architecture.\n", path, arch.AsCString());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.SetErrorStringWithFormat("'%s' does not exist.\n", path);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
|
|
// Make sure no one else can try and get or create a module while this
|
|
// function is actively working on it by doing an extra lock on the
|
|
// global mutex list.
|
|
Mutex::Locker locker(shared_module_list.m_modules_mutex);
|
|
ModuleList matching_module_list;
|
|
if (shared_module_list.FindModules (&file_spec, &arch, uuid_ptr, object_name_ptr, matching_module_list) > 0)
|
|
{
|
|
module_sp = matching_module_list.GetModuleAtIndex(0);
|
|
|
|
// If we didn't have a UUID in mind when looking for the object file,
|
|
// then we should make sure the modification time hasn't changed!
|
|
if (uuid_ptr == NULL)
|
|
{
|
|
TimeValue file_spec_mod_time(file_spec.GetModificationTime());
|
|
if (file_spec_mod_time.IsValid())
|
|
{
|
|
if (file_spec_mod_time != module_sp->GetModificationTime())
|
|
{
|
|
if (old_module_sp_ptr)
|
|
*old_module_sp_ptr = module_sp;
|
|
shared_module_list.Remove (module_sp);
|
|
module_sp.reset();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (module_sp.get() == NULL)
|
|
{
|
|
module_sp.reset (new Module (file_spec, arch, object_name_ptr, object_offset));
|
|
if (module_sp)
|
|
{
|
|
if (did_create_ptr)
|
|
*did_create_ptr = true;
|
|
|
|
shared_module_list.Append(module_sp);
|
|
}
|
|
else
|
|
{
|
|
file_spec.GetPath(path, sizeof(path));
|
|
|
|
if (file_spec)
|
|
{
|
|
if (arch.IsValid())
|
|
error.SetErrorStringWithFormat("Unable to open %s architecture in '%s'.\n", arch.AsCString(), path);
|
|
else
|
|
error.SetErrorStringWithFormat("Unable to open '%s'.\n", path);
|
|
}
|
|
else
|
|
{
|
|
if (uuid_ptr && uuid_ptr->IsValid())
|
|
uuid_ptr->GetAsCString(uuid_cstr, sizeof (uuid_cstr));
|
|
else
|
|
uuid_cstr[0] = '\0';
|
|
|
|
if (uuid_cstr[0])
|
|
error.SetErrorStringWithFormat("Cannot locate a module for UUID '%s'.\n", uuid_cstr[0]);
|
|
else
|
|
error.SetErrorStringWithFormat("Cannot locate a module.\n", path, arch.AsCString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|