SectionLoadList.cpp revision 9ce953807eb814a93b449dc243de4f7bf32c3115 
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 Section *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);
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 Section *section, addr_t load_addr)
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,
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    Mutex::Locker locker(m_mutex);
81    sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section);
82    if (sta_pos != m_sect_to_addr.end())
83    {
84        if (load_addr == sta_pos->second)
85            return false; // No change...
86        else
87            sta_pos->second = load_addr;
88    }
89    else
90        m_sect_to_addr[section] = load_addr;
91
92    addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
93    if (ats_pos != m_addr_to_sect.end())
94    {
95        if (section != ats_pos->second)
96        {
97            Module *module = section->GetModule();
98            if (module)
99            {
100                module->ReportWarning ("address 0x%16.16llx maps to more than one section: %s.%s and %s.%s",
101                                       load_addr,
102                                       module->GetFileSpec().GetFilename().GetCString(),
103                                       section->GetName().GetCString(),
104                                       ats_pos->second->GetModule()->GetFileSpec().GetFilename().GetCString(),
105                                       ats_pos->second->GetName().GetCString());
106            }
107        }
108        ats_pos->second = section;
109    }
110    else
111        m_addr_to_sect[load_addr] = section;
112
113    return true;    // Changed
114}
115
116size_t
117SectionLoadList::SetSectionUnloaded (const Section *section)
118{
119    LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
120
121    if (log)
122    {
123        const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
124        log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s))",
125                     __FUNCTION__,
126                     section,
127                     module_file_spec.GetDirectory().AsCString(),
128                     module_file_spec.GetDirectory() ? "/" : "",
129                     module_file_spec.GetFilename().AsCString(),
130                     section->GetName().AsCString());
131    }
132
133    size_t unload_count = 0;
134    Mutex::Locker locker(m_mutex);
135
136    sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section);
137    if (sta_pos != m_sect_to_addr.end())
138    {
139        addr_t load_addr = sta_pos->second;
140        m_sect_to_addr.erase (sta_pos);
141
142        addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
143        if (ats_pos != m_addr_to_sect.end())
144            m_addr_to_sect.erase (ats_pos);
145    }
146
147    return unload_count;
148}
149
150bool
151SectionLoadList::SetSectionUnloaded (const Section *section, addr_t load_addr)
152{
153    LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER | LIBLLDB_LOG_VERBOSE));
154
155    if (log)
156    {
157        const FileSpec &module_file_spec (section->GetModule()->GetFileSpec());
158        log->Printf ("SectionLoadList::%s (section = %p (%s%s%s.%s), load_addr = 0x%16.16llx)",
159                     __FUNCTION__,
160                     section,
161                     module_file_spec.GetDirectory().AsCString(),
162                     module_file_spec.GetDirectory() ? "/" : "",
163                     module_file_spec.GetFilename().AsCString(),
164                     section->GetName().AsCString(),
165                     load_addr);
166    }
167    bool erased = false;
168    Mutex::Locker locker(m_mutex);
169    sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section);
170    if (sta_pos != m_sect_to_addr.end())
171    {
172        erased = true;
173        m_sect_to_addr.erase (sta_pos);
174    }
175
176    addr_to_sect_collection::iterator ats_pos = m_addr_to_sect.find(load_addr);
177    if (ats_pos != m_addr_to_sect.end())
178    {
179        erased = true;
180        m_addr_to_sect.erase (ats_pos);
181    }
182
183    return erased;
184}
185
186
187bool
188SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
189{
190    // First find the top level section that this load address exists in
191    Mutex::Locker locker(m_mutex);
192    if (!m_addr_to_sect.empty())
193    {
194        addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);
195        if (pos != m_addr_to_sect.end())
196        {
197            if (load_addr != pos->first && pos != m_addr_to_sect.begin())
198                --pos;
199            if (load_addr >= pos->first)
200            {
201                addr_t offset = load_addr - pos->first;
202                if (offset < pos->second->GetByteSize())
203                {
204                    // We have found the top level section, now we need to find the
205                    // deepest child section.
206                    return pos->second->ResolveContainedAddress (offset, so_addr);
207                }
208            }
209        }
210        else
211        {
212            // There are no entries that have an address that is >= load_addr,
213            // so we need to check the last entry on our collection.
214            addr_to_sect_collection::const_reverse_iterator rpos = m_addr_to_sect.rbegin();
215            if (load_addr >= rpos->first)
216            {
217                addr_t offset = load_addr - rpos->first;
218                if (offset < rpos->second->GetByteSize())
219                {
220                    // We have found the top level section, now we need to find the
221                    // deepest child section.
222                    return rpos->second->ResolveContainedAddress (offset, so_addr);
223                }
224            }
225        }
226    }
227    so_addr.Clear();
228    return false;
229}
230
231void
232SectionLoadList::Dump (Stream &s, Target *target)
233{
234    Mutex::Locker locker(m_mutex);
235    addr_to_sect_collection::const_iterator pos, end;
236    for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
237    {
238        s.Printf("addr = 0x%16.16llx, section = %p: ", pos->first, pos->second);
239        pos->second->Dump (&s, target, 0);
240    }
241}
242
243
244