SectionLoadList.cpp revision 269024
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 28SectionLoadList::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 38void 39SectionLoadList::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 47bool 48SectionLoadList::IsEmpty() const 49{ 50 Mutex::Locker locker(m_mutex); 51 return m_addr_to_sect.empty(); 52} 53 54void 55SectionLoadList::Clear () 56{ 57 Mutex::Locker locker(m_mutex); 58 m_addr_to_sect.clear(); 59 m_sect_to_addr.clear(); 60} 61 62addr_t 63SectionLoadList::GetSectionLoadAddress (const lldb::SectionSP §ion) 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 78bool 79SectionLoadList::SetSectionLoadAddress (const lldb::SectionSP §ion, 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 167size_t 168SectionLoadList::SetSectionUnloaded (const lldb::SectionSP §ion_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 203bool 204SectionLoadList::SetSectionUnloaded (const lldb::SectionSP §ion_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 238bool 239SectionLoadList::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 283void 284SectionLoadList::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 296