xref: /openbsd-src/gnu/llvm/lldb/source/Core/DynamicLoader.cpp (revision f6aab3d83b51b91c24247ad2c2573574de475a82)
1dda28197Spatrick //===-- DynamicLoader.cpp -------------------------------------------------===//
2061da546Spatrick //
3061da546Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4061da546Spatrick // See https://llvm.org/LICENSE.txt for license information.
5061da546Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6061da546Spatrick //
7061da546Spatrick //===----------------------------------------------------------------------===//
8061da546Spatrick 
9061da546Spatrick #include "lldb/Target/DynamicLoader.h"
10061da546Spatrick 
11061da546Spatrick #include "lldb/Core/Module.h"
12061da546Spatrick #include "lldb/Core/ModuleList.h"
13061da546Spatrick #include "lldb/Core/ModuleSpec.h"
14061da546Spatrick #include "lldb/Core/PluginManager.h"
15061da546Spatrick #include "lldb/Core/Section.h"
16*f6aab3d8Srobert #include "lldb/Symbol/LocateSymbolFile.h"
17061da546Spatrick #include "lldb/Symbol/ObjectFile.h"
18061da546Spatrick #include "lldb/Target/MemoryRegionInfo.h"
19*f6aab3d8Srobert #include "lldb/Target/Platform.h"
20061da546Spatrick #include "lldb/Target/Process.h"
21061da546Spatrick #include "lldb/Target/Target.h"
22061da546Spatrick #include "lldb/Utility/ConstString.h"
23*f6aab3d8Srobert #include "lldb/Utility/LLDBLog.h"
24*f6aab3d8Srobert #include "lldb/Utility/Log.h"
25061da546Spatrick #include "lldb/lldb-private-interfaces.h"
26061da546Spatrick 
27061da546Spatrick #include "llvm/ADT/StringRef.h"
28061da546Spatrick 
29061da546Spatrick #include <memory>
30061da546Spatrick 
31be691f3bSpatrick #include <cassert>
32061da546Spatrick 
33061da546Spatrick using namespace lldb;
34061da546Spatrick using namespace lldb_private;
35061da546Spatrick 
FindPlugin(Process * process,llvm::StringRef plugin_name)36061da546Spatrick DynamicLoader *DynamicLoader::FindPlugin(Process *process,
37*f6aab3d8Srobert                                          llvm::StringRef plugin_name) {
38061da546Spatrick   DynamicLoaderCreateInstance create_callback = nullptr;
39*f6aab3d8Srobert   if (!plugin_name.empty()) {
40061da546Spatrick     create_callback =
41*f6aab3d8Srobert         PluginManager::GetDynamicLoaderCreateCallbackForPluginName(plugin_name);
42061da546Spatrick     if (create_callback) {
43061da546Spatrick       std::unique_ptr<DynamicLoader> instance_up(
44061da546Spatrick           create_callback(process, true));
45061da546Spatrick       if (instance_up)
46061da546Spatrick         return instance_up.release();
47061da546Spatrick     }
48061da546Spatrick   } else {
49061da546Spatrick     for (uint32_t idx = 0;
50061da546Spatrick          (create_callback =
51061da546Spatrick               PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) !=
52061da546Spatrick          nullptr;
53061da546Spatrick          ++idx) {
54061da546Spatrick       std::unique_ptr<DynamicLoader> instance_up(
55061da546Spatrick           create_callback(process, false));
56061da546Spatrick       if (instance_up)
57061da546Spatrick         return instance_up.release();
58061da546Spatrick     }
59061da546Spatrick   }
60061da546Spatrick   return nullptr;
61061da546Spatrick }
62061da546Spatrick 
DynamicLoader(Process * process)63061da546Spatrick DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
64061da546Spatrick 
65*f6aab3d8Srobert // Accessors to the global setting as to whether to stop at image (shared
66061da546Spatrick // library) loading/unloading.
67061da546Spatrick 
GetStopWhenImagesChange() const68061da546Spatrick bool DynamicLoader::GetStopWhenImagesChange() const {
69061da546Spatrick   return m_process->GetStopOnSharedLibraryEvents();
70061da546Spatrick }
71061da546Spatrick 
SetStopWhenImagesChange(bool stop)72061da546Spatrick void DynamicLoader::SetStopWhenImagesChange(bool stop) {
73061da546Spatrick   m_process->SetStopOnSharedLibraryEvents(stop);
74061da546Spatrick }
75061da546Spatrick 
GetTargetExecutable()76061da546Spatrick ModuleSP DynamicLoader::GetTargetExecutable() {
77061da546Spatrick   Target &target = m_process->GetTarget();
78061da546Spatrick   ModuleSP executable = target.GetExecutableModule();
79061da546Spatrick 
80061da546Spatrick   if (executable) {
81061da546Spatrick     if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
82061da546Spatrick       ModuleSpec module_spec(executable->GetFileSpec(),
83061da546Spatrick                              executable->GetArchitecture());
84061da546Spatrick       auto module_sp = std::make_shared<Module>(module_spec);
85061da546Spatrick 
86061da546Spatrick       // Check if the executable has changed and set it to the target
87061da546Spatrick       // executable if they differ.
88061da546Spatrick       if (module_sp && module_sp->GetUUID().IsValid() &&
89061da546Spatrick           executable->GetUUID().IsValid()) {
90061da546Spatrick         if (module_sp->GetUUID() != executable->GetUUID())
91061da546Spatrick           executable.reset();
92061da546Spatrick       } else if (executable->FileHasChanged()) {
93061da546Spatrick         executable.reset();
94061da546Spatrick       }
95061da546Spatrick 
96061da546Spatrick       if (!executable) {
97061da546Spatrick         executable = target.GetOrCreateModule(module_spec, true /* notify */);
98061da546Spatrick         if (executable.get() != target.GetExecutableModulePointer()) {
99061da546Spatrick           // Don't load dependent images since we are in dyld where we will
100061da546Spatrick           // know and find out about all images that are loaded
101061da546Spatrick           target.SetExecutableModule(executable, eLoadDependentsNo);
102061da546Spatrick         }
103061da546Spatrick       }
104061da546Spatrick     }
105061da546Spatrick   }
106061da546Spatrick   return executable;
107061da546Spatrick }
108061da546Spatrick 
UpdateLoadedSections(ModuleSP module,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)109061da546Spatrick void DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr,
110061da546Spatrick                                          addr_t base_addr,
111061da546Spatrick                                          bool base_addr_is_offset) {
112061da546Spatrick   UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
113061da546Spatrick }
114061da546Spatrick 
UpdateLoadedSectionsCommon(ModuleSP module,addr_t base_addr,bool base_addr_is_offset)115061da546Spatrick void DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module,
116061da546Spatrick                                                addr_t base_addr,
117061da546Spatrick                                                bool base_addr_is_offset) {
118061da546Spatrick   bool changed;
119061da546Spatrick   module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset,
120061da546Spatrick                          changed);
121061da546Spatrick }
122061da546Spatrick 
UnloadSections(const ModuleSP module)123061da546Spatrick void DynamicLoader::UnloadSections(const ModuleSP module) {
124061da546Spatrick   UnloadSectionsCommon(module);
125061da546Spatrick }
126061da546Spatrick 
UnloadSectionsCommon(const ModuleSP module)127061da546Spatrick void DynamicLoader::UnloadSectionsCommon(const ModuleSP module) {
128061da546Spatrick   Target &target = m_process->GetTarget();
129061da546Spatrick   const SectionList *sections = GetSectionListFromModule(module);
130061da546Spatrick 
131061da546Spatrick   assert(sections && "SectionList missing from unloaded module.");
132061da546Spatrick 
133061da546Spatrick   const size_t num_sections = sections->GetSize();
134061da546Spatrick   for (size_t i = 0; i < num_sections; ++i) {
135061da546Spatrick     SectionSP section_sp(sections->GetSectionAtIndex(i));
136061da546Spatrick     target.SetSectionUnloaded(section_sp);
137061da546Spatrick   }
138061da546Spatrick }
139061da546Spatrick 
140061da546Spatrick const SectionList *
GetSectionListFromModule(const ModuleSP module) const141061da546Spatrick DynamicLoader::GetSectionListFromModule(const ModuleSP module) const {
142061da546Spatrick   SectionList *sections = nullptr;
143061da546Spatrick   if (module) {
144061da546Spatrick     ObjectFile *obj_file = module->GetObjectFile();
145061da546Spatrick     if (obj_file != nullptr) {
146061da546Spatrick       sections = obj_file->GetSectionList();
147061da546Spatrick     }
148061da546Spatrick   }
149061da546Spatrick   return sections;
150061da546Spatrick }
151061da546Spatrick 
FindModuleViaTarget(const FileSpec & file)152*f6aab3d8Srobert ModuleSP DynamicLoader::FindModuleViaTarget(const FileSpec &file) {
153*f6aab3d8Srobert   Target &target = m_process->GetTarget();
154*f6aab3d8Srobert   ModuleSpec module_spec(file, target.GetArchitecture());
155*f6aab3d8Srobert 
156*f6aab3d8Srobert   if (ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec))
157*f6aab3d8Srobert     return module_sp;
158*f6aab3d8Srobert 
159*f6aab3d8Srobert   if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, false))
160*f6aab3d8Srobert     return module_sp;
161*f6aab3d8Srobert 
162*f6aab3d8Srobert   return nullptr;
163*f6aab3d8Srobert }
164*f6aab3d8Srobert 
LoadModuleAtAddress(const FileSpec & file,addr_t link_map_addr,addr_t base_addr,bool base_addr_is_offset)165061da546Spatrick ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
166061da546Spatrick                                             addr_t link_map_addr,
167061da546Spatrick                                             addr_t base_addr,
168061da546Spatrick                                             bool base_addr_is_offset) {
169*f6aab3d8Srobert   if (ModuleSP module_sp = FindModuleViaTarget(file)) {
170*f6aab3d8Srobert     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
171*f6aab3d8Srobert                          base_addr_is_offset);
172*f6aab3d8Srobert     return module_sp;
173*f6aab3d8Srobert   }
174*f6aab3d8Srobert 
175*f6aab3d8Srobert   return nullptr;
176*f6aab3d8Srobert }
177*f6aab3d8Srobert 
ReadUnnamedMemoryModule(Process * process,addr_t addr,llvm::StringRef name)178*f6aab3d8Srobert static ModuleSP ReadUnnamedMemoryModule(Process *process, addr_t addr,
179*f6aab3d8Srobert                                         llvm::StringRef name) {
180*f6aab3d8Srobert   char namebuf[80];
181*f6aab3d8Srobert   if (name.empty()) {
182*f6aab3d8Srobert     snprintf(namebuf, sizeof(namebuf), "memory-image-0x%" PRIx64, addr);
183*f6aab3d8Srobert     name = namebuf;
184*f6aab3d8Srobert   }
185*f6aab3d8Srobert   return process->ReadModuleFromMemory(FileSpec(name), addr);
186*f6aab3d8Srobert }
187*f6aab3d8Srobert 
LoadBinaryWithUUIDAndAddress(Process * process,llvm::StringRef name,UUID uuid,addr_t value,bool value_is_offset,bool force_symbol_search,bool notify)188*f6aab3d8Srobert ModuleSP DynamicLoader::LoadBinaryWithUUIDAndAddress(
189*f6aab3d8Srobert     Process *process, llvm::StringRef name, UUID uuid, addr_t value,
190*f6aab3d8Srobert     bool value_is_offset, bool force_symbol_search, bool notify) {
191*f6aab3d8Srobert   ModuleSP memory_module_sp;
192061da546Spatrick   ModuleSP module_sp;
193*f6aab3d8Srobert   PlatformSP platform_sp = process->GetTarget().GetPlatform();
194*f6aab3d8Srobert   Target &target = process->GetTarget();
195*f6aab3d8Srobert   Status error;
196*f6aab3d8Srobert   ModuleSpec module_spec;
197*f6aab3d8Srobert   module_spec.GetUUID() = uuid;
198061da546Spatrick 
199*f6aab3d8Srobert   if (!uuid.IsValid() && !value_is_offset) {
200*f6aab3d8Srobert     memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
201*f6aab3d8Srobert 
202*f6aab3d8Srobert     if (memory_module_sp)
203*f6aab3d8Srobert       uuid = memory_module_sp->GetUUID();
204061da546Spatrick   }
205061da546Spatrick 
206*f6aab3d8Srobert   if (uuid.IsValid()) {
207*f6aab3d8Srobert     ModuleSpec module_spec;
208*f6aab3d8Srobert     module_spec.GetUUID() = uuid;
209061da546Spatrick 
210*f6aab3d8Srobert     if (!module_sp)
211*f6aab3d8Srobert       module_sp = target.GetOrCreateModule(module_spec, false, &error);
212061da546Spatrick 
213*f6aab3d8Srobert     // If we haven't found a binary, or we don't have a SymbolFile, see
214*f6aab3d8Srobert     // if there is an external search tool that can find it.
215*f6aab3d8Srobert     if (force_symbol_search &&
216*f6aab3d8Srobert         (!module_sp || !module_sp->GetSymbolFileFileSpec())) {
217*f6aab3d8Srobert       Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
218*f6aab3d8Srobert       if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
219*f6aab3d8Srobert         module_sp = std::make_shared<Module>(module_spec);
220061da546Spatrick       }
221061da546Spatrick     }
222061da546Spatrick   }
223061da546Spatrick 
224*f6aab3d8Srobert   // If we couldn't find the binary anywhere else, as a last resort,
225*f6aab3d8Srobert   // read it out of memory.
226*f6aab3d8Srobert   if (!module_sp.get() && value != LLDB_INVALID_ADDRESS && !value_is_offset) {
227*f6aab3d8Srobert     if (!memory_module_sp)
228*f6aab3d8Srobert       memory_module_sp = ReadUnnamedMemoryModule(process, value, name);
229*f6aab3d8Srobert     if (memory_module_sp)
230*f6aab3d8Srobert       module_sp = memory_module_sp;
231*f6aab3d8Srobert   }
232*f6aab3d8Srobert 
233*f6aab3d8Srobert   Log *log = GetLog(LLDBLog::DynamicLoader);
234*f6aab3d8Srobert   if (module_sp.get()) {
235*f6aab3d8Srobert     // Ensure the Target has an architecture set in case
236*f6aab3d8Srobert     // we need it while processing this binary/eh_frame/debug info.
237*f6aab3d8Srobert     if (!target.GetArchitecture().IsValid())
238*f6aab3d8Srobert       target.SetArchitecture(module_sp->GetArchitecture());
239*f6aab3d8Srobert     target.GetImages().AppendIfNeeded(module_sp, false);
240*f6aab3d8Srobert 
241*f6aab3d8Srobert     bool changed = false;
242*f6aab3d8Srobert     if (module_sp->GetObjectFile()) {
243*f6aab3d8Srobert       if (value != LLDB_INVALID_ADDRESS) {
244*f6aab3d8Srobert         LLDB_LOGF(log, "Loading binary UUID %s at %s 0x%" PRIx64,
245*f6aab3d8Srobert                   uuid.GetAsString().c_str(),
246*f6aab3d8Srobert                   value_is_offset ? "offset" : "address", value);
247*f6aab3d8Srobert         module_sp->SetLoadAddress(target, value, value_is_offset, changed);
248*f6aab3d8Srobert       } else {
249*f6aab3d8Srobert         // No address/offset/slide, load the binary at file address,
250*f6aab3d8Srobert         // offset 0.
251*f6aab3d8Srobert         LLDB_LOGF(log, "Loading binary UUID %s at file address",
252*f6aab3d8Srobert                   uuid.GetAsString().c_str());
253*f6aab3d8Srobert         module_sp->SetLoadAddress(target, 0, true /* value_is_slide */,
254*f6aab3d8Srobert                                   changed);
255*f6aab3d8Srobert       }
256*f6aab3d8Srobert     } else {
257*f6aab3d8Srobert       // In-memory image, load at its true address, offset 0.
258*f6aab3d8Srobert       LLDB_LOGF(log, "Loading binary UUID %s from memory at address 0x%" PRIx64,
259*f6aab3d8Srobert                 uuid.GetAsString().c_str(), value);
260*f6aab3d8Srobert       module_sp->SetLoadAddress(target, 0, true /* value_is_slide */, changed);
261*f6aab3d8Srobert     }
262*f6aab3d8Srobert 
263*f6aab3d8Srobert     if (notify) {
264*f6aab3d8Srobert       ModuleList added_module;
265*f6aab3d8Srobert       added_module.Append(module_sp, false);
266*f6aab3d8Srobert       target.ModulesDidLoad(added_module);
267*f6aab3d8Srobert     }
268*f6aab3d8Srobert   } else {
269*f6aab3d8Srobert     LLDB_LOGF(log, "Unable to find binary with UUID %s and load it at "
270*f6aab3d8Srobert                   "%s 0x%" PRIx64,
271*f6aab3d8Srobert                   uuid.GetAsString().c_str(),
272*f6aab3d8Srobert                   value_is_offset ? "offset" : "address", value);
273061da546Spatrick   }
274061da546Spatrick 
275061da546Spatrick   return module_sp;
276061da546Spatrick }
277061da546Spatrick 
ReadUnsignedIntWithSizeInBytes(addr_t addr,int size_in_bytes)278061da546Spatrick int64_t DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr,
279061da546Spatrick                                                       int size_in_bytes) {
280061da546Spatrick   Status error;
281061da546Spatrick   uint64_t value =
282061da546Spatrick       m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
283061da546Spatrick   if (error.Fail())
284061da546Spatrick     return -1;
285061da546Spatrick   else
286061da546Spatrick     return (int64_t)value;
287061da546Spatrick }
288061da546Spatrick 
ReadPointer(addr_t addr)289061da546Spatrick addr_t DynamicLoader::ReadPointer(addr_t addr) {
290061da546Spatrick   Status error;
291061da546Spatrick   addr_t value = m_process->ReadPointerFromMemory(addr, error);
292061da546Spatrick   if (error.Fail())
293061da546Spatrick     return LLDB_INVALID_ADDRESS;
294061da546Spatrick   else
295061da546Spatrick     return value;
296061da546Spatrick }
297061da546Spatrick 
LoadOperatingSystemPlugin(bool flush)298061da546Spatrick void DynamicLoader::LoadOperatingSystemPlugin(bool flush)
299061da546Spatrick {
300061da546Spatrick     if (m_process)
301061da546Spatrick         m_process->LoadOperatingSystemPlugin(flush);
302061da546Spatrick }
303061da546Spatrick 
304