SectionLoadList.cpp revision 545762f7780bece4e9255e052c0a50a1ea66ce57 
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
24using namespace lldb;
25using namespace lldb_private;
26
27
28bool
29SectionLoadList::IsEmpty() const
30{
31    Mutex::Locker locker(m_mutex);
32    return m_addr_to_sect.empty();
33}
34
35void
36SectionLoadList::Clear ()
37{
38    Mutex::Locker locker(m_mutex);
39    m_addr_to_sect.clear();
40    m_sect_to_addr.clear();
41}
42
43addr_t
44SectionLoadList::GetSectionLoadAddress (const lldb::SectionSP &section) const
45{
46    // TODO: add support for the same section having multiple load addresses
47    addr_t section_load_addr = LLDB_INVALID_ADDRESS;
48    if (section)
49    {
50        Mutex::Locker locker(m_mutex);
51        sect_to_addr_collection::const_iterator pos = m_sect_to_addr.find (section.get());
52
53        if (pos != m_sect_to_addr.end())
54            section_load_addr = pos->second;
55    }
56    return section_load_addr;
57}
58
59bool
60SectionLoadList::SetSectionLoadAddress (const lldb::SectionSP &section, addr_t load_addr, bool warn_multiple)
61{
62    LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
63
64    if (log)
65    {
66        const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
67        log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
68                     __FUNCTION__,
69                     section.get(),
70                     module_file_spec.GetDirectory().AsCString(),
71                     module_file_spec.GetDirectory() ? "/" : "",
72                     module_file_spec.GetFilename().AsCString(),
73                     section->GetName().AsCString(),
74                     load_addr);
75    }
76
77    if (section->GetByteSize() == 0)
78        return false; // No change
79
80    // Fill in the section -> load_addr map
81    Mutex::Locker locker(m_mutex);
82    sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section.get());
83    if (sta_pos != m_sect_to_addr.end())
84    {
85        if (load_addr == sta_pos->second)
86            return false; // No change...
87        else
88            sta_pos->second = load_addr;
89    }
90    else
91        m_sect_to_addr[section.get()] = load_addr;
92
93    // Fill in the load_addr -> section map
94    addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
95    if (ats_pos != m_addr_to_sect.end())
96    {
97        // Some sections are ok to overlap, and for others we should warn. When
98        // we have multiple load addresses that correspond to a section, we will
99        // allways attribute the section to the be last section that claims it
100        // exists at that address. Sometimes it is ok for more that one section
101        // to be loaded at a specific load address, and other times it isn't.
102        // The "warn_multiple" parameter tells us if we should warn in this case
103        // or not. The DynamicLoader plug-in subclasses should know which
104        // sections should warn and which shouldn't (darwin shared cache modules
105        // all shared the same "__LINKEDIT" sections, so the dynamic loader can
106        // pass false for "warn_multiple").
107        if (warn_multiple && section != ats_pos->second)
108        {
109            ModuleSP module_sp (section->GetModule());
110            if (module_sp)
111            {
112                module_sp->ReportWarning ("address 0x%16.16llx maps to more than one section: %s.%s and %s.%s",
113                                          load_addr,
114                                          module_sp->GetFileSpec().GetFilename().GetCString(),
115                                          section->GetName().GetCString(),
116                                          ats_pos->second->GetModule()->GetFileSpec().GetFilename().GetCString(),
117                                          ats_pos->second->GetName().GetCString());
118            }
119        }
120        ats_pos->second = section;
121    }
122    else
123        m_addr_to_sect[load_addr] = section;
124
125    return true;    // Changed
126}
127
128size_t
129SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp)
130{
131    size_t unload_count = 0;
132
133    if (section_sp)
134    {
135        LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
136
137        if (log)
138        {
139            const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
140            log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s))",
141                         __FUNCTION__,
142                         section_sp.get(),
143                         module_file_spec.GetDirectory().AsCString(),
144                         module_file_spec.GetDirectory() ? "/" : "",
145                         module_file_spec.GetFilename().AsCString(),
146                         section_sp->GetName().AsCString());
147        }
148
149        Mutex::Locker locker(m_mutex);
150
151        sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
152        if (sta_pos != m_sect_to_addr.end())
153        {
154            addr_t load_addr = sta_pos->second;
155            m_sect_to_addr.erase (sta_pos);
156
157            addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
158            if (ats_pos != m_addr_to_sect.end())
159                m_addr_to_sect.erase (ats_pos);
160        }
161    }
162    return unload_count;
163}
164
165bool
166SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp, addr_t load_addr)
167{
168    LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
169
170    if (log)
171    {
172        const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
173        log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
174                     __FUNCTION__,
175                     section_sp.get(),
176                     module_file_spec.GetDirectory().AsCString(),
177                     module_file_spec.GetDirectory() ? "/" : "",
178                     module_file_spec.GetFilename().AsCString(),
179                     section_sp->GetName().AsCString(),
180                     load_addr);
181    }
182    bool erased = false;
183    Mutex::Locker locker(m_mutex);
184    sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
185    if (sta_pos != m_sect_to_addr.end())
186    {
187        erased = true;
188        m_sect_to_addr.erase (sta_pos);
189    }
190
191    addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
192    if (ats_pos != m_addr_to_sect.end())
193    {
194        erased = true;
195        m_addr_to_sect.erase (ats_pos);
196    }
197
198    return erased;
199}
200
201
202bool
203SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
204{
205    // First find the top level section that this load address exists in
206    Mutex::Locker locker(m_mutex);
207    if (!m_addr_to_sect.empty())
208    {
209        addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);
210        if (pos != m_addr_to_sect.end())
211        {
212            if (load_addr != pos->first && pos != m_addr_to_sect.begin())
213                --pos;
214            if (load_addr >= pos->first)
215            {
216                addr_t offset = load_addr - pos->first;
217                if (offset < pos->second->GetByteSize())
218                {
219                    // We have found the top level section, now we need to find the
220                    // deepest child section.
221                    return pos->second->ResolveContainedAddress (offset, so_addr);
222                }
223            }
224        }
225        else
226        {
227            // There are no entries that have an address that is >= load_addr,
228            // so we need to check the last entry on our collection.
229            addr_to_sect_collection::const_reverse_iterator rpos = m_addr_to_sect.rbegin();
230            if (load_addr >= rpos->first)
231            {
232                addr_t offset = load_addr - rpos->first;
233                if (offset < rpos->second->GetByteSize())
234                {
235                    // We have found the top level section, now we need to find the
236                    // deepest child section.
237                    return rpos->second->ResolveContainedAddress (offset, so_addr);
238                }
239            }
240        }
241    }
242    so_addr.Clear();
243    return false;
244}
245
246void
247SectionLoadList::Dump (Stream &s, Target *target)
248{
249    Mutex::Locker locker(m_mutex);
250    addr_to_sect_collection::const_iterator pos, end;
251    for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
252    {
253        s.Printf("addr = 0x%16.16llx, section = %p: ", pos->first, pos->second.get());
254        pos->second->Dump (&s, target, 0);
255    }
256}
257
258
259