caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bec49efdf2d7fe33a064a3e9faffa7704df87593
clang-p2996/lldb/source/Core/Section.cpp
Greg Clayton 741f3f9a55 lldb_private::Section objects have a boolean flag that can be set that 
indicates that the section is thread specific. Any functions the load a module
given a slide, will currently ignore any sections that are thread specific.

lldb_private::Section now has:

bool
Section::IsThreadSpecific () const
{
    return m_thread_specific;
}

void
Section::SetIsThreadSpecific (bool b)
{
    m_thread_specific = b;
}

The ELF plug-in has been modified to set this for the ".tdata" and the ".tbss"
sections.

Eventually we need to have each lldb_private::Thread subclass be able to 
resolve a thread specific section, but for now they will just not resolve. The
code for that should be trivual to add, but the address resolving functions
will need to be changed to take a "ExecutionContext" object instead of just
a target so that thread specific sections can be resolved.

llvm-svn: 153537
2012-03-27 21:10:07 +00:00

634 lines
17 KiB
C++
Raw Blame History

//===-- Section.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/Section.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
Section::Section (const ModuleSP &module_sp,
user_id_t sect_id,
const ConstString &name,
SectionType sect_type,
addr_t file_addr,
addr_t byte_size,
uint64_t file_offset,
uint64_t file_size,
uint32_t flags) :
ModuleChild (module_sp),
UserID (sect_id),
Flags (flags),
m_parent_wp (),
m_name (name),
m_type (sect_type),
m_file_addr (file_addr),
m_byte_size (byte_size),
m_file_offset (file_offset),
m_file_size (file_size),
m_children (),
m_fake (false),
m_encrypted (false),
m_thread_specific (false),
m_linked_section_wp(),
m_linked_offset (0)
{
// printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16llx, addr=[0x%16.16llx - 0x%16.16llx), file [0x%16.16llx - 0x%16.16llx), flags = 0x%8.8x, name = %s\n",
// this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, name.GetCString());
}
Section::Section (const lldb::SectionSP &parent_section_sp,
const ModuleSP &module_sp,
user_id_t sect_id,
const ConstString &name,
SectionType sect_type,
addr_t file_addr,
addr_t byte_size,
uint64_t file_offset,
uint64_t file_size,
uint32_t flags) :
ModuleChild (module_sp),
UserID (sect_id),
Flags (flags),
m_parent_wp (),
m_name (name),
m_type (sect_type),
m_file_addr (file_addr),
m_byte_size (byte_size),
m_file_offset (file_offset),
m_file_size (file_size),
m_children (),
m_fake (false),
m_encrypted (false),
m_thread_specific (false),
m_linked_section_wp(),
m_linked_offset (0)
{
// printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16llx, addr=[0x%16.16llx - 0x%16.16llx), file [0x%16.16llx - 0x%16.16llx), flags = 0x%8.8x, name = %s.%s\n",
// this, module_sp.get(), sect_id, file_addr, file_addr + byte_size, file_offset, file_offset + file_size, flags, parent_section_sp->GetName().GetCString(), name.GetCString());
if (parent_section_sp)
m_parent_wp = parent_section_sp;
}
Section::~Section()
{
// printf ("Section::~Section(%p)\n", this);
}
const ConstString&
Section::GetName() const
{
SectionSP linked_section_sp (m_linked_section_wp.lock());
if (linked_section_sp)
return linked_section_sp->GetName();
return m_name;
}
addr_t
Section::GetFileAddress () const
{
SectionSP parent_sp (GetParent ());
if (parent_sp)
{
// This section has a parent which means m_file_addr is an offset into
// the parent section, so the file address for this section is the file
// address of the parent plus the offset
return parent_sp->GetFileAddress() + m_file_addr;
}
// This section has no parent, so m_file_addr is the file base address
return m_file_addr;
}
lldb::addr_t
Section::GetOffset () const
{
// This section has a parent which means m_file_addr is an offset.
SectionSP parent_sp (GetParent ());
if (parent_sp)
return m_file_addr;
// This section has no parent, so there is no offset to be had
return 0;
}
addr_t
Section::GetLinkedFileAddress () const
{
SectionSP linked_section_sp (m_linked_section_wp.lock());
if (linked_section_sp)
return linked_section_sp->GetFileAddress() + m_linked_offset;
return LLDB_INVALID_ADDRESS;
}
addr_t
Section::GetLoadBaseAddress (Target *target) const
{
addr_t load_base_addr = LLDB_INVALID_ADDRESS;
SectionSP linked_section_sp (m_linked_section_wp.lock());
if (linked_section_sp)
{
load_base_addr = linked_section_sp->GetLoadBaseAddress(target);
if (load_base_addr != LLDB_INVALID_ADDRESS)
load_base_addr += m_linked_offset;
}
else
{
SectionSP parent_sp (GetParent ());
if (parent_sp)
{
load_base_addr = parent_sp->GetLoadBaseAddress (target);
if (load_base_addr != LLDB_INVALID_ADDRESS)
load_base_addr += GetOffset();
}
else
{
load_base_addr = target->GetSectionLoadList().GetSectionLoadAddress (this);
}
}
return load_base_addr;
}
bool
Section::ResolveContainedAddress (addr_t offset, Address &so_addr) const
{
const uint32_t num_children = m_children.GetSize();
if (num_children > 0)
{
for (uint32_t i=0; i<num_children; i++)
{
Section* child_section = m_children.GetSectionAtIndex (i).get();
addr_t child_offset = child_section->GetOffset();
if (child_offset <= offset && offset - child_offset < child_section->GetByteSize())
return child_section->ResolveContainedAddress (offset - child_offset, so_addr);
}
}
SectionSP linked_section_sp (m_linked_section_wp.lock());
if (linked_section_sp)
{
so_addr.SetOffset(m_linked_offset + offset);
so_addr.SetSection(linked_section_sp);
}
else
{
so_addr.SetOffset(offset);
so_addr.SetSection(const_cast<Section *>(this)->shared_from_this());
}
return true;
}
bool
Section::ContainsFileAddress (addr_t vm_addr) const
{
const addr_t file_addr = GetFileAddress();
if (file_addr != LLDB_INVALID_ADDRESS)
{
if (file_addr <= vm_addr)
{
const addr_t offset = vm_addr - file_addr;
return offset < GetByteSize();
}
}
return false;
}
bool
Section::ContainsLinkedFileAddress (addr_t vm_addr) const
{
const addr_t linked_file_addr = GetLinkedFileAddress();
if (linked_file_addr != LLDB_INVALID_ADDRESS)
{
if (linked_file_addr <= vm_addr)
{
const addr_t offset = vm_addr - linked_file_addr;
return offset < GetByteSize();
}
}
return false;
}
int
Section::Compare (const Section& a, const Section& b)
{
if (&a == &b)
return 0;
const ModuleSP a_module_sp = a.GetModule();
const ModuleSP b_module_sp = b.GetModule();
if (a_module_sp == b_module_sp)
{
user_id_t a_sect_uid = a.GetID();
user_id_t b_sect_uid = b.GetID();
if (a_sect_uid < b_sect_uid)
return -1;
if (a_sect_uid > b_sect_uid)
return 1;
return 0;
}
else
{
// The modules are different, just compare the module pointers
if (a_module_sp.get() < b_module_sp.get())
return -1;
else
return 1; // We already know the modules aren't equal
}
}
void
Section::Dump (Stream *s, Target *target, uint32_t depth) const
{
// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
s->Indent();
s->Printf("0x%8.8llx %-16s ", GetID(), GetSectionTypeAsCString (m_type));
bool resolved = true;
addr_t addr = LLDB_INVALID_ADDRESS;
SectionSP linked_section_sp (m_linked_section_wp.lock());
if (GetByteSize() == 0)
s->Printf("%39s", "");
else
{
if (target && linked_section_sp.get() == NULL)
addr = GetLoadBaseAddress (target);
if (addr == LLDB_INVALID_ADDRESS)
{
if (target)
resolved = false;
addr = GetFileAddress();
}
VMRange range(addr, addr + m_byte_size);
range.Dump (s, 0);
}
s->Printf("%c 0x%8.8llx 0x%8.8llx 0x%8.8x ", resolved ? ' ' : '*', m_file_offset, m_file_size, Get());
DumpName (s);
s->EOL();
if (linked_section_sp)
{
addr = LLDB_INVALID_ADDRESS;
resolved = true;
if (target)
{
addr = linked_section_sp->GetLoadBaseAddress(target);
if (addr != LLDB_INVALID_ADDRESS)
addr += m_linked_offset;
}
if (addr == LLDB_INVALID_ADDRESS)
{
if (target)
resolved = false;
addr = linked_section_sp->GetFileAddress() + m_linked_offset;
}
int indent = 26 + s->GetIndentLevel();
s->Printf("%*.*s", indent, indent, "");
VMRange linked_range(addr, addr + m_byte_size);
linked_range.Dump (s, 0);
indent = 3 * (sizeof(uint32_t) * 2 + 2 + 1) + 1;
s->Printf("%c%*.*s", resolved ? ' ' : '*', indent, indent, "");
linked_section_sp->DumpName(s);
s->Printf(" + 0x%llx\n", m_linked_offset);
}
if (depth > 0)
m_children.Dump(s, target, false, depth - 1);
}
void
Section::DumpName (Stream *s) const
{
SectionSP parent_sp (GetParent ());
if (parent_sp)
{
parent_sp->DumpName (s);
s->PutChar('.');
}
else
{
// The top most section prints the module basename
ModuleSP module_sp (GetModule());
if (module_sp)
{
const char *module_basename = module_sp->GetFileSpec().GetFilename().AsCString();
if (module_basename && module_basename[0])
s->Printf("%s.", module_basename);
}
}
m_name.Dump(s);
}
bool
Section::IsDescendant (const Section *section)
{
if (this == section)
return true;
SectionSP parent_sp (GetParent ());
if (parent_sp)
return parent_sp->IsDescendant (section);
return false;
}
bool
Section::Slide (addr_t slide_amount, bool slide_children)
{
if (m_file_addr != LLDB_INVALID_ADDRESS)
{
if (slide_amount == 0)
return true;
m_file_addr += slide_amount;
if (slide_children)
m_children.Slide (slide_amount, slide_children);
return true;
}
return false;
}
void
Section::SetLinkedLocation (const lldb::SectionSP &linked_section_sp, uint64_t linked_offset)
{
if (linked_section_sp)
m_module_wp = linked_section_sp->GetModule();
m_linked_section_wp = linked_section_sp;
m_linked_offset = linked_offset;
}
#pragma mark SectionList
SectionList::SectionList () :
m_sections()
{
}
SectionList::~SectionList ()
{
}
uint32_t
SectionList::AddSection (const lldb::SectionSP& section_sp)
{
assert (section_sp.get());
uint32_t section_index = m_sections.size();
m_sections.push_back(section_sp);
return section_index;
}
uint32_t
SectionList::FindSectionIndex (const Section* sect)
{
iterator sect_iter;
iterator begin = m_sections.begin();
iterator end = m_sections.end();
for (sect_iter = begin; sect_iter != end; ++sect_iter)
{
if (sect_iter->get() == sect)
{
// The secton was already in this section list
return std::distance (begin, sect_iter);
}
}
return UINT32_MAX;
}
uint32_t
SectionList::AddUniqueSection (const lldb::SectionSP& sect_sp)
{
uint32_t sect_idx = FindSectionIndex (sect_sp.get());
if (sect_idx == UINT32_MAX)
sect_idx = AddSection (sect_sp);
return sect_idx;
}
bool
SectionList::ReplaceSection (user_id_t sect_id, const lldb::SectionSP& sect_sp, uint32_t depth)
{
iterator sect_iter, end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter)
{
if ((*sect_iter)->GetID() == sect_id)
{
*sect_iter = sect_sp;
return true;
}
else if (depth > 0)
{
if ((*sect_iter)->GetChildren().ReplaceSection(sect_id, sect_sp, depth - 1))
return true;
}
}
return false;
}
size_t
SectionList::GetNumSections (uint32_t depth) const
{
size_t count = m_sections.size();
if (depth > 0)
{
const_iterator sect_iter, end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter)
{
count += (*sect_iter)->GetChildren().GetNumSections(depth - 1);
}
}
return count;
}
SectionSP
SectionList::GetSectionAtIndex (uint32_t idx) const
{
SectionSP sect_sp;
if (idx < m_sections.size())
sect_sp = m_sections[idx];
return sect_sp;
}
SectionSP
SectionList::FindSectionByName (const ConstString &section_dstr) const
{
SectionSP sect_sp;
// Check if we have a valid section string
if (section_dstr && !m_sections.empty())
{
const_iterator sect_iter;
const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter)
{
Section *child_section = sect_iter->get();
assert (child_section);
if (child_section->GetName() == section_dstr)
{
sect_sp = *sect_iter;
}
else
{
sect_sp = child_section->GetChildren().FindSectionByName(section_dstr);
}
}
}
return sect_sp;
}
SectionSP
SectionList::FindSectionByID (user_id_t sect_id) const
{
SectionSP sect_sp;
if (sect_id)
{
const_iterator sect_iter;
const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter)
{
if ((*sect_iter)->GetID() == sect_id)
{
sect_sp = *sect_iter;
break;
}
else
{
sect_sp = (*sect_iter)->GetChildren().FindSectionByID (sect_id);
}
}
}
return sect_sp;
}
SectionSP
SectionList::FindSectionByType (SectionType sect_type, bool check_children, uint32_t start_idx) const
{
SectionSP sect_sp;
uint32_t num_sections = m_sections.size();
for (uint32_t idx = start_idx; idx < num_sections; ++idx)
{
if (m_sections[idx]->GetType() == sect_type)
{
sect_sp = m_sections[idx];
break;
}
else if (check_children)
{
sect_sp = m_sections[idx]->GetChildren().FindSectionByType (sect_type, check_children, 0);
if (sect_sp)
break;
}
}
return sect_sp;
}
SectionSP
SectionList::FindSectionContainingFileAddress (addr_t vm_addr, uint32_t depth) const
{
SectionSP sect_sp;
const_iterator sect_iter;
const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter)
{
Section *sect = sect_iter->get();
if (sect->ContainsFileAddress (vm_addr))
{
// The file address is in this section. We need to make sure one of our child
// sections doesn't contain this address as well as obeying the depth limit
// that was passed in.
if (depth > 0)
sect_sp = sect->GetChildren().FindSectionContainingFileAddress(vm_addr, depth - 1);
if (sect_sp.get() == NULL && !sect->IsFake())
sect_sp = *sect_iter;
}
}
return sect_sp;
}
SectionSP
SectionList::FindSectionContainingLinkedFileAddress (addr_t vm_addr, uint32_t depth) const
{
SectionSP sect_sp;
const_iterator sect_iter;
const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end && sect_sp.get() == NULL; ++sect_iter)
{
Section *sect = sect_iter->get();
if (sect->ContainsLinkedFileAddress (vm_addr))
{
sect_sp = *sect_iter;
}
else if (depth > 0)
{
sect_sp = sect->GetChildren().FindSectionContainingLinkedFileAddress (vm_addr, depth - 1);
}
}
return sect_sp;
}
bool
SectionList::ContainsSection(user_id_t sect_id) const
{
return FindSectionByID (sect_id).get() != NULL;
}
void
SectionList::Dump (Stream *s, Target *target, bool show_header, uint32_t depth) const
{
bool target_has_loaded_sections = target && !target->GetSectionLoadList().IsEmpty();
if (show_header && !m_sections.empty())
{
s->Indent();
s->Printf( "SectID Type %s Address File Off. File Size Flags Section Name\n", target_has_loaded_sections ? "Load" : "File");
s->Indent();
s->PutCString("---------- ---------------- --------------------------------------- ---------- ---------- ---------- ----------------------------\n");
}
const_iterator sect_iter;
const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); sect_iter != end; ++sect_iter)
{
(*sect_iter)->Dump(s, target_has_loaded_sections ? target : NULL, depth);
}
if (show_header && !m_sections.empty())
s->IndentLess();
}
size_t
SectionList::Slide (addr_t slide_amount, bool slide_children)
{
size_t count = 0;
const_iterator pos, end = m_sections.end();
for (pos = m_sections.begin(); pos != end; ++pos)
{
if ((*pos)->Slide(slide_amount, slide_children))
++count;
}
return count;
}
Reference in New Issue View Git Blame Copy Permalink