1 //===-- DynamicLoader.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/Target/DynamicLoader.h"
10
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleList.h"
13 #include "lldb/Core/ModuleSpec.h"
14 #include "lldb/Core/PluginManager.h"
15 #include "lldb/Core/Section.h"
16 #include "lldb/Symbol/LocateSymbolFile.h"
17 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Target/MemoryRegionInfo.h"
19 #include "lldb/Target/Platform.h"
20 #include "lldb/Target/Process.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/ConstString.h"
23 #include "lldb/Utility/LLDBLog.h"
24 #include "lldb/Utility/Log.h"
25 #include "lldb/lldb-private-interfaces.h"
26
27 #include "llvm/ADT/StringRef.h"
28
29 #include <memory>
30
31 #include <cassert>
32
33 using namespace lldb;
34 using namespace lldb_private;
35
FindPlugin(Process * process,llvm::StringRef plugin_name)36 DynamicLoader *DynamicLoader::FindPlugin(Process *process,
37 llvm::StringRef plugin_name) {
38 DynamicLoaderCreateInstance create_callback = nullptr;
39 if (!plugin_name.empty()) {
40 create_callback =
41 PluginManager::GetDynamicLoaderCreateCallbackForPluginName(plugin_name);
42 if (create_callback) {
43 std::unique_ptr<DynamicLoader> instance_up(
44 create_callback(process, true));
45 if (instance_up)
46 return instance_up.release();
47 }
48 } else {
49 for (uint32_t idx = 0;
50 (create_callback =
51 PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) !=
52 nullptr;
53 ++idx) {
54 std::unique_ptr<DynamicLoader> instance_up(
55 create_callback(process, false));
56 if (instance_up)
57 return instance_up.release();
58 }
59 }
60 return nullptr;
61 }
62
DynamicLoader(Process * process)63 DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
64
65 // Accessors to the global setting as to whether to stop at image (shared
66 // library) loading/unloading.
67
GetStopWhenImagesChange() const68 bool DynamicLoader::GetStopWhenImagesChange() const {
69 return m_process->GetStopOnSharedLibraryEvents();
70 }
71
SetStopWhenImagesChange(bool stop)72 void DynamicLoader::SetStopWhenImagesChange(bool stop) {
73 m_process->SetStopOnSharedLibraryEvents(stop);
74 }
75
GetTargetExecutable()76 ModuleSP DynamicLoader::GetTargetExecutable() {
77 Target &target = m_process->GetTarget();
78 ModuleSP executable = target.GetExecutableModule();
79
80 if (executable) {
81 if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
82 ModuleSpec module_spec(executable->GetFileSpec(),
83 executable->GetArchitecture());
84 auto module_sp = std::make_shared<Module>(module_spec);
85
86 // Check if the executable has changed and set it to the target
87 // executable if they differ.
88 if (module_sp && module_sp->GetUUID().IsValid() &&
89 executable->GetUUID().IsValid()) {
90 if (module_sp->GetUUID() != executable->GetUUID())
91 executable.reset();
92 } else if (executable->FileHasChanged()) {
93 executable.reset();
94 }
95
96 if (!executable) {
97 executable = target.GetOrCreateModule(module_spec, true /* notify */);
98 if (executable.get() != target.GetExecutableModulePointer()) {
99 // Don't load dependent images since we are in dyld where we will
100 // know and find out about all images that are loaded
101 target.SetExecutableModule(executable, eLoadDependentsNo);
102 }
103 }
104 }
105 }
106 return executable;
107 }
108
UpdateLoadedSections(ModuleSP module,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)109 void DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr,
110 addr_t base_addr,
111 bool base_addr_is_offset) {
112 UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
113 }
114
UpdateLoadedSectionsCommon(ModuleSP module,addr_t base_addr,bool base_addr_is_offset)115 void DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module,
116 addr_t base_addr,
117 bool base_addr_is_offset) {
118 bool changed;
119 module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset,
120 changed);
121 }
122
UnloadSections(const ModuleSP module)123 void DynamicLoader::UnloadSections(const ModuleSP module) {
124 UnloadSectionsCommon(module);
125 }
126
UnloadSectionsCommon(const ModuleSP module)127 void DynamicLoader::UnloadSectionsCommon(const ModuleSP module) {
128 Target &target = m_process->GetTarget();
129 const SectionList *sections = GetSectionListFromModule(module);
130
131 assert(sections && "SectionList missing from unloaded module.");
132
133 const size_t num_sections = sections->GetSize();
134 for (size_t i = 0; i < num_sections; ++i) {
135 SectionSP section_sp(sections->GetSectionAtIndex(i));
136 target.SetSectionUnloaded(section_sp);
137 }
138 }
139
140 const SectionList *
GetSectionListFromModule(const ModuleSP module) const141 DynamicLoader::GetSectionListFromModule(const ModuleSP module) const {
142 SectionList *sections = nullptr;
143 if (module) {
144 ObjectFile *obj_file = module->GetObjectFile();
145 if (obj_file != nullptr) {
146 sections = obj_file->GetSectionList();
147 }
148 }
149 return sections;
150 }
151
FindModuleViaTarget(const FileSpec & file)152 ModuleSP DynamicLoader::FindModuleViaTarget(const FileSpec &file) {
153 Target &target = m_process->GetTarget();
154 ModuleSpec module_spec(file, target.GetArchitecture());
155
156 if (ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec))
157 return module_sp;
158
159 if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, false))
160 return module_sp;
161
162 return nullptr;
163 }
164
LoadModuleAtAddress(const FileSpec & file,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)165 ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
166 addr_t link_map_addr,
167 addr_t base_addr,
168 bool base_addr_is_offset) {
169 if (ModuleSP module_sp = FindModuleViaTarget(file)) {
170 UpdateLoadedSections(module_sp, link_map_addr, base_addr,
171 base_addr_is_offset);
172 return module_sp;
173 }
174
175 return nullptr;
176 }
177
ReadUnnamedMemoryModule(Process * process,addr_t addr,llvm::StringRef name)178 static ModuleSP ReadUnnamedMemoryModule(Process *process, addr_t addr,
179 llvm::StringRef name) {
180 char namebuf[80];
181 if (name.empty()) {
182 snprintf(namebuf, sizeof(namebuf), "memory-image-0x%" PRIx64, addr);
183 name = namebuf;
184 }
185 return process->ReadModuleFromMemory(FileSpec(name), addr);
186 }
187
LoadBinaryWithUUIDAndAddress(Process * process,llvm::StringRef name,UUID uuid,addr_t value,bool value_is_offset,bool force_symbol_search,bool notify)188 ModuleSP DynamicLoader::LoadBinaryWithUUIDAndAddress(
189 Process *process, llvm::StringRef name, UUID uuid, addr_t value,
190 bool value_is_offset, bool force_symbol_search, bool notify) {
191 ModuleSP memory_module_sp;
192 ModuleSP module_sp;
193 PlatformSP platform_sp = process->GetTarget().GetPlatform();
194 Target &target = process->GetTarget();
195 Status error;
196 ModuleSpec module_spec;
197 module_spec.GetUUID() = uuid;
198
199 if (!uuid.IsValid() && !value_is_offset) {
200 memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
201
202 if (memory_module_sp)
203 uuid = memory_module_sp->GetUUID();
204 }
205
206 if (uuid.IsValid()) {
207 ModuleSpec module_spec;
208 module_spec.GetUUID() = uuid;
209
210 if (!module_sp)
211 module_sp = target.GetOrCreateModule(module_spec, false, &error);
212
213 // If we haven't found a binary, or we don't have a SymbolFile, see
214 // if there is an external search tool that can find it.
215 if (force_symbol_search &&
216 (!module_sp || !module_sp->GetSymbolFileFileSpec())) {
217 Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
218 if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
219 module_sp = std::make_shared<Module>(module_spec);
220 }
221 }
222 }
223
224 // If we couldn't find the binary anywhere else, as a last resort,
225 // read it out of memory.
226 if (!module_sp.get() && value != LLDB_INVALID_ADDRESS && !value_is_offset) {
227 if (!memory_module_sp)
228 memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
229 if (memory_module_sp)
230 module_sp = memory_module_sp;
231 }
232
233 Log *log = GetLog(LLDBLog::DynamicLoader);
234 if (module_sp.get()) {
235 // Ensure the Target has an architecture set in case
236 // we need it while processing this binary/eh_frame/debug info.
237 if (!target.GetArchitecture().IsValid())
238 target.SetArchitecture(module_sp->GetArchitecture());
239 target.GetImages().AppendIfNeeded(module_sp, false);
240
241 bool changed = false;
242 if (module_sp->GetObjectFile()) {
243 if (value != LLDB_INVALID_ADDRESS) {
244 LLDB_LOGF(log, "Loading binary UUID %s at %s 0x%" PRIx64,
245 uuid.GetAsString().c_str(),
246 value_is_offset ? "offset" : "address", value);
247 module_sp->SetLoadAddress(target, value, value_is_offset, changed);
248 } else {
249 // No address/offset/slide, load the binary at file address,
250 // offset 0.
251 LLDB_LOGF(log, "Loading binary UUID %s at file address",
252 uuid.GetAsString().c_str());
253 module_sp->SetLoadAddress(target, 0, true /* value_is_slide */,
254 changed);
255 }
256 } else {
257 // In-memory image, load at its true address, offset 0.
258 LLDB_LOGF(log, "Loading binary UUID %s from memory at address 0x%" PRIx64,
259 uuid.GetAsString().c_str(), value);
260 module_sp->SetLoadAddress(target, 0, true /* value_is_slide */, changed);
261 }
262
263 if (notify) {
264 ModuleList added_module;
265 added_module.Append(module_sp, false);
266 target.ModulesDidLoad(added_module);
267 }
268 } else {
269 LLDB_LOGF(log, "Unable to find binary with UUID %s and load it at "
270 "%s 0x%" PRIx64,
271 uuid.GetAsString().c_str(),
272 value_is_offset ? "offset" : "address", value);
273 }
274
275 return module_sp;
276 }
277
ReadUnsignedIntWithSizeInBytes(addr_t addr,int size_in_bytes)278 int64_t DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr,
279 int size_in_bytes) {
280 Status error;
281 uint64_t value =
282 m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
283 if (error.Fail())
284 return -1;
285 else
286 return (int64_t)value;
287 }
288
ReadPointer(addr_t addr)289 addr_t DynamicLoader::ReadPointer(addr_t addr) {
290 Status error;
291 addr_t value = m_process->ReadPointerFromMemory(addr, error);
292 if (error.Fail())
293 return LLDB_INVALID_ADDRESS;
294 else
295 return value;
296 }
297
LoadOperatingSystemPlugin(bool flush)298 void DynamicLoader::LoadOperatingSystemPlugin(bool flush)
299 {
300 if (m_process)
301 m_process->LoadOperatingSystemPlugin(flush);
302 }
303
304