contrib/llvm/tools/lldb/source/Target/SectionLoadList.cpp

   1 //===-- SectionLoadList.cpp -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/SectionLoadList.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16 #include "lldb/Core/Log.h"
  17 #include "lldb/Core/Module.h"
  18 #include "lldb/Core/Section.h"
  19 #include "lldb/Core/Stream.h"
  20 #include "lldb/Symbol/Block.h"
  21 #include "lldb/Symbol/Symbol.h"
  22 #include "lldb/Symbol/SymbolContext.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27
  28 SectionLoadList::SectionLoadList (const SectionLoadList& rhs) :
  29     m_addr_to_sect(),
  30     m_sect_to_addr(),
  31     m_mutex (Mutex::eMutexTypeRecursive)
  32 {
  33     Mutex::Locker locker(rhs.m_mutex);
  34     m_addr_to_sect = rhs.m_addr_to_sect;
  35     m_sect_to_addr = rhs.m_sect_to_addr;
  36 }
  37
  38 void
  39 SectionLoadList::operator=(const SectionLoadList &rhs)
  40 {
  41     Mutex::Locker lhs_locker (m_mutex);
  42     Mutex::Locker rhs_locker (rhs.m_mutex);
  43     m_addr_to_sect = rhs.m_addr_to_sect;
  44     m_sect_to_addr = rhs.m_sect_to_addr;
  45 }
  46
  47 bool
  48 SectionLoadList::IsEmpty() const
  49 {
  50     Mutex::Locker locker(m_mutex);
  51     return m_addr_to_sect.empty();
  52 }
  53
  54 void
  55 SectionLoadList::Clear ()
  56 {
  57     Mutex::Locker locker(m_mutex);
  58     m_addr_to_sect.clear();
  59     m_sect_to_addr.clear();
  60 }
  61
  62 addr_t
  63 SectionLoadList::GetSectionLoadAddress (const lldb::SectionSP &section) const
  64 {
  65     // TODO: add support for the same section having multiple load addresses
  66     addr_t section_load_addr = LLDB_INVALID_ADDRESS;
  67     if (section)
  68     {
  69         Mutex::Locker locker(m_mutex);
  70         sect_to_addr_collection::const_iterator pos = m_sect_to_addr.find (section.get());
  71
  72         if (pos != m_sect_to_addr.end())
  73             section_load_addr = pos->second;
  74     }
  75     return section_load_addr;
  76 }
  77
  78 bool
  79 SectionLoadList::SetSectionLoadAddress (const lldb::SectionSP &section, addr_t load_addr, bool warn_multiple)
  80 {
  81     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
  82
  83     ModuleSP module_sp (section->GetModule());
  84
  85     if (module_sp)
  86     {
  87         if (log)
  88         {
  89             const FileSpec &module_file_spec (module_sp->GetFileSpec());
  90             log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16" PRIx64 ") module = %p",
  91                          __FUNCTION__,
  92                          section.get(),
  93                          module_file_spec.GetPath().c_str(),
  94                          section->GetName().AsCString(),
  95                          load_addr,
  96                          module_sp.get());
  97         }
  98
  99         if (section->GetByteSize() == 0)
 100             return false; // No change
 101
 102         // Fill in the section -> load_addr map
 103         Mutex::Locker locker(m_mutex);
 104         sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section.get());
 105         if (sta_pos != m_sect_to_addr.end())
 106         {
 107             if (load_addr == sta_pos->second)
 108                 return false; // No change...
 109             else
 110                 sta_pos->second = load_addr;
 111         }
 112         else
 113             m_sect_to_addr[section.get()] = load_addr;
 114
 115         // Fill in the load_addr -> section map
 116         addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
 117         if (ats_pos != m_addr_to_sect.end())
 118         {
 119             // Some sections are ok to overlap, and for others we should warn. When
 120             // we have multiple load addresses that correspond to a section, we will
 121             // allways attribute the section to the be last section that claims it
 122             // exists at that address. Sometimes it is ok for more that one section
 123             // to be loaded at a specific load address, and other times it isn't.
 124             // The "warn_multiple" parameter tells us if we should warn in this case
 125             // or not. The DynamicLoader plug-in subclasses should know which
 126             // sections should warn and which shouldn't (darwin shared cache modules
 127             // all shared the same "__LINKEDIT" sections, so the dynamic loader can
 128             // pass false for "warn_multiple").
 129             if (warn_multiple && section != ats_pos->second)
 130             {
 131                 ModuleSP module_sp (section->GetModule());
 132                 if (module_sp)
 133                 {
 134                     ModuleSP curr_module_sp (ats_pos->second->GetModule());
 135                     if (curr_module_sp)
 136                     {
 137                         module_sp->ReportWarning ("address 0x%16.16" PRIx64 " maps to more than one section: %s.%s and %s.%s",
 138                                                   load_addr,
 139                                                   module_sp->GetFileSpec().GetFilename().GetCString(),
 140                                                   section->GetName().GetCString(),
 141                                                   curr_module_sp->GetFileSpec().GetFilename().GetCString(),
 142                                                   ats_pos->second->GetName().GetCString());
 143                     }
 144                 }
 145             }
 146             ats_pos->second = section;
 147         }
 148         else
 149             m_addr_to_sect[load_addr] = section;
 150         return true;    // Changed
 151
 152     }
 153     else
 154     {
 155         if (log)
 156         {
 157             log->Printf ("SectionLoadList::%s (section = %p (%s), load_addr = 0x%16.16" PRIx64 ") error: module has been deleted",
 158                          __FUNCTION__,
 159                          section.get(),
 160                          section->GetName().AsCString(),
 161                          load_addr);
 162         }
 163     }
 164     return false;
 165 }
 166
 167 size_t
 168 SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp)
 169 {
 170     size_t unload_count = 0;
 171
 172     if (section_sp)
 173     {
 174         Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
 175
 176         if (log)
 177         {
 178             const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
 179             log->Printf ("SectionLoadList::%s (section = %p (%s.%s))",
 180                          __FUNCTION__,
 181                          section_sp.get(),
 182                          module_file_spec.GetPath().c_str(),
 183                          section_sp->GetName().AsCString());
 184         }
 185
 186         Mutex::Locker locker(m_mutex);
 187
 188         sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
 189         if (sta_pos != m_sect_to_addr.end())
 190         {
 191             ++unload_count;
 192             addr_t load_addr = sta_pos->second;
 193             m_sect_to_addr.erase (sta_pos);
 194
 195             addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
 196             if (ats_pos != m_addr_to_sect.end())
 197                 m_addr_to_sect.erase (ats_pos);
 198         }
 199     }
 200     return unload_count;
 201 }
 202
 203 bool
 204 SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp, addr_t load_addr)
 205 {
 206     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
 207
 208     if (log)
 209     {
 210         const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
 211         log->Printf ("SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16" PRIx64 ")",
 212                      __FUNCTION__,
 213                      section_sp.get(),
 214                      module_file_spec.GetPath().c_str(),
 215                      section_sp->GetName().AsCString(),
 216                      load_addr);
 217     }
 218     bool erased = false;
 219     Mutex::Locker locker(m_mutex);
 220     sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
 221     if (sta_pos != m_sect_to_addr.end())
 222     {
 223         erased = true;
 224         m_sect_to_addr.erase (sta_pos);
 225     }
 226
 227     addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
 228     if (ats_pos != m_addr_to_sect.end())
 229     {
 230         erased = true;
 231         m_addr_to_sect.erase (ats_pos);
 232     }
 233
 234     return erased;
 235 }
 236
 237
 238 bool
 239 SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
 240 {
 241     // First find the top level section that this load address exists in
 242     Mutex::Locker locker(m_mutex);
 243     if (!m_addr_to_sect.empty())
 244     {
 245         addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);
 246         if (pos != m_addr_to_sect.end())
 247         {
 248             if (load_addr != pos->first && pos != m_addr_to_sect.begin())
 249                 --pos;
 250             const addr_t pos_load_addr = pos->first;
 251             if (load_addr >= pos_load_addr)
 252             {
 253                 addr_t offset = load_addr - pos_load_addr;
 254                 if (offset < pos->second->GetByteSize())
 255                 {
 256                     // We have found the top level section, now we need to find the
 257                     // deepest child section.
 258                     return pos->second->ResolveContainedAddress (offset, so_addr);
 259                 }
 260             }
 261         }
 262         else
 263         {
 264             // There are no entries that have an address that is >= load_addr,
 265             // so we need to check the last entry on our collection.
 266             addr_to_sect_collection::const_reverse_iterator rpos = m_addr_to_sect.rbegin();
 267             if (load_addr >= rpos->first)
 268             {
 269                 addr_t offset = load_addr - rpos->first;
 270                 if (offset < rpos->second->GetByteSize())
 271                 {
 272                     // We have found the top level section, now we need to find the
 273                     // deepest child section.
 274                     return rpos->second->ResolveContainedAddress (offset, so_addr);
 275                 }
 276             }
 277         }
 278     }
 279     so_addr.Clear();
 280     return false;
 281 }
 282
 283 void
 284 SectionLoadList::Dump (Stream &s, Target *target)
 285 {
 286     Mutex::Locker locker(m_mutex);
 287     addr_to_sect_collection::const_iterator pos, end;
 288     for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
 289     {
 290         s.Printf("addr = 0x%16.16" PRIx64 ", section = %p: ", pos->first, pos->second.get());
 291         pos->second->Dump (&s, target, 0);
 292     }
 293 }
 294
 295