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/Debugger.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/ModuleList.h"
14 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Core/PluginManager.h"
16 #include "lldb/Core/Progress.h"
17 #include "lldb/Core/Section.h"
18 #include "lldb/Symbol/ObjectFile.h"
19 #include "lldb/Target/MemoryRegionInfo.h"
20 #include "lldb/Target/Platform.h"
21 #include "lldb/Target/Process.h"
22 #include "lldb/Target/Target.h"
23 #include "lldb/Utility/ConstString.h"
24 #include "lldb/Utility/LLDBLog.h"
25 #include "lldb/Utility/Log.h"
26 #include "lldb/lldb-private-interfaces.h"
27
28 #include "llvm/ADT/StringRef.h"
29
30 #include <memory>
31
32 #include <cassert>
33
34 using namespace lldb;
35 using namespace lldb_private;
36
FindPlugin(Process * process,llvm::StringRef plugin_name)37 DynamicLoader *DynamicLoader::FindPlugin(Process *process,
38 llvm::StringRef plugin_name) {
39 DynamicLoaderCreateInstance create_callback = nullptr;
40 if (!plugin_name.empty()) {
41 create_callback =
42 PluginManager::GetDynamicLoaderCreateCallbackForPluginName(plugin_name);
43 if (create_callback) {
44 std::unique_ptr<DynamicLoader> instance_up(
45 create_callback(process, true));
46 if (instance_up)
47 return instance_up.release();
48 }
49 } else {
50 for (uint32_t idx = 0;
51 (create_callback =
52 PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) !=
53 nullptr;
54 ++idx) {
55 std::unique_ptr<DynamicLoader> instance_up(
56 create_callback(process, false));
57 if (instance_up)
58 return instance_up.release();
59 }
60 }
61 return nullptr;
62 }
63
DynamicLoader(Process * process)64 DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
65
66 // Accessors to the global setting as to whether to stop at image (shared
67 // library) loading/unloading.
68
GetStopWhenImagesChange() const69 bool DynamicLoader::GetStopWhenImagesChange() const {
70 return m_process->GetStopOnSharedLibraryEvents();
71 }
72
SetStopWhenImagesChange(bool stop)73 void DynamicLoader::SetStopWhenImagesChange(bool stop) {
74 m_process->SetStopOnSharedLibraryEvents(stop);
75 }
76
GetTargetExecutable()77 ModuleSP DynamicLoader::GetTargetExecutable() {
78 Target &target = m_process->GetTarget();
79 ModuleSP executable = target.GetExecutableModule();
80
81 if (executable) {
82 if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
83 ModuleSpec module_spec(executable->GetFileSpec(),
84 executable->GetArchitecture());
85 auto module_sp = std::make_shared<Module>(module_spec);
86 // If we're a coredump and we already have a main executable, we don't
87 // need to reload the module list that target already has
88 if (!m_process->IsLiveDebugSession()) {
89 return executable;
90 }
91 // Check if the executable has changed and set it to the target
92 // executable if they differ.
93 if (module_sp && module_sp->GetUUID().IsValid() &&
94 executable->GetUUID().IsValid()) {
95 if (module_sp->GetUUID() != executable->GetUUID())
96 executable.reset();
97 } else if (executable->FileHasChanged()) {
98 executable.reset();
99 }
100
101 if (!executable) {
102 executable = target.GetOrCreateModule(module_spec, true /* notify */);
103 if (executable.get() != target.GetExecutableModulePointer()) {
104 // Don't load dependent images since we are in dyld where we will
105 // know and find out about all images that are loaded
106 target.SetExecutableModule(executable, eLoadDependentsNo);
107 }
108 }
109 }
110 }
111 return executable;
112 }
113
UpdateLoadedSections(ModuleSP module,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)114 void DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr,
115 addr_t base_addr,
116 bool base_addr_is_offset) {
117 UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
118 }
119
UpdateLoadedSectionsCommon(ModuleSP module,addr_t base_addr,bool base_addr_is_offset)120 void DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module,
121 addr_t base_addr,
122 bool base_addr_is_offset) {
123 bool changed;
124 module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset,
125 changed);
126 }
127
UnloadSections(const ModuleSP module)128 void DynamicLoader::UnloadSections(const ModuleSP module) {
129 UnloadSectionsCommon(module);
130 }
131
UnloadSectionsCommon(const ModuleSP module)132 void DynamicLoader::UnloadSectionsCommon(const ModuleSP module) {
133 Target &target = m_process->GetTarget();
134 const SectionList *sections = GetSectionListFromModule(module);
135
136 assert(sections && "SectionList missing from unloaded module.");
137
138 const size_t num_sections = sections->GetSize();
139 for (size_t i = 0; i < num_sections; ++i) {
140 SectionSP section_sp(sections->GetSectionAtIndex(i));
141 target.SetSectionUnloaded(section_sp);
142 }
143 }
144
145 const SectionList *
GetSectionListFromModule(const ModuleSP module) const146 DynamicLoader::GetSectionListFromModule(const ModuleSP module) const {
147 SectionList *sections = nullptr;
148 if (module) {
149 ObjectFile *obj_file = module->GetObjectFile();
150 if (obj_file != nullptr) {
151 sections = obj_file->GetSectionList();
152 }
153 }
154 return sections;
155 }
156
FindModuleViaTarget(const FileSpec & file)157 ModuleSP DynamicLoader::FindModuleViaTarget(const FileSpec &file) {
158 Target &target = m_process->GetTarget();
159 ModuleSpec module_spec(file, target.GetArchitecture());
160 if (UUID uuid = m_process->FindModuleUUID(file.GetPath())) {
161 // Process may be able to augment the module_spec with UUID, e.g. ELF core.
162 module_spec.GetUUID() = uuid;
163 }
164
165 if (ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec))
166 return module_sp;
167
168 if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, false))
169 return module_sp;
170
171 return nullptr;
172 }
173
LoadModuleAtAddress(const FileSpec & file,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)174 ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
175 addr_t link_map_addr,
176 addr_t base_addr,
177 bool base_addr_is_offset) {
178 if (ModuleSP module_sp = FindModuleViaTarget(file)) {
179 UpdateLoadedSections(module_sp, link_map_addr, base_addr,
180 base_addr_is_offset);
181 return module_sp;
182 }
183
184 return nullptr;
185 }
186
ReadUnnamedMemoryModule(Process * process,addr_t addr,llvm::StringRef name)187 static ModuleSP ReadUnnamedMemoryModule(Process *process, addr_t addr,
188 llvm::StringRef name) {
189 char namebuf[80];
190 if (name.empty()) {
191 snprintf(namebuf, sizeof(namebuf), "memory-image-0x%" PRIx64, addr);
192 name = namebuf;
193 }
194 return process->ReadModuleFromMemory(FileSpec(name), addr);
195 }
196
LoadBinaryWithUUIDAndAddress(Process * process,llvm::StringRef name,UUID uuid,addr_t value,bool value_is_offset,bool force_symbol_search,bool notify,bool set_address_in_target,bool allow_memory_image_last_resort)197 ModuleSP DynamicLoader::LoadBinaryWithUUIDAndAddress(
198 Process *process, llvm::StringRef name, UUID uuid, addr_t value,
199 bool value_is_offset, bool force_symbol_search, bool notify,
200 bool set_address_in_target, bool allow_memory_image_last_resort) {
201 ModuleSP memory_module_sp;
202 ModuleSP module_sp;
203 PlatformSP platform_sp = process->GetTarget().GetPlatform();
204 Target &target = process->GetTarget();
205 Status error;
206
207 StreamString prog_str;
208 if (!name.empty()) {
209 prog_str << name.str() << " ";
210 }
211 if (uuid.IsValid())
212 prog_str << uuid.GetAsString();
213 if (value_is_offset == 0 && value != LLDB_INVALID_ADDRESS) {
214 prog_str << "at 0x";
215 prog_str.PutHex64(value);
216 }
217
218 if (!uuid.IsValid() && !value_is_offset) {
219 memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
220
221 if (memory_module_sp) {
222 uuid = memory_module_sp->GetUUID();
223 if (uuid.IsValid()) {
224 prog_str << " ";
225 prog_str << uuid.GetAsString();
226 }
227 }
228 }
229 ModuleSpec module_spec;
230 module_spec.GetUUID() = uuid;
231 FileSpec name_filespec(name);
232 if (FileSystem::Instance().Exists(name_filespec))
233 module_spec.GetFileSpec() = name_filespec;
234
235 if (uuid.IsValid()) {
236 Progress progress("Locating binary", prog_str.GetString().str());
237
238 // Has lldb already seen a module with this UUID?
239 // Or have external lookup enabled in DebugSymbols on macOS.
240 if (!module_sp)
241 error = ModuleList::GetSharedModule(module_spec, module_sp, nullptr,
242 nullptr, nullptr);
243
244 // Can lldb's symbol/executable location schemes
245 // find an executable and symbol file.
246 if (!module_sp) {
247 FileSpecList search_paths = Target::GetDefaultDebugFileSearchPaths();
248 StatisticsMap symbol_locator_map;
249 module_spec.GetSymbolFileSpec() =
250 PluginManager::LocateExecutableSymbolFile(module_spec, search_paths,
251 symbol_locator_map);
252 ModuleSpec objfile_module_spec =
253 PluginManager::LocateExecutableObjectFile(module_spec,
254 symbol_locator_map);
255 module_spec.GetFileSpec() = objfile_module_spec.GetFileSpec();
256 if (FileSystem::Instance().Exists(module_spec.GetFileSpec()) &&
257 FileSystem::Instance().Exists(module_spec.GetSymbolFileSpec())) {
258 module_sp = std::make_shared<Module>(module_spec);
259 }
260
261 if (module_sp) {
262 module_sp->GetSymbolLocatorStatistics().merge(symbol_locator_map);
263 }
264 }
265
266 // If we haven't found a binary, or we don't have a SymbolFile, see
267 // if there is an external search tool that can find it.
268 if (!module_sp || !module_sp->GetSymbolFileFileSpec()) {
269 PluginManager::DownloadObjectAndSymbolFile(module_spec, error,
270 force_symbol_search);
271 if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
272 module_sp = std::make_shared<Module>(module_spec);
273 } else if (force_symbol_search && error.AsCString("") &&
274 error.AsCString("")[0] != '\0') {
275 *target.GetDebugger().GetAsyncErrorStream() << error.AsCString();
276 }
277 }
278
279 // If we only found the executable, create a Module based on that.
280 if (!module_sp && FileSystem::Instance().Exists(module_spec.GetFileSpec()))
281 module_sp = std::make_shared<Module>(module_spec);
282 }
283
284 // If we couldn't find the binary anywhere else, as a last resort,
285 // read it out of memory.
286 if (allow_memory_image_last_resort && !module_sp.get() &&
287 value != LLDB_INVALID_ADDRESS && !value_is_offset) {
288 if (!memory_module_sp)
289 memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
290 if (memory_module_sp)
291 module_sp = memory_module_sp;
292 }
293
294 Log *log = GetLog(LLDBLog::DynamicLoader);
295 if (module_sp.get()) {
296 // Ensure the Target has an architecture set in case
297 // we need it while processing this binary/eh_frame/debug info.
298 if (!target.GetArchitecture().IsValid())
299 target.SetArchitecture(module_sp->GetArchitecture());
300 target.GetImages().AppendIfNeeded(module_sp, false);
301
302 bool changed = false;
303 if (set_address_in_target) {
304 if (module_sp->GetObjectFile()) {
305 if (value != LLDB_INVALID_ADDRESS) {
306 LLDB_LOGF(log,
307 "DynamicLoader::LoadBinaryWithUUIDAndAddress Loading "
308 "binary %s UUID %s at %s 0x%" PRIx64,
309 name.str().c_str(), uuid.GetAsString().c_str(),
310 value_is_offset ? "offset" : "address", value);
311 module_sp->SetLoadAddress(target, value, value_is_offset, changed);
312 } else {
313 // No address/offset/slide, load the binary at file address,
314 // offset 0.
315 LLDB_LOGF(log,
316 "DynamicLoader::LoadBinaryWithUUIDAndAddress Loading "
317 "binary %s UUID %s at file address",
318 name.str().c_str(), uuid.GetAsString().c_str());
319 module_sp->SetLoadAddress(target, 0, true /* value_is_slide */,
320 changed);
321 }
322 } else {
323 // In-memory image, load at its true address, offset 0.
324 LLDB_LOGF(log,
325 "DynamicLoader::LoadBinaryWithUUIDAndAddress Loading binary "
326 "%s UUID %s from memory at address 0x%" PRIx64,
327 name.str().c_str(), uuid.GetAsString().c_str(), value);
328 module_sp->SetLoadAddress(target, 0, true /* value_is_slide */,
329 changed);
330 }
331 }
332
333 if (notify) {
334 ModuleList added_module;
335 added_module.Append(module_sp, false);
336 target.ModulesDidLoad(added_module);
337 }
338 } else {
339 if (force_symbol_search) {
340 lldb::StreamUP s = target.GetDebugger().GetAsyncErrorStream();
341 s->Printf("Unable to find file");
342 if (!name.empty())
343 s->Printf(" %s", name.str().c_str());
344 if (uuid.IsValid())
345 s->Printf(" with UUID %s", uuid.GetAsString().c_str());
346 if (value != LLDB_INVALID_ADDRESS) {
347 if (value_is_offset)
348 s->Printf(" with slide 0x%" PRIx64, value);
349 else
350 s->Printf(" at address 0x%" PRIx64, value);
351 }
352 s->Printf("\n");
353 }
354 LLDB_LOGF(log,
355 "Unable to find binary %s with UUID %s and load it at "
356 "%s 0x%" PRIx64,
357 name.str().c_str(), uuid.GetAsString().c_str(),
358 value_is_offset ? "offset" : "address", value);
359 }
360
361 return module_sp;
362 }
363
ReadUnsignedIntWithSizeInBytes(addr_t addr,int size_in_bytes)364 int64_t DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr,
365 int size_in_bytes) {
366 Status error;
367 uint64_t value =
368 m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
369 if (error.Fail())
370 return -1;
371 else
372 return (int64_t)value;
373 }
374
ReadPointer(addr_t addr)375 addr_t DynamicLoader::ReadPointer(addr_t addr) {
376 Status error;
377 addr_t value = m_process->ReadPointerFromMemory(addr, error);
378 if (error.Fail())
379 return LLDB_INVALID_ADDRESS;
380 else
381 return value;
382 }
383
LoadOperatingSystemPlugin(bool flush)384 void DynamicLoader::LoadOperatingSystemPlugin(bool flush)
385 {
386 if (m_process)
387 m_process->LoadOperatingSystemPlugin(flush);
388 }
389