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

source code of lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp