DynamicLoaderHexagonDYLD.cpp revision 360784
1//===-- DynamicLoaderHexagonDYLD.cpp ----------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "lldb/Breakpoint/BreakpointLocation.h" 10#include "lldb/Core/Module.h" 11#include "lldb/Core/ModuleSpec.h" 12#include "lldb/Core/PluginManager.h" 13#include "lldb/Core/Section.h" 14#include "lldb/Symbol/ObjectFile.h" 15#include "lldb/Target/Process.h" 16#include "lldb/Target/Target.h" 17#include "lldb/Target/Thread.h" 18#include "lldb/Target/ThreadPlanRunToAddress.h" 19#include "lldb/Utility/Log.h" 20 21#include "DynamicLoaderHexagonDYLD.h" 22 23#include <memory> 24 25using namespace lldb; 26using namespace lldb_private; 27 28// Aidan 21/05/2014 29// 30// Notes about hexagon dynamic loading: 31// 32// When we connect to a target we find the dyld breakpoint address. We put 33// a 34// breakpoint there with a callback 'RendezvousBreakpointHit()'. 35// 36// It is possible to find the dyld structure address from the ELF symbol 37// table, 38// but in the case of the simulator it has not been initialized before the 39// target calls dlinit(). 40// 41// We can only safely parse the dyld structure after we hit the dyld 42// breakpoint 43// since at that time we know dlinit() must have been called. 44// 45 46// Find the load address of a symbol 47static lldb::addr_t findSymbolAddress(Process *proc, ConstString findName) { 48 assert(proc != nullptr); 49 50 ModuleSP module = proc->GetTarget().GetExecutableModule(); 51 assert(module.get() != nullptr); 52 53 ObjectFile *exe = module->GetObjectFile(); 54 assert(exe != nullptr); 55 56 lldb_private::Symtab *symtab = exe->GetSymtab(); 57 assert(symtab != nullptr); 58 59 for (size_t i = 0; i < symtab->GetNumSymbols(); i++) { 60 const Symbol *sym = symtab->SymbolAtIndex(i); 61 assert(sym != nullptr); 62 ConstString symName = sym->GetName(); 63 64 if (ConstString::Compare(findName, symName) == 0) { 65 Address addr = sym->GetAddress(); 66 return addr.GetLoadAddress(&proc->GetTarget()); 67 } 68 } 69 return LLDB_INVALID_ADDRESS; 70} 71 72void DynamicLoaderHexagonDYLD::Initialize() { 73 PluginManager::RegisterPlugin(GetPluginNameStatic(), 74 GetPluginDescriptionStatic(), CreateInstance); 75} 76 77void DynamicLoaderHexagonDYLD::Terminate() {} 78 79lldb_private::ConstString DynamicLoaderHexagonDYLD::GetPluginName() { 80 return GetPluginNameStatic(); 81} 82 83lldb_private::ConstString DynamicLoaderHexagonDYLD::GetPluginNameStatic() { 84 static ConstString g_name("hexagon-dyld"); 85 return g_name; 86} 87 88const char *DynamicLoaderHexagonDYLD::GetPluginDescriptionStatic() { 89 return "Dynamic loader plug-in that watches for shared library " 90 "loads/unloads in Hexagon processes."; 91} 92 93uint32_t DynamicLoaderHexagonDYLD::GetPluginVersion() { return 1; } 94 95DynamicLoader *DynamicLoaderHexagonDYLD::CreateInstance(Process *process, 96 bool force) { 97 bool create = force; 98 if (!create) { 99 const llvm::Triple &triple_ref = 100 process->GetTarget().GetArchitecture().GetTriple(); 101 if (triple_ref.getArch() == llvm::Triple::hexagon) 102 create = true; 103 } 104 105 if (create) 106 return new DynamicLoaderHexagonDYLD(process); 107 return nullptr; 108} 109 110DynamicLoaderHexagonDYLD::DynamicLoaderHexagonDYLD(Process *process) 111 : DynamicLoader(process), m_rendezvous(process), 112 m_load_offset(LLDB_INVALID_ADDRESS), m_entry_point(LLDB_INVALID_ADDRESS), 113 m_dyld_bid(LLDB_INVALID_BREAK_ID) {} 114 115DynamicLoaderHexagonDYLD::~DynamicLoaderHexagonDYLD() { 116 if (m_dyld_bid != LLDB_INVALID_BREAK_ID) { 117 m_process->GetTarget().RemoveBreakpointByID(m_dyld_bid); 118 m_dyld_bid = LLDB_INVALID_BREAK_ID; 119 } 120} 121 122void DynamicLoaderHexagonDYLD::DidAttach() { 123 ModuleSP executable; 124 addr_t load_offset; 125 126 executable = GetTargetExecutable(); 127 128 // Find the difference between the desired load address in the elf file and 129 // the real load address in memory 130 load_offset = ComputeLoadOffset(); 131 132 // Check that there is a valid executable 133 if (executable.get() == nullptr) 134 return; 135 136 // Disable JIT for hexagon targets because its not supported 137 m_process->SetCanJIT(false); 138 139 // Enable Interpreting of function call expressions 140 m_process->SetCanInterpretFunctionCalls(true); 141 142 // Add the current executable to the module list 143 ModuleList module_list; 144 module_list.Append(executable); 145 146 // Map the loaded sections of this executable 147 if (load_offset != LLDB_INVALID_ADDRESS) 148 UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true); 149 150 // AD: confirm this? 151 // Load into LLDB all of the currently loaded executables in the stub 152 LoadAllCurrentModules(); 153 154 // AD: confirm this? 155 // Callback for the target to give it the loaded module list 156 m_process->GetTarget().ModulesDidLoad(module_list); 157 158 // Try to set a breakpoint at the rendezvous breakpoint. DidLaunch uses 159 // ProbeEntry() instead. That sets a breakpoint, at the dyld breakpoint 160 // address, with a callback so that when hit, the dyld structure can be 161 // parsed. 162 if (!SetRendezvousBreakpoint()) { 163 // fail 164 } 165} 166 167void DynamicLoaderHexagonDYLD::DidLaunch() {} 168 169/// Checks to see if the target module has changed, updates the target 170/// accordingly and returns the target executable module. 171ModuleSP DynamicLoaderHexagonDYLD::GetTargetExecutable() { 172 Target &target = m_process->GetTarget(); 173 ModuleSP executable = target.GetExecutableModule(); 174 175 // There is no executable 176 if (!executable.get()) 177 return executable; 178 179 // The target executable file does not exits 180 if (!FileSystem::Instance().Exists(executable->GetFileSpec())) 181 return executable; 182 183 // Prep module for loading 184 ModuleSpec module_spec(executable->GetFileSpec(), 185 executable->GetArchitecture()); 186 ModuleSP module_sp(new Module(module_spec)); 187 188 // Check if the executable has changed and set it to the target executable if 189 // they differ. 190 if (module_sp.get() && module_sp->GetUUID().IsValid() && 191 executable->GetUUID().IsValid()) { 192 // if the executable has changed ?? 193 if (module_sp->GetUUID() != executable->GetUUID()) 194 executable.reset(); 195 } else if (executable->FileHasChanged()) 196 executable.reset(); 197 198 if (executable.get()) 199 return executable; 200 201 // TODO: What case is this code used? 202 executable = target.GetOrCreateModule(module_spec, true /* notify */); 203 if (executable.get() != target.GetExecutableModulePointer()) { 204 // Don't load dependent images since we are in dyld where we will know and 205 // find out about all images that are loaded 206 target.SetExecutableModule(executable, eLoadDependentsNo); 207 } 208 209 return executable; 210} 211 212// AD: Needs to be updated? 213Status DynamicLoaderHexagonDYLD::CanLoadImage() { return Status(); } 214 215void DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module, 216 addr_t link_map_addr, 217 addr_t base_addr, 218 bool base_addr_is_offset) { 219 Target &target = m_process->GetTarget(); 220 const SectionList *sections = GetSectionListFromModule(module); 221 222 assert(sections && "SectionList missing from loaded module."); 223 224 m_loaded_modules[module] = link_map_addr; 225 226 const size_t num_sections = sections->GetSize(); 227 228 for (unsigned i = 0; i < num_sections; ++i) { 229 SectionSP section_sp(sections->GetSectionAtIndex(i)); 230 lldb::addr_t new_load_addr = section_sp->GetFileAddress() + base_addr; 231 232 // AD: 02/05/14 233 // since our memory map starts from address 0, we must not ignore 234 // sections that load to address 0. This violates the reference 235 // ELF spec, however is used for Hexagon. 236 237 // If the file address of the section is zero then this is not an 238 // allocatable/loadable section (property of ELF sh_addr). Skip it. 239 // if (new_load_addr == base_addr) 240 // continue; 241 242 target.SetSectionLoadAddress(section_sp, new_load_addr); 243 } 244} 245 246/// Removes the loaded sections from the target in \p module. 247/// 248/// \param module The module to traverse. 249void DynamicLoaderHexagonDYLD::UnloadSections(const ModuleSP module) { 250 Target &target = m_process->GetTarget(); 251 const SectionList *sections = GetSectionListFromModule(module); 252 253 assert(sections && "SectionList missing from unloaded module."); 254 255 m_loaded_modules.erase(module); 256 257 const size_t num_sections = sections->GetSize(); 258 for (size_t i = 0; i < num_sections; ++i) { 259 SectionSP section_sp(sections->GetSectionAtIndex(i)); 260 target.SetSectionUnloaded(section_sp); 261 } 262} 263 264// Place a breakpoint on <_rtld_debug_state> 265bool DynamicLoaderHexagonDYLD::SetRendezvousBreakpoint() { 266 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 267 268 // This is the original code, which want to look in the rendezvous structure 269 // to find the breakpoint address. Its backwards for us, since we can easily 270 // find the breakpoint address, since it is exported in our executable. We 271 // however know that we cant read the Rendezvous structure until we have hit 272 // the breakpoint once. 273 const ConstString dyldBpName("_rtld_debug_state"); 274 addr_t break_addr = findSymbolAddress(m_process, dyldBpName); 275 276 Target &target = m_process->GetTarget(); 277 278 // Do not try to set the breakpoint if we don't know where to put it 279 if (break_addr == LLDB_INVALID_ADDRESS) { 280 LLDB_LOGF(log, "Unable to locate _rtld_debug_state breakpoint address"); 281 282 return false; 283 } 284 285 // Save the address of the rendezvous structure 286 m_rendezvous.SetBreakAddress(break_addr); 287 288 // If we haven't set the breakpoint before then set it 289 if (m_dyld_bid == LLDB_INVALID_BREAK_ID) { 290 Breakpoint *dyld_break = 291 target.CreateBreakpoint(break_addr, true, false).get(); 292 dyld_break->SetCallback(RendezvousBreakpointHit, this, true); 293 dyld_break->SetBreakpointKind("shared-library-event"); 294 m_dyld_bid = dyld_break->GetID(); 295 296 // Make sure our breakpoint is at the right address. 297 assert(target.GetBreakpointByID(m_dyld_bid) 298 ->FindLocationByAddress(break_addr) 299 ->GetBreakpoint() 300 .GetID() == m_dyld_bid); 301 302 if (log && dyld_break == nullptr) 303 LLDB_LOGF(log, "Failed to create _rtld_debug_state breakpoint"); 304 305 // check we have successfully set bp 306 return (dyld_break != nullptr); 307 } else 308 // rendezvous already set 309 return true; 310} 311 312// We have just hit our breakpoint at <_rtld_debug_state> 313bool DynamicLoaderHexagonDYLD::RendezvousBreakpointHit( 314 void *baton, StoppointCallbackContext *context, user_id_t break_id, 315 user_id_t break_loc_id) { 316 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 317 318 LLDB_LOGF(log, "Rendezvous breakpoint hit!"); 319 320 DynamicLoaderHexagonDYLD *dyld_instance = nullptr; 321 dyld_instance = static_cast<DynamicLoaderHexagonDYLD *>(baton); 322 323 // if the dyld_instance is still not valid then try to locate it on the 324 // symbol table 325 if (!dyld_instance->m_rendezvous.IsValid()) { 326 Process *proc = dyld_instance->m_process; 327 328 const ConstString dyldStructName("_rtld_debug"); 329 addr_t structAddr = findSymbolAddress(proc, dyldStructName); 330 331 if (structAddr != LLDB_INVALID_ADDRESS) { 332 dyld_instance->m_rendezvous.SetRendezvousAddress(structAddr); 333 334 LLDB_LOGF(log, "Found _rtld_debug structure @ 0x%08" PRIx64, structAddr); 335 } else { 336 LLDB_LOGF(log, "Unable to resolve the _rtld_debug structure"); 337 } 338 } 339 340 dyld_instance->RefreshModules(); 341 342 // Return true to stop the target, false to just let the target run. 343 return dyld_instance->GetStopWhenImagesChange(); 344} 345 346/// Helper method for RendezvousBreakpointHit. Updates LLDB's current set 347/// of loaded modules. 348void DynamicLoaderHexagonDYLD::RefreshModules() { 349 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 350 351 if (!m_rendezvous.Resolve()) 352 return; 353 354 HexagonDYLDRendezvous::iterator I; 355 HexagonDYLDRendezvous::iterator E; 356 357 ModuleList &loaded_modules = m_process->GetTarget().GetImages(); 358 359 if (m_rendezvous.ModulesDidLoad()) { 360 ModuleList new_modules; 361 362 E = m_rendezvous.loaded_end(); 363 for (I = m_rendezvous.loaded_begin(); I != E; ++I) { 364 FileSpec file(I->path); 365 FileSystem::Instance().Resolve(file); 366 ModuleSP module_sp = 367 LoadModuleAtAddress(file, I->link_addr, I->base_addr, true); 368 if (module_sp.get()) { 369 loaded_modules.AppendIfNeeded(module_sp); 370 new_modules.Append(module_sp); 371 } 372 373 if (log) { 374 LLDB_LOGF(log, "Target is loading '%s'", I->path.c_str()); 375 if (!module_sp.get()) 376 LLDB_LOGF(log, "LLDB failed to load '%s'", I->path.c_str()); 377 else 378 LLDB_LOGF(log, "LLDB successfully loaded '%s'", I->path.c_str()); 379 } 380 } 381 m_process->GetTarget().ModulesDidLoad(new_modules); 382 } 383 384 if (m_rendezvous.ModulesDidUnload()) { 385 ModuleList old_modules; 386 387 E = m_rendezvous.unloaded_end(); 388 for (I = m_rendezvous.unloaded_begin(); I != E; ++I) { 389 FileSpec file(I->path); 390 FileSystem::Instance().Resolve(file); 391 ModuleSpec module_spec(file); 392 ModuleSP module_sp = loaded_modules.FindFirstModule(module_spec); 393 394 if (module_sp.get()) { 395 old_modules.Append(module_sp); 396 UnloadSections(module_sp); 397 } 398 399 LLDB_LOGF(log, "Target is unloading '%s'", I->path.c_str()); 400 } 401 loaded_modules.Remove(old_modules); 402 m_process->GetTarget().ModulesDidUnload(old_modules, false); 403 } 404} 405 406// AD: This is very different to the Static Loader code. 407// It may be wise to look over this and its relation to stack 408// unwinding. 409ThreadPlanSP 410DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread, 411 bool stop) { 412 ThreadPlanSP thread_plan_sp; 413 414 StackFrame *frame = thread.GetStackFrameAtIndex(0).get(); 415 const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol); 416 Symbol *sym = context.symbol; 417 418 if (sym == nullptr || !sym->IsTrampoline()) 419 return thread_plan_sp; 420 421 const ConstString sym_name = sym->GetMangled().GetName( 422 lldb::eLanguageTypeUnknown, Mangled::ePreferMangled); 423 if (!sym_name) 424 return thread_plan_sp; 425 426 SymbolContextList target_symbols; 427 Target &target = thread.GetProcess()->GetTarget(); 428 const ModuleList &images = target.GetImages(); 429 430 images.FindSymbolsWithNameAndType(sym_name, eSymbolTypeCode, target_symbols); 431 size_t num_targets = target_symbols.GetSize(); 432 if (!num_targets) 433 return thread_plan_sp; 434 435 typedef std::vector<lldb::addr_t> AddressVector; 436 AddressVector addrs; 437 for (size_t i = 0; i < num_targets; ++i) { 438 SymbolContext context; 439 AddressRange range; 440 if (target_symbols.GetContextAtIndex(i, context)) { 441 context.GetAddressRange(eSymbolContextEverything, 0, false, range); 442 lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target); 443 if (addr != LLDB_INVALID_ADDRESS) 444 addrs.push_back(addr); 445 } 446 } 447 448 if (addrs.size() > 0) { 449 AddressVector::iterator start = addrs.begin(); 450 AddressVector::iterator end = addrs.end(); 451 452 llvm::sort(start, end); 453 addrs.erase(std::unique(start, end), end); 454 thread_plan_sp = 455 std::make_shared<ThreadPlanRunToAddress>(thread, addrs, stop); 456 } 457 458 return thread_plan_sp; 459} 460 461/// Helper for the entry breakpoint callback. Resolves the load addresses 462/// of all dependent modules. 463void DynamicLoaderHexagonDYLD::LoadAllCurrentModules() { 464 HexagonDYLDRendezvous::iterator I; 465 HexagonDYLDRendezvous::iterator E; 466 ModuleList module_list; 467 468 if (!m_rendezvous.Resolve()) { 469 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 470 LLDB_LOGF( 471 log, 472 "DynamicLoaderHexagonDYLD::%s unable to resolve rendezvous address", 473 __FUNCTION__); 474 return; 475 } 476 477 // The rendezvous class doesn't enumerate the main module, so track that 478 // ourselves here. 479 ModuleSP executable = GetTargetExecutable(); 480 m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress(); 481 482 for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) { 483 const char *module_path = I->path.c_str(); 484 FileSpec file(module_path); 485 ModuleSP module_sp = 486 LoadModuleAtAddress(file, I->link_addr, I->base_addr, true); 487 if (module_sp.get()) { 488 module_list.Append(module_sp); 489 } else { 490 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 491 LLDB_LOGF(log, 492 "DynamicLoaderHexagonDYLD::%s failed loading module %s at " 493 "0x%" PRIx64, 494 __FUNCTION__, module_path, I->base_addr); 495 } 496 } 497 498 m_process->GetTarget().ModulesDidLoad(module_list); 499} 500 501/// Computes a value for m_load_offset returning the computed address on 502/// success and LLDB_INVALID_ADDRESS on failure. 503addr_t DynamicLoaderHexagonDYLD::ComputeLoadOffset() { 504 // Here we could send a GDB packet to know the load offset 505 // 506 // send: $qOffsets#4b 507 // get: Text=0;Data=0;Bss=0 508 // 509 // Currently qOffsets is not supported by pluginProcessGDBRemote 510 // 511 return 0; 512} 513 514// Here we must try to read the entry point directly from the elf header. This 515// is possible if the process is not relocatable or dynamically linked. 516// 517// an alternative is to look at the PC if we can be sure that we have connected 518// when the process is at the entry point. 519// I dont think that is reliable for us. 520addr_t DynamicLoaderHexagonDYLD::GetEntryPoint() { 521 if (m_entry_point != LLDB_INVALID_ADDRESS) 522 return m_entry_point; 523 // check we have a valid process 524 if (m_process == nullptr) 525 return LLDB_INVALID_ADDRESS; 526 // Get the current executable module 527 Module &module = *(m_process->GetTarget().GetExecutableModule().get()); 528 // Get the object file (elf file) for this module 529 lldb_private::ObjectFile &object = *(module.GetObjectFile()); 530 // Check if the file is executable (ie, not shared object or relocatable) 531 if (object.IsExecutable()) { 532 // Get the entry point address for this object 533 lldb_private::Address entry = object.GetEntryPointAddress(); 534 // Return the entry point address 535 return entry.GetFileAddress(); 536 } 537 // No idea so back out 538 return LLDB_INVALID_ADDRESS; 539} 540 541const SectionList *DynamicLoaderHexagonDYLD::GetSectionListFromModule( 542 const ModuleSP module) const { 543 SectionList *sections = nullptr; 544 if (module.get()) { 545 ObjectFile *obj_file = module->GetObjectFile(); 546 if (obj_file) { 547 sections = obj_file->GetSectionList(); 548 } 549 } 550 return sections; 551} 552 553static int ReadInt(Process *process, addr_t addr) { 554 Status error; 555 int value = (int)process->ReadUnsignedIntegerFromMemory( 556 addr, sizeof(uint32_t), 0, error); 557 if (error.Fail()) 558 return -1; 559 else 560 return value; 561} 562 563lldb::addr_t 564DynamicLoaderHexagonDYLD::GetThreadLocalData(const lldb::ModuleSP module, 565 const lldb::ThreadSP thread, 566 lldb::addr_t tls_file_addr) { 567 auto it = m_loaded_modules.find(module); 568 if (it == m_loaded_modules.end()) 569 return LLDB_INVALID_ADDRESS; 570 571 addr_t link_map = it->second; 572 if (link_map == LLDB_INVALID_ADDRESS) 573 return LLDB_INVALID_ADDRESS; 574 575 const HexagonDYLDRendezvous::ThreadInfo &metadata = 576 m_rendezvous.GetThreadInfo(); 577 if (!metadata.valid) 578 return LLDB_INVALID_ADDRESS; 579 580 // Get the thread pointer. 581 addr_t tp = thread->GetThreadPointer(); 582 if (tp == LLDB_INVALID_ADDRESS) 583 return LLDB_INVALID_ADDRESS; 584 585 // Find the module's modid. 586 int modid = ReadInt(m_process, link_map + metadata.modid_offset); 587 if (modid == -1) 588 return LLDB_INVALID_ADDRESS; 589 590 // Lookup the DTV structure for this thread. 591 addr_t dtv_ptr = tp + metadata.dtv_offset; 592 addr_t dtv = ReadPointer(dtv_ptr); 593 if (dtv == LLDB_INVALID_ADDRESS) 594 return LLDB_INVALID_ADDRESS; 595 596 // Find the TLS block for this module. 597 addr_t dtv_slot = dtv + metadata.dtv_slot_size * modid; 598 addr_t tls_block = ReadPointer(dtv_slot + metadata.tls_offset); 599 600 Module *mod = module.get(); 601 Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); 602 LLDB_LOGF(log, 603 "DynamicLoaderHexagonDYLD::Performed TLS lookup: " 604 "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64 605 ", modid=%i, tls_block=0x%" PRIx64, 606 mod->GetObjectName().AsCString(""), link_map, tp, modid, tls_block); 607 608 if (tls_block == LLDB_INVALID_ADDRESS) 609 return LLDB_INVALID_ADDRESS; 610 else 611 return tls_block + tls_file_addr; 612} 613