LLDB mainline
DynamicLoaderPOSIXDYLD.h
Go to the documentation of this file.
1//===-- DynamicLoaderPOSIXDYLD.h --------------------------------*- 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#ifndef LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYNAMICLOADERPOSIXDYLD_H
10#define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYNAMICLOADERPOSIXDYLD_H
11
12#include <map>
13#include <memory>
14
15#include "DYLDRendezvous.h"
20
21class AuxVector;
22
24public:
26
27 ~DynamicLoaderPOSIXDYLD() override;
28
29 static void Initialize();
30
31 static void Terminate();
32
33 static llvm::StringRef GetPluginNameStatic() { return "posix-dyld"; }
34
35 static llvm::StringRef GetPluginDescriptionStatic();
36
38 CreateInstance(lldb_private::Process *process, bool force);
39
40 // DynamicLoader protocol
41
42 void DidAttach() override;
43
44 void DidLaunch() override;
45
47 bool stop_others) override;
48
50
52 const lldb::ThreadSP thread,
53 lldb::addr_t tls_file_addr) override;
54
55 // PluginInterface protocol
56 llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
57
59 lldb::addr_t link_map_addr,
60 lldb::addr_t base_addr,
61 bool base_addr_is_offset) override;
62
63protected:
64 /// Runtime linker rendezvous structure.
66
67 /// Virtual load address of the inferior process.
69
70 /// Virtual entry address of the inferior process.
72
73 /// Auxiliary vector of the inferior process.
74 std::unique_ptr<AuxVector> m_auxv;
75
76 /// Rendezvous breakpoint.
78
79 /// Contains AT_SYSINFO_EHDR, which means a vDSO has been
80 /// mapped to the address space
82
83 /// Contains AT_BASE, which means a dynamic loader has been
84 /// mapped to the address space
86
87 /// Contains the pointer to the interpret module, if loaded.
88 std::weak_ptr<lldb_private::Module> m_interpreter_module;
89
90 /// Loaded module list. (link map for each module)
91 std::map<lldb::ModuleWP, lldb::addr_t, std::owner_less<lldb::ModuleWP>>
93
94 /// Returns true if the process is for a core file.
95 bool IsCoreFile() const;
96
97 /// If possible sets a breakpoint on a function called by the runtime
98 /// linker each time a module is loaded or unloaded.
100
101 /// Callback routine which updates the current list of loaded modules based
102 /// on the information supplied by the runtime linker.
103 static bool RendezvousBreakpointHit(
104 void *baton, lldb_private::StoppointCallbackContext *context,
105 lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
106
107 /// Indicates whether the initial set of modules was reported added.
109
110 /// Helper method for RendezvousBreakpointHit. Updates LLDB's current set
111 /// of loaded modules.
112 void RefreshModules();
113
114 /// Updates the load address of every allocatable section in \p module.
115 ///
116 /// \param module The module to traverse.
117 ///
118 /// \param link_map_addr The virtual address of the link map for the @p
119 /// module.
120 ///
121 /// \param base_addr The virtual base address \p module is loaded at.
122 void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr,
123 lldb::addr_t base_addr,
124 bool base_addr_is_offset) override;
125
126 /// Removes the loaded sections from the target in \p module.
127 ///
128 /// \param module The module to traverse.
129 void UnloadSections(const lldb::ModuleSP module) override;
130
131 /// Resolves the entry point for the current inferior process and sets a
132 /// breakpoint at that address.
133 void ProbeEntry();
134
135 /// Callback routine invoked when we hit the breakpoint on process entry.
136 ///
137 /// This routine is responsible for resolving the load addresses of all
138 /// dependent modules required by the inferior and setting up the rendezvous
139 /// breakpoint.
140 static bool
141 EntryBreakpointHit(void *baton,
143 lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
144
145 /// Helper for the entry breakpoint callback. Resolves the load addresses
146 /// of all dependent modules.
147 virtual void LoadAllCurrentModules();
148
149 void LoadVDSO();
150
151 // Loading an interpreter module (if present) assuming m_interpreter_base
152 // already points to its base address.
154
155 /// Computes a value for m_load_offset returning the computed address on
156 /// success and LLDB_INVALID_ADDRESS on failure.
158
159 /// Computes a value for m_entry_point returning the computed address on
160 /// success and LLDB_INVALID_ADDRESS on failure.
162
163 /// Evaluate if Aux vectors contain vDSO and LD information
164 /// in case they do, read and assign the address to m_vdso_base
165 /// and m_interpreter_base.
167
168 /// Loads Module from inferior process.
170
172
173private:
177};
178
179#endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYNAMICLOADERPOSIXDYLD_H
Interface to the runtime linker.
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...
std::map< lldb::ModuleWP, lldb::addr_t, std::owner_less< lldb::ModuleWP > > m_loaded_modules
Loaded module list. (link map for each module)
static lldb_private::DynamicLoader * CreateInstance(lldb_private::Process *process, bool force)
bool m_initial_modules_added
Indicates whether the initial set of modules was reported added.
lldb::addr_t m_load_offset
Virtual load address of the inferior process.
DynamicLoaderPOSIXDYLD(const DynamicLoaderPOSIXDYLD &)=delete
lldb::break_id_t m_dyld_bid
Rendezvous breakpoint.
lldb::addr_t GetEntryPoint()
Computes a value for m_entry_point returning the computed address on success and LLDB_INVALID_ADDRESS...
std::unique_ptr< AuxVector > m_auxv
Auxiliary vector of the inferior process.
static llvm::StringRef GetPluginDescriptionStatic()
void EvalSpecialModulesStatus()
Evaluate if Aux vectors contain vDSO and LD information in case they do, read and assign the address ...
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.
bool SetRendezvousBreakpoint()
If possible sets a breakpoint on a function called by the runtime linker each time a module is loaded...
lldb::ModuleSP LoadInterpreterModule()
void RefreshModules()
Helper method for RendezvousBreakpointHit.
bool AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override
Ask if the eh_frame information for the given SymbolContext should be relied on even when it's the fi...
lldb::addr_t m_interpreter_base
Contains AT_BASE, which means a dynamic loader has been mapped to the address space.
void ProbeEntry()
Resolves the entry point for the current inferior process and sets a breakpoint at that address.
lldb_private::Status CanLoadImage() override
Ask if it is ok to try and load or unload an shared library (image).
const DynamicLoaderPOSIXDYLD & operator=(const DynamicLoaderPOSIXDYLD &)=delete
lldb::addr_t m_vdso_base
Contains AT_SYSINFO_EHDR, which means a vDSO has been mapped to the address space.
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.
lldb::addr_t ComputeLoadOffset()
Computes a value for m_load_offset returning the computed address on success and LLDB_INVALID_ADDRESS...
void UnloadSections(const lldb::ModuleSP module) override
Removes the loaded sections from the target in module.
DYLDRendezvous m_rendezvous
Runtime linker rendezvous structure.
void DidLaunch() override
Called after launching a process.
lldb::ModuleSP LoadModuleAtAddress(const lldb_private::FileSpec &file, lldb::addr_t link_map_addr, lldb::addr_t base_addr, bool base_addr_is_offset) override
Locates or creates a module given by file and updates/loads the resulting module at the virtual base ...
static bool EntryBreakpointHit(void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Callback routine invoked when we hit the breakpoint on process entry.
void DidAttach() override
Called after attaching a process.
llvm::StringRef GetPluginName() override
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.
static llvm::StringRef GetPluginNameStatic()
void ResolveExecutableModule(lldb::ModuleSP &module_sp)
Loads Module from inferior process.
lldb::addr_t m_entry_point
Virtual entry address of the inferior process.
virtual void LoadAllCurrentModules()
Helper for the entry breakpoint callback.
std::weak_ptr< lldb_private::Module > m_interpreter_module
Contains the pointer to the interpret module, if loaded.
bool IsCoreFile() const
Returns true if the process is for a core file.
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
A file utility class.
Definition: FileSpec.h:56
A plug-in interface definition class for debugging a process.
Definition: Process.h:341
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...
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:34
std::shared_ptr< lldb_private::ThreadPlan > ThreadPlanSP
Definition: lldb-forward.h:447
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:444
int32_t break_id_t
Definition: lldb-types.h:86
uint64_t user_id_t
Definition: lldb-types.h:82
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:369