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