2010-09-15 07:52:43 +08:00
|
|
|
//===-- SectionLoadList.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/Target/SectionLoadList.h"
|
|
|
|
|
|
|
|
// C Includes
|
|
|
|
// C++ Includes
|
|
|
|
// Other libraries and framework includes
|
|
|
|
// Project includes
|
|
|
|
#include "lldb/Core/Log.h"
|
|
|
|
#include "lldb/Core/Module.h"
|
|
|
|
#include "lldb/Core/Section.h"
|
|
|
|
#include "lldb/Core/Stream.h"
|
|
|
|
#include "lldb/Symbol/Block.h"
|
|
|
|
#include "lldb/Symbol/Symbol.h"
|
|
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
|
2013-12-06 09:12:00 +08:00
|
|
|
SectionLoadList::SectionLoadList (const SectionLoadList& rhs) :
|
|
|
|
m_addr_to_sect(),
|
|
|
|
m_sect_to_addr(),
|
|
|
|
m_mutex (Mutex::eMutexTypeRecursive)
|
|
|
|
{
|
|
|
|
Mutex::Locker locker(rhs.m_mutex);
|
|
|
|
m_addr_to_sect = rhs.m_addr_to_sect;
|
|
|
|
m_sect_to_addr = rhs.m_sect_to_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SectionLoadList::operator=(const SectionLoadList &rhs)
|
|
|
|
{
|
|
|
|
Mutex::Locker lhs_locker (m_mutex);
|
|
|
|
Mutex::Locker rhs_locker (rhs.m_mutex);
|
|
|
|
m_addr_to_sect = rhs.m_addr_to_sect;
|
|
|
|
m_sect_to_addr = rhs.m_sect_to_addr;
|
|
|
|
}
|
|
|
|
|
2010-09-15 07:52:43 +08:00
|
|
|
bool
|
|
|
|
SectionLoadList::IsEmpty() const
|
|
|
|
{
|
2010-12-08 13:08:21 +08:00
|
|
|
Mutex::Locker locker(m_mutex);
|
2011-02-05 10:25:06 +08:00
|
|
|
return m_addr_to_sect.empty();
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SectionLoadList::Clear ()
|
|
|
|
{
|
2010-12-08 13:08:21 +08:00
|
|
|
Mutex::Locker locker(m_mutex);
|
2011-02-05 10:25:06 +08:00
|
|
|
m_addr_to_sect.clear();
|
|
|
|
m_sect_to_addr.clear();
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
addr_t
|
2012-07-07 09:24:12 +08:00
|
|
|
SectionLoadList::GetSectionLoadAddress (const lldb::SectionSP §ion) const
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
|
|
|
// TODO: add support for the same section having multiple load addresses
|
|
|
|
addr_t section_load_addr = LLDB_INVALID_ADDRESS;
|
2010-12-08 13:08:21 +08:00
|
|
|
if (section)
|
|
|
|
{
|
|
|
|
Mutex::Locker locker(m_mutex);
|
2012-07-07 09:24:12 +08:00
|
|
|
sect_to_addr_collection::const_iterator pos = m_sect_to_addr.find (section.get());
|
2011-02-05 10:25:06 +08:00
|
|
|
|
|
|
|
if (pos != m_sect_to_addr.end())
|
|
|
|
section_load_addr = pos->second;
|
2010-12-08 13:08:21 +08:00
|
|
|
}
|
|
|
|
return section_load_addr;
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2012-07-07 09:24:12 +08:00
|
|
|
SectionLoadList::SetSectionLoadAddress (const lldb::SectionSP §ion, addr_t load_addr, bool warn_multiple)
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
|
2010-09-15 07:52:43 +08:00
|
|
|
|
2013-08-13 09:42:25 +08:00
|
|
|
ModuleSP module_sp (section->GetModule());
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2013-08-13 09:42:25 +08:00
|
|
|
if (module_sp)
|
2010-12-14 10:59:59 +08:00
|
|
|
{
|
2013-08-13 09:42:25 +08:00
|
|
|
if (log)
|
|
|
|
{
|
|
|
|
const FileSpec &module_file_spec (module_sp->GetFileSpec());
|
|
|
|
log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16" PRIx64 ") module = %p",
|
2014-04-04 12:06:10 +08:00
|
|
|
__FUNCTION__, static_cast<void*>(section.get()),
|
2013-08-13 09:42:25 +08:00
|
|
|
module_file_spec.GetPath().c_str(),
|
2014-04-04 12:06:10 +08:00
|
|
|
section->GetName().AsCString(), load_addr,
|
|
|
|
static_cast<void*>(module_sp.get()));
|
2013-08-13 09:42:25 +08:00
|
|
|
}
|
2010-09-15 07:52:43 +08:00
|
|
|
|
2013-08-13 09:42:25 +08:00
|
|
|
if (section->GetByteSize() == 0)
|
|
|
|
return false; // No change
|
2012-02-14 07:10:39 +08:00
|
|
|
|
2013-08-13 09:42:25 +08:00
|
|
|
// Fill in the section -> load_addr map
|
|
|
|
Mutex::Locker locker(m_mutex);
|
|
|
|
sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section.get());
|
|
|
|
if (sta_pos != m_sect_to_addr.end())
|
|
|
|
{
|
|
|
|
if (load_addr == sta_pos->second)
|
|
|
|
return false; // No change...
|
|
|
|
else
|
|
|
|
sta_pos->second = load_addr;
|
|
|
|
}
|
2010-12-08 13:08:21 +08:00
|
|
|
else
|
2013-08-13 09:42:25 +08:00
|
|
|
m_sect_to_addr[section.get()] = load_addr;
|
2011-02-05 10:25:06 +08:00
|
|
|
|
2013-08-13 09:42:25 +08:00
|
|
|
// Fill in the load_addr -> section map
|
|
|
|
addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
|
|
|
|
if (ats_pos != m_addr_to_sect.end())
|
2012-02-14 07:10:39 +08:00
|
|
|
{
|
2013-08-13 09:42:25 +08:00
|
|
|
// Some sections are ok to overlap, and for others we should warn. When
|
|
|
|
// we have multiple load addresses that correspond to a section, we will
|
2014-07-09 02:05:41 +08:00
|
|
|
// always attribute the section to the be last section that claims it
|
2013-08-13 09:42:25 +08:00
|
|
|
// exists at that address. Sometimes it is ok for more that one section
|
|
|
|
// to be loaded at a specific load address, and other times it isn't.
|
|
|
|
// The "warn_multiple" parameter tells us if we should warn in this case
|
|
|
|
// or not. The DynamicLoader plug-in subclasses should know which
|
|
|
|
// sections should warn and which shouldn't (darwin shared cache modules
|
|
|
|
// all shared the same "__LINKEDIT" sections, so the dynamic loader can
|
|
|
|
// pass false for "warn_multiple").
|
|
|
|
if (warn_multiple && section != ats_pos->second)
|
2012-02-14 07:10:39 +08:00
|
|
|
{
|
2013-08-13 09:42:25 +08:00
|
|
|
ModuleSP module_sp (section->GetModule());
|
|
|
|
if (module_sp)
|
2012-07-31 08:31:32 +08:00
|
|
|
{
|
2013-08-13 09:42:25 +08:00
|
|
|
ModuleSP curr_module_sp (ats_pos->second->GetModule());
|
|
|
|
if (curr_module_sp)
|
|
|
|
{
|
|
|
|
module_sp->ReportWarning ("address 0x%16.16" PRIx64 " maps to more than one section: %s.%s and %s.%s",
|
|
|
|
load_addr,
|
|
|
|
module_sp->GetFileSpec().GetFilename().GetCString(),
|
|
|
|
section->GetName().GetCString(),
|
|
|
|
curr_module_sp->GetFileSpec().GetFilename().GetCString(),
|
|
|
|
ats_pos->second->GetName().GetCString());
|
|
|
|
}
|
2012-07-31 08:31:32 +08:00
|
|
|
}
|
2012-02-14 07:10:39 +08:00
|
|
|
}
|
2013-08-13 09:42:25 +08:00
|
|
|
ats_pos->second = section;
|
2012-02-14 07:10:39 +08:00
|
|
|
}
|
2013-08-13 09:42:25 +08:00
|
|
|
else
|
|
|
|
m_addr_to_sect[load_addr] = section;
|
|
|
|
return true; // Changed
|
|
|
|
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
2011-02-05 10:25:06 +08:00
|
|
|
else
|
2013-08-13 09:42:25 +08:00
|
|
|
{
|
|
|
|
if (log)
|
|
|
|
{
|
|
|
|
log->Printf ("SectionLoadList::%s (section = %p (%s), load_addr = 0x%16.16" PRIx64 ") error: module has been deleted",
|
2014-04-04 12:06:10 +08:00
|
|
|
__FUNCTION__, static_cast<void*>(section.get()),
|
2013-08-13 09:42:25 +08:00
|
|
|
section->GetName().AsCString(),
|
|
|
|
load_addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
2012-07-07 09:24:12 +08:00
|
|
|
SectionLoadList::SetSectionUnloaded (const lldb::SectionSP §ion_sp)
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
2012-07-07 09:24:12 +08:00
|
|
|
size_t unload_count = 0;
|
2010-09-15 07:52:43 +08:00
|
|
|
|
2012-07-07 09:24:12 +08:00
|
|
|
if (section_sp)
|
2010-12-14 10:59:59 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
|
2010-09-15 07:52:43 +08:00
|
|
|
|
2012-07-07 09:24:12 +08:00
|
|
|
if (log)
|
|
|
|
{
|
2016-01-30 04:21:33 +08:00
|
|
|
ModuleSP module_sp = section_sp->GetModule();
|
|
|
|
std::string module_name("<Unknown>");
|
|
|
|
if (module_sp)
|
|
|
|
{
|
|
|
|
const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
|
|
|
|
module_name = module_file_spec.GetPath();
|
|
|
|
}
|
2013-04-30 01:25:54 +08:00
|
|
|
log->Printf ("SectionLoadList::%s (section = %p (%s.%s))",
|
2014-04-04 12:06:10 +08:00
|
|
|
__FUNCTION__, static_cast<void*>(section_sp.get()),
|
2016-01-30 04:21:33 +08:00
|
|
|
module_name.c_str(),
|
2012-07-07 09:24:12 +08:00
|
|
|
section_sp->GetName().AsCString());
|
|
|
|
}
|
2011-02-05 10:25:06 +08:00
|
|
|
|
2012-07-07 09:24:12 +08:00
|
|
|
Mutex::Locker locker(m_mutex);
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2012-07-07 09:24:12 +08:00
|
|
|
sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
|
|
|
|
if (sta_pos != m_sect_to_addr.end())
|
|
|
|
{
|
2013-01-29 09:17:09 +08:00
|
|
|
++unload_count;
|
2012-07-07 09:24:12 +08:00
|
|
|
addr_t load_addr = sta_pos->second;
|
|
|
|
m_sect_to_addr.erase (sta_pos);
|
|
|
|
|
|
|
|
addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
|
|
|
|
if (ats_pos != m_addr_to_sect.end())
|
|
|
|
m_addr_to_sect.erase (ats_pos);
|
|
|
|
}
|
2011-02-05 10:25:06 +08:00
|
|
|
}
|
2010-09-15 07:52:43 +08:00
|
|
|
return unload_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2012-07-07 09:24:12 +08:00
|
|
|
SectionLoadList::SetSectionUnloaded (const lldb::SectionSP §ion_sp, addr_t load_addr)
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
2013-03-28 07:08:40 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
|
2010-09-15 07:52:43 +08:00
|
|
|
|
|
|
|
if (log)
|
2010-12-14 10:59:59 +08:00
|
|
|
{
|
2016-01-30 04:21:33 +08:00
|
|
|
ModuleSP module_sp = section_sp->GetModule();
|
|
|
|
std::string module_name("<Unknown>");
|
|
|
|
if (module_sp)
|
|
|
|
{
|
|
|
|
const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
|
|
|
|
module_name = module_file_spec.GetPath();
|
|
|
|
}
|
2013-04-30 01:25:54 +08:00
|
|
|
log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16" PRIx64 ")",
|
2014-04-04 12:06:10 +08:00
|
|
|
__FUNCTION__, static_cast<void*>(section_sp.get()),
|
2016-01-30 04:21:33 +08:00
|
|
|
module_name.c_str(),
|
2014-04-04 12:06:10 +08:00
|
|
|
section_sp->GetName().AsCString(), load_addr);
|
2010-12-14 10:59:59 +08:00
|
|
|
}
|
2011-02-05 10:25:06 +08:00
|
|
|
bool erased = false;
|
2010-12-08 13:08:21 +08:00
|
|
|
Mutex::Locker locker(m_mutex);
|
2012-07-07 09:24:12 +08:00
|
|
|
sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
|
2011-02-05 10:25:06 +08:00
|
|
|
if (sta_pos != m_sect_to_addr.end())
|
|
|
|
{
|
|
|
|
erased = true;
|
|
|
|
m_sect_to_addr.erase (sta_pos);
|
|
|
|
}
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2011-02-05 10:25:06 +08:00
|
|
|
addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
|
|
|
|
if (ats_pos != m_addr_to_sect.end())
|
|
|
|
{
|
|
|
|
erased = true;
|
|
|
|
m_addr_to_sect.erase (ats_pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
return erased;
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool
|
|
|
|
SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
|
|
|
|
{
|
2010-12-08 13:08:21 +08:00
|
|
|
// First find the top level section that this load address exists in
|
|
|
|
Mutex::Locker locker(m_mutex);
|
2011-05-18 02:13:59 +08:00
|
|
|
if (!m_addr_to_sect.empty())
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
2011-05-18 02:13:59 +08:00
|
|
|
addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);
|
|
|
|
if (pos != m_addr_to_sect.end())
|
2010-09-15 07:52:43 +08:00
|
|
|
{
|
2011-05-18 02:13:59 +08:00
|
|
|
if (load_addr != pos->first && pos != m_addr_to_sect.begin())
|
|
|
|
--pos;
|
2013-02-02 05:38:35 +08:00
|
|
|
const addr_t pos_load_addr = pos->first;
|
|
|
|
if (load_addr >= pos_load_addr)
|
2010-12-22 10:02:45 +08:00
|
|
|
{
|
2013-02-02 05:38:35 +08:00
|
|
|
addr_t offset = load_addr - pos_load_addr;
|
2011-05-18 02:13:59 +08:00
|
|
|
if (offset < pos->second->GetByteSize())
|
|
|
|
{
|
|
|
|
// We have found the top level section, now we need to find the
|
|
|
|
// deepest child section.
|
|
|
|
return pos->second->ResolveContainedAddress (offset, so_addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-05-19 02:22:47 +08:00
|
|
|
// There are no entries that have an address that is >= load_addr,
|
|
|
|
// so we need to check the last entry on our collection.
|
|
|
|
addr_to_sect_collection::const_reverse_iterator rpos = m_addr_to_sect.rbegin();
|
|
|
|
if (load_addr >= rpos->first)
|
2011-05-18 02:13:59 +08:00
|
|
|
{
|
2011-05-19 02:22:47 +08:00
|
|
|
addr_t offset = load_addr - rpos->first;
|
|
|
|
if (offset < rpos->second->GetByteSize())
|
2011-05-18 02:13:59 +08:00
|
|
|
{
|
|
|
|
// We have found the top level section, now we need to find the
|
|
|
|
// deepest child section.
|
2011-05-19 02:22:47 +08:00
|
|
|
return rpos->second->ResolveContainedAddress (offset, so_addr);
|
2011-05-18 02:13:59 +08:00
|
|
|
}
|
2010-12-22 10:02:45 +08:00
|
|
|
}
|
2010-09-15 07:52:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
so_addr.Clear();
|
|
|
|
return false;
|
|
|
|
}
|
2010-12-08 13:08:21 +08:00
|
|
|
|
|
|
|
void
|
|
|
|
SectionLoadList::Dump (Stream &s, Target *target)
|
|
|
|
{
|
|
|
|
Mutex::Locker locker(m_mutex);
|
2011-02-05 10:25:06 +08:00
|
|
|
addr_to_sect_collection::const_iterator pos, end;
|
|
|
|
for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
|
2010-12-08 13:08:21 +08:00
|
|
|
{
|
2014-04-04 12:06:10 +08:00
|
|
|
s.Printf("addr = 0x%16.16" PRIx64 ", section = %p: ",
|
|
|
|
pos->first, static_cast<void*>(pos->second.get()));
|
2010-12-08 13:08:21 +08:00
|
|
|
pos->second->Dump (&s, target, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|