contrib/llvm/tools/lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

   1 //===-- DynamicLoaderWindowsDYLD.cpp --------------------------------*- C++
   2 //-*-===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "DynamicLoaderWindowsDYLD.h"
  11
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Core/PluginManager.h"
  14 #include "lldb/Target/ExecutionContext.h"
  15 #include "lldb/Target/Platform.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Target/RegisterContext.h"
  18 #include "lldb/Target/Target.h"
  19 #include "lldb/Target/ThreadPlanStepInstruction.h"
  20 #include "lldb/Utility/Log.h"
  21
  22 #include "llvm/ADT/Triple.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
  28     : DynamicLoader(process) {}
  29
  30 DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() {}
  31
  32 void DynamicLoaderWindowsDYLD::Initialize() {
  33   PluginManager::RegisterPlugin(GetPluginNameStatic(),
  34                                 GetPluginDescriptionStatic(), CreateInstance);
  35 }
  36
  37 void DynamicLoaderWindowsDYLD::Terminate() {}
  38
  39 ConstString DynamicLoaderWindowsDYLD::GetPluginNameStatic() {
  40   static ConstString g_plugin_name("windows-dyld");
  41   return g_plugin_name;
  42 }
  43
  44 const char *DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic() {
  45   return "Dynamic loader plug-in that watches for shared library "
  46          "loads/unloads in Windows processes.";
  47 }
  48
  49 DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
  50                                                         bool force) {
  51   bool should_create = force;
  52   if (!should_create) {
  53     const llvm::Triple &triple_ref =
  54         process->GetTarget().GetArchitecture().GetTriple();
  55     if (triple_ref.getOS() == llvm::Triple::Win32)
  56       should_create = true;
  57   }
  58
  59   if (should_create)
  60     return new DynamicLoaderWindowsDYLD(process);
  61
  62   return nullptr;
  63 }
  64
  65 void DynamicLoaderWindowsDYLD::OnLoadModule(lldb::ModuleSP module_sp,
  66                                             const ModuleSpec module_spec,
  67                                             lldb::addr_t module_addr) {
  68
  69   // Resolve the module unless we already have one.
  70   if (!module_sp) {
  71     Status error;
  72     module_sp = m_process->GetTarget().GetOrCreateModule(module_spec,
  73                                              true /* notify */, &error);
  74     if (error.Fail())
  75       return;
  76   }
  77
  78   m_loaded_modules[module_sp] = module_addr;
  79   UpdateLoadedSectionsCommon(module_sp, module_addr, false);
  80   ModuleList module_list;
  81   module_list.Append(module_sp);
  82   m_process->GetTarget().ModulesDidLoad(module_list);
  83 }
  84
  85 void DynamicLoaderWindowsDYLD::OnUnloadModule(lldb::addr_t module_addr) {
  86   Address resolved_addr;
  87   if (!m_process->GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
  88     return;
  89
  90   ModuleSP module_sp = resolved_addr.GetModule();
  91   if (module_sp) {
  92     m_loaded_modules.erase(module_sp);
  93     UnloadSectionsCommon(module_sp);
  94     ModuleList module_list;
  95     module_list.Append(module_sp);
  96     m_process->GetTarget().ModulesDidUnload(module_list, false);
  97   }
  98 }
  99
 100 lldb::addr_t DynamicLoaderWindowsDYLD::GetLoadAddress(ModuleSP executable) {
 101   // First, see if the load address is already cached.
 102   auto it = m_loaded_modules.find(executable);
 103   if (it != m_loaded_modules.end() && it->second != LLDB_INVALID_ADDRESS)
 104     return it->second;
 105
 106   lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
 107
 108   // Second, try to get it through the process plugins.  For a remote process,
 109   // the remote platform will be responsible for providing it.
 110   FileSpec file_spec(executable->GetPlatformFileSpec());
 111   bool is_loaded = false;
 112   Status status =
 113       m_process->GetFileLoadAddress(file_spec, is_loaded, load_addr);
 114   // Servers other than lldb server could respond with a bogus address.
 115   if (status.Success() && is_loaded && load_addr != LLDB_INVALID_ADDRESS) {
 116     m_loaded_modules[executable] = load_addr;
 117     return load_addr;
 118   }
 119
 120   return LLDB_INVALID_ADDRESS;
 121 }
 122
 123 void DynamicLoaderWindowsDYLD::DidAttach() {
 124     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 125   if (log)
 126     log->Printf("DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
 127
 128   ModuleSP executable = GetTargetExecutable();
 129
 130   if (!executable.get())
 131     return;
 132
 133   // Try to fetch the load address of the file from the process, since there
 134   // could be randomization of the load address.
 135   lldb::addr_t load_addr = GetLoadAddress(executable);
 136   if (load_addr == LLDB_INVALID_ADDRESS)
 137     return;
 138
 139   // Request the process base address.
 140   lldb::addr_t image_base = m_process->GetImageInfoAddress();
 141   if (image_base == load_addr)
 142     return;
 143
 144   // Rebase the process's modules if there is a mismatch.
 145   UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
 146
 147   ModuleList module_list;
 148   module_list.Append(executable);
 149   m_process->GetTarget().ModulesDidLoad(module_list);
 150   m_process->LoadModules();
 151 }
 152
 153 void DynamicLoaderWindowsDYLD::DidLaunch() {
 154   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 155   if (log)
 156     log->Printf("DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
 157
 158   ModuleSP executable = GetTargetExecutable();
 159   if (!executable.get())
 160     return;
 161
 162   lldb::addr_t load_addr = GetLoadAddress(executable);
 163   if (load_addr != LLDB_INVALID_ADDRESS) {
 164     // Update the loaded sections so that the breakpoints can be resolved.
 165     UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
 166
 167     ModuleList module_list;
 168     module_list.Append(executable);
 169     m_process->GetTarget().ModulesDidLoad(module_list);
 170     m_process->LoadModules();
 171   }
 172 }
 173
 174 Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }
 175
 176 ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
 177   return GetPluginNameStatic();
 178 }
 179
 180 uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
 181
 182 ThreadPlanSP
 183 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
 184                                                        bool stop) {
 185   auto arch = m_process->GetTarget().GetArchitecture();
 186   if (arch.GetMachine() != llvm::Triple::x86) {
 187     return ThreadPlanSP();
 188   }
 189
 190   uint64_t pc = thread.GetRegisterContext()->GetPC();
 191   // Max size of an instruction in x86 is 15 bytes.
 192   AddressRange range(pc, 2 * 15);
 193
 194   ExecutionContext exe_ctx(m_process->GetTarget());
 195   DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
 196       arch, nullptr, nullptr, exe_ctx, range, true);
 197   if (!disassembler_sp) {
 198     return ThreadPlanSP();
 199   }
 200
 201   InstructionList *insn_list = &disassembler_sp->GetInstructionList();
 202   if (insn_list == nullptr) {
 203     return ThreadPlanSP();
 204   }
 205
 206   // First instruction in a x86 Windows trampoline is going to be an indirect
 207   // jump through the IAT and the next one will be a nop (usually there for
 208   // alignment purposes). e.g.:
 209   //     0x70ff4cfc <+956>: jmpl   *0x7100c2a8
 210   //     0x70ff4d02 <+962>: nop
 211
 212   auto first_insn = insn_list->GetInstructionAtIndex(0);
 213   auto second_insn = insn_list->GetInstructionAtIndex(1);
 214
 215   if (first_insn == nullptr || second_insn == nullptr ||
 216       strcmp(first_insn->GetMnemonic(&exe_ctx), "jmpl") != 0 ||
 217       strcmp(second_insn->GetMnemonic(&exe_ctx), "nop") != 0) {
 218     return ThreadPlanSP();
 219   }
 220
 221   assert(first_insn->DoesBranch() && !second_insn->DoesBranch());
 222
 223   return ThreadPlanSP(new ThreadPlanStepInstruction(
 224       thread, false, false, eVoteNoOpinion, eVoteNoOpinion));
 225 }