LLDB mainline
DynamicLoaderHexagonDYLD.cpp
Go to the documentation of this file.
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
10#include "lldb/Core/Module.h"
13#include "lldb/Core/Section.h"
15#include "lldb/Target/Process.h"
16#include "lldb/Target/Target.h"
17#include "lldb/Target/Thread.h"
20#include "lldb/Utility/Log.h"
21
23
24#include <memory>
25
26using namespace lldb;
27using namespace lldb_private;
28
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
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(i);
64 assert(sym != nullptr);
65 ConstString symName = sym->GetName();
66
67 if (ConstString::Compare(findName, symName) == 0) {
68 Address addr = sym->GetAddress();
69 return addr.GetLoadAddress(&proc->GetTarget());
70 }
71 }
73}
74
78}
79
81
83 return "Dynamic loader plug-in that watches for shared library "
84 "loads/unloads in Hexagon processes.";
85}
86
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
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
111 }
112}
113
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
133
134 // Add the current executable to the module list
135 ModuleList module_list;
136 module_list.Append(executable);
137
138 // Map the loaded sections of this executable
139 if (load_offset != LLDB_INVALID_ADDRESS)
140 UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
141
142 // AD: confirm this?
143 // Load into LLDB all of the currently loaded executables in the stub
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.
155 // fail
156 }
157}
158
160
161/// Checks to see if the target module has changed, updates the target
162/// accordingly and returns the target executable module.
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(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, 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(executable, eLoadDependentsNo);
199 }
200
201 return executable;
202}
203
204// AD: Needs to be updated?
206
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(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_sp, 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.
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(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(i));
252 target.SetSectionUnloaded(section_sp);
253 }
254}
255
256// Place a breakpoint on <_rtld_debug_state>
258 Log *log = GetLog(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(m_process, 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
282 Breakpoint *dyld_break =
283 target.CreateBreakpoint(break_addr, true, false).get();
284 dyld_break->SetCallback(RendezvousBreakpointHit, this, 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>
306 void *baton, StoppointCallbackContext *context, user_id_t break_id,
307 user_id_t break_loc_id) {
308 Log *log = GetLog(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, 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.
341 Log *log = GetLog(LLDBLog::DynamicLoader);
342
343 if (!m_rendezvous.Resolve())
344 return;
345
348
349 ModuleList &loaded_modules = m_process->GetTarget().GetImages();
350
352 ModuleList new_modules;
353
355 for (I = m_rendezvous.loaded_begin(); I != E; ++I) {
356 FileSpec file(I->path);
358 ModuleSP module_sp =
359 LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
360 if (module_sp.get()) {
361 loaded_modules.AppendIfNeeded(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(new_modules);
374 }
375
377 ModuleList old_modules;
378
380 for (I = m_rendezvous.unloaded_begin(); I != E; ++I) {
381 FileSpec file(I->path);
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_sp);
389 }
390
391 LLDB_LOGF(log, "Target is unloading '%s'", I->path.c_str());
392 }
393 loaded_modules.Remove(old_modules);
394 m_process->GetTarget().ModulesDidUnload(old_modules, 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.
403 bool stop) {
404 ThreadPlanSP thread_plan_sp;
405
406 StackFrame *frame = thread.GetStackFrameAtIndex(0).get();
407 const SymbolContext &context = frame->GetSymbolContext(eSymbolContextSymbol);
408 Symbol *sym = context.symbol;
409
410 if (sym == nullptr || !sym->IsTrampoline())
411 return thread_plan_sp;
412
413 const ConstString sym_name =
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(sym_name, eSymbolTypeCode, 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 AddressRange range;
430 context.GetAddressRange(eSymbolContextEverything, 0, false, range);
431 lldb::addr_t addr = range.GetBaseAddress().GetLoadAddress(&target);
432 if (addr != LLDB_INVALID_ADDRESS)
433 addrs.push_back(addr);
434 }
435
436 if (addrs.size() > 0) {
437 AddressVector::iterator start = addrs.begin();
438 AddressVector::iterator end = addrs.end();
439
440 llvm::sort(start, end);
441 addrs.erase(std::unique(start, end), end);
442 thread_plan_sp =
443 std::make_shared<ThreadPlanRunToAddress>(thread, addrs, stop);
444 }
445
446 return thread_plan_sp;
447}
448
449/// Helper for the entry breakpoint callback. Resolves the load addresses
450/// of all dependent modules.
454 ModuleList module_list;
455
456 if (!m_rendezvous.Resolve()) {
457 Log *log = GetLog(LLDBLog::DynamicLoader);
458 LLDB_LOGF(
459 log,
460 "DynamicLoaderHexagonDYLD::%s unable to resolve rendezvous address",
461 __FUNCTION__);
462 return;
463 }
464
465 // The rendezvous class doesn't enumerate the main module, so track that
466 // ourselves here.
467 ModuleSP executable = GetTargetExecutable();
469
470 for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I) {
471 const char *module_path = I->path.c_str();
472 FileSpec file(module_path);
473 ModuleSP module_sp =
474 LoadModuleAtAddress(file, I->link_addr, I->base_addr, true);
475 if (module_sp.get()) {
476 module_list.Append(module_sp);
477 } else {
478 Log *log = GetLog(LLDBLog::DynamicLoader);
479 LLDB_LOGF(log,
480 "DynamicLoaderHexagonDYLD::%s failed loading module %s at "
481 "0x%" PRIx64,
482 __FUNCTION__, module_path, I->base_addr);
483 }
484 }
485
486 m_process->GetTarget().ModulesDidLoad(module_list);
487}
488
489/// Computes a value for m_load_offset returning the computed address on
490/// success and LLDB_INVALID_ADDRESS on failure.
492 // Here we could send a GDB packet to know the load offset
493 //
494 // send: $qOffsets#4b
495 // get: Text=0;Data=0;Bss=0
496 //
497 // Currently qOffsets is not supported by pluginProcessGDBRemote
498 //
499 return 0;
500}
501
502// Here we must try to read the entry point directly from the elf header. This
503// is possible if the process is not relocatable or dynamically linked.
504//
505// an alternative is to look at the PC if we can be sure that we have connected
506// when the process is at the entry point.
507// I dont think that is reliable for us.
510 return m_entry_point;
511 // check we have a valid process
512 if (m_process == nullptr)
514 // Get the current executable module
515 Module &module = *(m_process->GetTarget().GetExecutableModule().get());
516 // Get the object file (elf file) for this module
517 lldb_private::ObjectFile &object = *(module.GetObjectFile());
518 // Check if the file is executable (ie, not shared object or relocatable)
519 if (object.IsExecutable()) {
520 // Get the entry point address for this object
521 lldb_private::Address entry = object.GetEntryPointAddress();
522 // Return the entry point address
523 return entry.GetFileAddress();
524 }
525 // No idea so back out
527}
528
530 const ModuleSP module) const {
531 SectionList *sections = nullptr;
532 if (module.get()) {
533 ObjectFile *obj_file = module->GetObjectFile();
534 if (obj_file) {
535 sections = obj_file->GetSectionList();
536 }
537 }
538 return sections;
539}
540
541static int ReadInt(Process *process, addr_t addr) {
543 int value = (int)process->ReadUnsignedIntegerFromMemory(
544 addr, sizeof(uint32_t), 0, error);
545 if (error.Fail())
546 return -1;
547 else
548 return value;
549}
550
553 const lldb::ThreadSP thread,
554 lldb::addr_t tls_file_addr) {
555 auto it = m_loaded_modules.find(module);
556 if (it == m_loaded_modules.end())
558
559 addr_t link_map = it->second;
560 if (link_map == LLDB_INVALID_ADDRESS)
562
563 const HexagonDYLDRendezvous::ThreadInfo &metadata =
565 if (!metadata.valid)
567
568 // Get the thread pointer.
569 addr_t tp = thread->GetThreadPointer();
570 if (tp == LLDB_INVALID_ADDRESS)
572
573 // Find the module's modid.
574 int modid = ReadInt(m_process, link_map + metadata.modid_offset);
575 if (modid == -1)
577
578 // Lookup the DTV structure for this thread.
579 addr_t dtv_ptr = tp + metadata.dtv_offset;
580 addr_t dtv = ReadPointer(dtv_ptr);
581 if (dtv == LLDB_INVALID_ADDRESS)
583
584 // Find the TLS block for this module.
585 addr_t dtv_slot = dtv + metadata.dtv_slot_size * modid;
586 addr_t tls_block = ReadPointer(dtv_slot + metadata.tls_offset);
587
588 Module *mod = module.get();
589 Log *log = GetLog(LLDBLog::DynamicLoader);
590 LLDB_LOGF(log,
591 "DynamicLoaderHexagonDYLD::Performed TLS lookup: "
592 "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64
593 ", modid=%i, tls_block=0x%" PRIx64,
594 mod->GetObjectName().AsCString(""), link_map, tp, modid, tls_block);
595
596 if (tls_block == LLDB_INVALID_ADDRESS)
598 else
599 return tls_block + tls_file_addr;
600}
static llvm::raw_ostream & error(Stream &strm)
static lldb::addr_t findSymbolAddress(Process *proc, ConstString findName)
static int ReadInt(Process *process, addr_t addr)
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb::ModuleSP GetTargetExecutable()
Checks to see if the target module has changed, updates the target accordingly and returns the target...
static llvm::StringRef GetPluginDescriptionStatic()
void LoadAllCurrentModules()
Helper for the entry breakpoint callback.
std::map< lldb::ModuleWP, lldb::addr_t, std::owner_less< lldb::ModuleWP > > m_loaded_modules
Loaded module list. (link map for each module)
lldb_private::Status CanLoadImage() override
Ask if it is ok to try and load or unload an shared library (image).
lldb::break_id_t m_dyld_bid
Rendezvous breakpoint.
lldb::addr_t m_entry_point
Virtual entry address of the inferior process.
bool SetRendezvousBreakpoint()
Enables a breakpoint on a function called by the runtime linker each time a module is loaded or unloa...
lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module, const lldb::ThreadSP thread, lldb::addr_t tls_file_addr) override
Retrieves the per-module TLS block for a given thread.
DynamicLoaderHexagonDYLD(lldb_private::Process *process)
static lldb_private::DynamicLoader * CreateInstance(lldb_private::Process *process, bool force)
void RefreshModules()
Helper method for RendezvousBreakpointHit.
HexagonDYLDRendezvous m_rendezvous
Runtime linker rendezvous structure.
static bool RendezvousBreakpointHit(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Callback routine which updates the current list of loaded modules based on the information supplied b...
lldb::addr_t ComputeLoadOffset()
Computes a value for m_load_offset returning the computed address on success and LLDB_INVALID_ADDRESS...
const lldb_private::SectionList * GetSectionListFromModule(const lldb::ModuleSP module) const
void DidLaunch() override
Called after launching a process.
void UnloadSections(const lldb::ModuleSP module) override
Removes the loaded sections from the target in module.
void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr, lldb::addr_t base_addr, bool base_addr_is_offset) override
Updates the load address of every allocatable section in module.
static llvm::StringRef GetPluginNameStatic()
lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread, bool stop_others) override
Provides a plan to step through the dynamic loader trampoline for the current state of thread.
void DidAttach() override
Called after attaching a process.
lldb::addr_t GetEntryPoint()
Computes a value for m_entry_point returning the computed address on success and LLDB_INVALID_ADDRESS...
lldb::addr_t GetLinkMapAddress() const
bool Resolve()
Update the internal snapshot of runtime linker rendezvous and recompute the currently loaded modules.
const ThreadInfo & GetThreadInfo()
SOEntryList::const_iterator iterator
void SetBreakAddress(lldb::addr_t addr)
In hexagon it is possible that we can know the dyld breakpoint without having to find it from the ren...
iterator loaded_begin() const
Iterators over all modules loaded into the inferior since the last call to Resolve().
iterator begin() const
Iterators over all currently loaded modules.
void SetRendezvousAddress(lldb::addr_t)
Provide the dyld structure address.
iterator unloaded_begin() const
Iterators over all modules unloaded from the inferior since the last call to Resolve().
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:81
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:452
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:408
A uniqued constant string class.
Definition: ConstString.h:40
static int Compare(ConstString lhs, ConstString rhs, const bool case_sensitive=true)
Compare two string objects.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
lldb::addr_t ReadPointer(lldb::addr_t addr)
Process * m_process
The process that this dynamic loader plug-in is tracking.
bool GetStopWhenImagesChange() const
Get whether the process should stop when images change.
virtual lldb::ModuleSP LoadModuleAtAddress(const lldb_private::FileSpec &file, lldb::addr_t link_map_addr, lldb::addr_t base_addr, bool base_addr_is_offset)
Locates or creates a module given by file and updates/loads the resulting module at the virtual base ...
A file utility class.
Definition: FileSpec.h:56
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
static FileSystem & Instance()
ConstString GetName(NamePreference preference=ePreferDemangled) const
Best name get accessor.
Definition: Mangled.cpp:325
A collection class for Module objects.
Definition: ModuleList.h:103
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:626
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Definition: ModuleList.cpp:280
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:527
bool Remove(const lldb::ModuleSP &module_sp, bool notify=true)
Remove a module from the module list.
Definition: ModuleList.cpp:334
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
Definition: ModuleList.cpp:247
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1182
ConstString GetObjectName() const
Definition: Module.cpp:1180
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:727
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:590
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
void SetCanJIT(bool can_jit)
Sets whether executing JIT-compiled code in this process is possible.
Definition: Process.cpp:2341
uint64_t ReadUnsignedIntegerFromMemory(lldb::addr_t load_addr, size_t byte_size, uint64_t fail_value, Status &error)
Reads an unsigned integer of the specified byte size from process memory.
Definition: Process.cpp:2079
void SetCanInterpretFunctionCalls(bool can_interpret_function_calls)
Sets whether executing function calls using the interpreter is possible for this process.
Definition: Process.h:2001
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1276
size_t GetSize() const
Definition: Section.h:75
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:544
This base class provides an interface to stack frames.
Definition: StackFrame.h:42
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:300
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
Symbol * symbol
The Symbol for a given query.
Mangled & GetMangled()
Definition: Symbol.h:146
bool IsTrampoline() const
Definition: Symbol.cpp:225
ConstString GetName() const
Definition: Symbol.cpp:552
Address GetAddress() const
Definition: Symbol.h:88
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:228
size_t GetNumSymbols() const
Definition: Symtab.cpp:77
void ModulesDidLoad(ModuleList &module_list)
Definition: Target.cpp:1690
Module * GetExecutableModulePointer()
Definition: Target.cpp:1436
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:328
bool SetSectionUnloaded(const lldb::SectionSP &section_sp)
Definition: Target.cpp:3170
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:1004
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:2158
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1422
void ModulesDidUnload(ModuleList &module_list, bool delete_locations)
Definition: Target.cpp:1724
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:395
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:972
const ArchSpec & GetArchitecture() const
Definition: Target.h:1014
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition: Target.cpp:1471
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:3121
virtual lldb::StackFrameSP GetStackFrameAtIndex(uint32_t idx)
Definition: Thread.h:405
lldb::ProcessSP GetProcess() const
Definition: Thread.h:154
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:441
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:438
uint64_t user_id_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:406
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365