SectionLoadList.cpp revision 40a3976b0c61894404036f23415191d631b3864c 
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                ModuleSP curr_module_sp (ats_pos->second->GetModule());
113                if (curr_module_sp)
114                {
115                    module_sp->ReportWarning ("address 0x%16.16llx maps to more than one section: %s.%s and %s.%s",
116                                              load_addr,
117                                              module_sp->GetFileSpec().GetFilename().GetCString(),
118                                              section->GetName().GetCString(),
119                                              curr_module_sp->GetFileSpec().GetFilename().GetCString(),
120                                              ats_pos->second->GetName().GetCString());
121                }
122            }
123        }
124        ats_pos->second = section;
125    }
126    else
127        m_addr_to_sect[load_addr] = section;
128
129    return true;    // Changed
130}
131
132size_t
133SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp)
134{
135    size_t unload_count = 0;
136
137    if (section_sp)
138    {
139        LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
140
141        if (log)
142        {
143            const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
144            log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s))",
145                         __FUNCTION__,
146                         section_sp.get(),
147                         module_file_spec.GetDirectory().AsCString(),
148                         module_file_spec.GetDirectory() ? "/" : "",
149                         module_file_spec.GetFilename().AsCString(),
150                         section_sp->GetName().AsCString());
151        }
152
153        Mutex::Locker locker(m_mutex);
154
155        sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
156        if (sta_pos != m_sect_to_addr.end())
157        {
158            addr_t load_addr = sta_pos->second;
159            m_sect_to_addr.erase (sta_pos);
160
161            addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
162            if (ats_pos != m_addr_to_sect.end())
163                m_addr_to_sect.erase (ats_pos);
164        }
165    }
166    return unload_count;
167}
168
169bool
170SectionLoadList::SetSectionUnloaded (const lldb::SectionSP &section_sp, addr_t load_addr)
171{
172    LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
173
174    if (log)
175    {
176        const FileSpec &module_file_spec (section_sp->GetModule()->GetFileSpec());
177        log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
178                     __FUNCTION__,
179                     section_sp.get(),
180                     module_file_spec.GetDirectory().AsCString(),
181                     module_file_spec.GetDirectory() ? "/" : "",
182                     module_file_spec.GetFilename().AsCString(),
183                     section_sp->GetName().AsCString(),
184                     load_addr);
185    }
186    bool erased = false;
187    Mutex::Locker locker(m_mutex);
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        erased = true;
192        m_sect_to_addr.erase (sta_pos);
193    }
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    {
198        erased = true;
199        m_addr_to_sect.erase (ats_pos);
200    }
201
202    return erased;
203}
204
205
206bool
207SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
208{
209    // First find the top level section that this load address exists in
210    Mutex::Locker locker(m_mutex);
211    if (!m_addr_to_sect.empty())
212    {
213        addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);
214        if (pos != m_addr_to_sect.end())
215        {
216            if (load_addr != pos->first && pos != m_addr_to_sect.begin())
217                --pos;
218            if (load_addr >= pos->first)
219            {
220                addr_t offset = load_addr - pos->first;
221                if (offset < pos->second->GetByteSize())
222                {
223                    // We have found the top level section, now we need to find the
224                    // deepest child section.
225                    return pos->second->ResolveContainedAddress (offset, so_addr);
226                }
227            }
228        }
229        else
230        {
231            // There are no entries that have an address that is >= load_addr,
232            // so we need to check the last entry on our collection.
233            addr_to_sect_collection::const_reverse_iterator rpos = m_addr_to_sect.rbegin();
234            if (load_addr >= rpos->first)
235            {
236                addr_t offset = load_addr - rpos->first;
237                if (offset < rpos->second->GetByteSize())
238                {
239                    // We have found the top level section, now we need to find the
240                    // deepest child section.
241                    return rpos->second->ResolveContainedAddress (offset, so_addr);
242                }
243            }
244        }
245    }
246    so_addr.Clear();
247    return false;
248}
249
250void
251SectionLoadList::Dump (Stream &s, Target *target)
252{
253    Mutex::Locker locker(m_mutex);
254    addr_to_sect_collection::const_iterator pos, end;
255    for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
256    {
257        s.Printf("addr = 0x%16.16llx, section = %p: ", pos->first, pos->second.get());
258        pos->second->Dump (&s, target, 0);
259    }
260}
261
262
263