contrib/llvm/tools/lldb/source/Core/DynamicLoader.cpp

   1 //===-- DynamicLoader.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Target/DynamicLoader.h"
  11
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Core/ModuleList.h" // for ModuleList
  14 #include "lldb/Core/ModuleSpec.h"
  15 #include "lldb/Core/PluginManager.h"
  16 #include "lldb/Core/Section.h"
  17 #include "lldb/Symbol/ObjectFile.h" // for ObjectFile
  18 #include "lldb/Target/MemoryRegionInfo.h"
  19 #include "lldb/Target/Process.h"
  20 #include "lldb/Target/Target.h"
  21 #include "lldb/Utility/ConstString.h"     // for ConstString
  22 #include "lldb/lldb-private-interfaces.h" // for DynamicLoaderCreateInstance
  23
  24 #include "llvm/ADT/StringRef.h" // for StringRef
  25
  26 #include <memory> // for shared_ptr, unique_ptr
  27
  28 #include <assert.h> // for assert
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 DynamicLoader *DynamicLoader::FindPlugin(Process *process,
  34                                          const char *plugin_name) {
  35   DynamicLoaderCreateInstance create_callback = nullptr;
  36   if (plugin_name) {
  37     ConstString const_plugin_name(plugin_name);
  38     create_callback =
  39         PluginManager::GetDynamicLoaderCreateCallbackForPluginName(
  40             const_plugin_name);
  41     if (create_callback) {
  42       std::unique_ptr<DynamicLoader> instance_ap(
  43           create_callback(process, true));
  44       if (instance_ap)
  45         return instance_ap.release();
  46     }
  47   } else {
  48     for (uint32_t idx = 0;
  49          (create_callback =
  50               PluginManager::GetDynamicLoaderCreateCallbackAtIndex(idx)) !=
  51          nullptr;
  52          ++idx) {
  53       std::unique_ptr<DynamicLoader> instance_ap(
  54           create_callback(process, false));
  55       if (instance_ap)
  56         return instance_ap.release();
  57     }
  58   }
  59   return nullptr;
  60 }
  61
  62 DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
  63
  64 DynamicLoader::~DynamicLoader() = default;
  65
  66 //----------------------------------------------------------------------
  67 // Accessosors to the global setting as to whether to stop at image (shared
  68 // library) loading/unloading.
  69 //----------------------------------------------------------------------
  70
  71 bool DynamicLoader::GetStopWhenImagesChange() const {
  72   return m_process->GetStopOnSharedLibraryEvents();
  73 }
  74
  75 void DynamicLoader::SetStopWhenImagesChange(bool stop) {
  76   m_process->SetStopOnSharedLibraryEvents(stop);
  77 }
  78
  79 ModuleSP DynamicLoader::GetTargetExecutable() {
  80   Target &target = m_process->GetTarget();
  81   ModuleSP executable = target.GetExecutableModule();
  82
  83   if (executable) {
  84     if (executable->GetFileSpec().Exists()) {
  85       ModuleSpec module_spec(executable->GetFileSpec(),
  86                              executable->GetArchitecture());
  87       auto module_sp = std::make_shared<Module>(module_spec);
  88
  89       // Check if the executable has changed and set it to the target
  90       // executable if they differ.
  91       if (module_sp && module_sp->GetUUID().IsValid() &&
  92           executable->GetUUID().IsValid()) {
  93         if (module_sp->GetUUID() != executable->GetUUID())
  94           executable.reset();
  95       } else if (executable->FileHasChanged()) {
  96         executable.reset();
  97       }
  98
  99       if (!executable) {
 100         executable = target.GetSharedModule(module_spec);
 101         if (executable.get() != target.GetExecutableModulePointer()) {
 102           // Don't load dependent images since we are in dyld where we will
 103           // know and find out about all images that are loaded
 104           const bool get_dependent_images = false;
 105           target.SetExecutableModule(executable, get_dependent_images);
 106         }
 107       }
 108     }
 109   }
 110   return executable;
 111 }
 112
 113 void DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr,
 114                                          addr_t base_addr,
 115                                          bool base_addr_is_offset) {
 116   UpdateLoadedSectionsCommon(module, base_addr, base_addr_is_offset);
 117 }
 118
 119 void DynamicLoader::UpdateLoadedSectionsCommon(ModuleSP module,
 120                                                addr_t base_addr,
 121                                                bool base_addr_is_offset) {
 122   bool changed;
 123   module->SetLoadAddress(m_process->GetTarget(), base_addr, base_addr_is_offset,
 124                          changed);
 125 }
 126
 127 void DynamicLoader::UnloadSections(const ModuleSP module) {
 128   UnloadSectionsCommon(module);
 129 }
 130
 131 void DynamicLoader::UnloadSectionsCommon(const ModuleSP module) {
 132   Target &target = m_process->GetTarget();
 133   const SectionList *sections = GetSectionListFromModule(module);
 134
 135   assert(sections && "SectionList missing from unloaded module.");
 136
 137   const size_t num_sections = sections->GetSize();
 138   for (size_t i = 0; i < num_sections; ++i) {
 139     SectionSP section_sp(sections->GetSectionAtIndex(i));
 140     target.SetSectionUnloaded(section_sp);
 141   }
 142 }
 143
 144 const SectionList *
 145 DynamicLoader::GetSectionListFromModule(const ModuleSP module) const {
 146   SectionList *sections = nullptr;
 147   if (module) {
 148     ObjectFile *obj_file = module->GetObjectFile();
 149     if (obj_file != nullptr) {
 150       sections = obj_file->GetSectionList();
 151     }
 152   }
 153   return sections;
 154 }
 155
 156 ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
 157                                             addr_t link_map_addr,
 158                                             addr_t base_addr,
 159                                             bool base_addr_is_offset) {
 160   Target &target = m_process->GetTarget();
 161   ModuleList &modules = target.GetImages();
 162   ModuleSpec module_spec(file, target.GetArchitecture());
 163   ModuleSP module_sp;
 164
 165   if ((module_sp = modules.FindFirstModule(module_spec))) {
 166     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
 167                          base_addr_is_offset);
 168     return module_sp;
 169   }
 170
 171   if ((module_sp = target.GetSharedModule(module_spec))) {
 172     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
 173                          base_addr_is_offset);
 174     return module_sp;
 175   }
 176
 177   bool check_alternative_file_name = true;
 178   if (base_addr_is_offset) {
 179     // Try to fetch the load address of the file from the process as we need
 180     // absolute load address to read the file out of the memory instead of a
 181     // load bias.
 182     bool is_loaded = false;
 183     lldb::addr_t load_addr;
 184     Status error = m_process->GetFileLoadAddress(file, is_loaded, load_addr);
 185     if (error.Success() && is_loaded) {
 186       check_alternative_file_name = false;
 187       base_addr = load_addr;
 188     }
 189   }
 190
 191   // We failed to find the module based on its name. Lets try to check if we
 192   // can find a different name based on the memory region info.
 193   if (check_alternative_file_name) {
 194     MemoryRegionInfo memory_info;
 195     Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
 196     if (error.Success() && memory_info.GetMapped() &&
 197         memory_info.GetRange().GetRangeBase() == base_addr &&
 198         !(memory_info.GetName().IsEmpty())) {
 199       ModuleSpec new_module_spec(
 200           FileSpec(memory_info.GetName().AsCString(), false),
 201           target.GetArchitecture());
 202
 203       if ((module_sp = modules.FindFirstModule(new_module_spec))) {
 204         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
 205         return module_sp;
 206       }
 207
 208       if ((module_sp = target.GetSharedModule(new_module_spec))) {
 209         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
 210         return module_sp;
 211       }
 212     }
 213   }
 214
 215   if ((module_sp = m_process->ReadModuleFromMemory(file, base_addr))) {
 216     UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
 217     target.GetImages().AppendIfNeeded(module_sp);
 218   }
 219
 220   return module_sp;
 221 }
 222
 223 int64_t DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr,
 224                                                       int size_in_bytes) {
 225   Status error;
 226   uint64_t value =
 227       m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
 228   if (error.Fail())
 229     return -1;
 230   else
 231     return (int64_t)value;
 232 }
 233
 234 addr_t DynamicLoader::ReadPointer(addr_t addr) {
 235   Status error;
 236   addr_t value = m_process->ReadPointerFromMemory(addr, error);
 237   if (error.Fail())
 238     return LLDB_INVALID_ADDRESS;
 239   else
 240     return value;
 241 }
 242
 243 void DynamicLoader::LoadOperatingSystemPlugin(bool flush)
 244 {
 245     if (m_process)
 246         m_process->LoadOperatingSystemPlugin(flush);
 247 }
 248