You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
227 lines
7.6 KiB
227 lines
7.6 KiB
//===-- DynamicLoaderWindowsDYLD.cpp --------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DynamicLoaderWindowsDYLD.h"
|
|
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Platform.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/ThreadPlanStepInstruction.h"
|
|
#include "lldb/Utility/Log.h"
|
|
|
|
#include "llvm/ADT/Triple.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
LLDB_PLUGIN_DEFINE(DynamicLoaderWindowsDYLD)
|
|
|
|
DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
|
|
: DynamicLoader(process) {}
|
|
|
|
DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() {}
|
|
|
|
void DynamicLoaderWindowsDYLD::Initialize() {
|
|
PluginManager::RegisterPlugin(GetPluginNameStatic(),
|
|
GetPluginDescriptionStatic(), CreateInstance);
|
|
}
|
|
|
|
void DynamicLoaderWindowsDYLD::Terminate() {}
|
|
|
|
ConstString DynamicLoaderWindowsDYLD::GetPluginNameStatic() {
|
|
static ConstString g_plugin_name("windows-dyld");
|
|
return g_plugin_name;
|
|
}
|
|
|
|
const char *DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic() {
|
|
return "Dynamic loader plug-in that watches for shared library "
|
|
"loads/unloads in Windows processes.";
|
|
}
|
|
|
|
DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
|
|
bool force) {
|
|
bool should_create = force;
|
|
if (!should_create) {
|
|
const llvm::Triple &triple_ref =
|
|
process->GetTarget().GetArchitecture().GetTriple();
|
|
if (triple_ref.getOS() == llvm::Triple::Win32)
|
|
should_create = true;
|
|
}
|
|
|
|
if (should_create)
|
|
return new DynamicLoaderWindowsDYLD(process);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void DynamicLoaderWindowsDYLD::OnLoadModule(lldb::ModuleSP module_sp,
|
|
const ModuleSpec module_spec,
|
|
lldb::addr_t module_addr) {
|
|
|
|
// Resolve the module unless we already have one.
|
|
if (!module_sp) {
|
|
Status error;
|
|
module_sp = m_process->GetTarget().GetOrCreateModule(module_spec,
|
|
true /* notify */, &error);
|
|
if (error.Fail())
|
|
return;
|
|
}
|
|
|
|
m_loaded_modules[module_sp] = module_addr;
|
|
UpdateLoadedSectionsCommon(module_sp, module_addr, false);
|
|
ModuleList module_list;
|
|
module_list.Append(module_sp);
|
|
m_process->GetTarget().ModulesDidLoad(module_list);
|
|
}
|
|
|
|
void DynamicLoaderWindowsDYLD::OnUnloadModule(lldb::addr_t module_addr) {
|
|
Address resolved_addr;
|
|
if (!m_process->GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
|
|
return;
|
|
|
|
ModuleSP module_sp = resolved_addr.GetModule();
|
|
if (module_sp) {
|
|
m_loaded_modules.erase(module_sp);
|
|
UnloadSectionsCommon(module_sp);
|
|
ModuleList module_list;
|
|
module_list.Append(module_sp);
|
|
m_process->GetTarget().ModulesDidUnload(module_list, false);
|
|
}
|
|
}
|
|
|
|
lldb::addr_t DynamicLoaderWindowsDYLD::GetLoadAddress(ModuleSP executable) {
|
|
// First, see if the load address is already cached.
|
|
auto it = m_loaded_modules.find(executable);
|
|
if (it != m_loaded_modules.end() && it->second != LLDB_INVALID_ADDRESS)
|
|
return it->second;
|
|
|
|
lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
|
|
|
|
// Second, try to get it through the process plugins. For a remote process,
|
|
// the remote platform will be responsible for providing it.
|
|
FileSpec file_spec(executable->GetPlatformFileSpec());
|
|
bool is_loaded = false;
|
|
Status status =
|
|
m_process->GetFileLoadAddress(file_spec, is_loaded, load_addr);
|
|
// Servers other than lldb server could respond with a bogus address.
|
|
if (status.Success() && is_loaded && load_addr != LLDB_INVALID_ADDRESS) {
|
|
m_loaded_modules[executable] = load_addr;
|
|
return load_addr;
|
|
}
|
|
|
|
return LLDB_INVALID_ADDRESS;
|
|
}
|
|
|
|
void DynamicLoaderWindowsDYLD::DidAttach() {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
|
|
LLDB_LOGF(log, "DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
|
|
|
|
ModuleSP executable = GetTargetExecutable();
|
|
|
|
if (!executable.get())
|
|
return;
|
|
|
|
// Try to fetch the load address of the file from the process, since there
|
|
// could be randomization of the load address.
|
|
lldb::addr_t load_addr = GetLoadAddress(executable);
|
|
if (load_addr == LLDB_INVALID_ADDRESS)
|
|
return;
|
|
|
|
// Request the process base address.
|
|
lldb::addr_t image_base = m_process->GetImageInfoAddress();
|
|
if (image_base == load_addr)
|
|
return;
|
|
|
|
// Rebase the process's modules if there is a mismatch.
|
|
UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
|
|
|
|
ModuleList module_list;
|
|
module_list.Append(executable);
|
|
m_process->GetTarget().ModulesDidLoad(module_list);
|
|
auto error = m_process->LoadModules();
|
|
LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
|
|
}
|
|
|
|
void DynamicLoaderWindowsDYLD::DidLaunch() {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
|
|
LLDB_LOGF(log, "DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
|
|
|
|
ModuleSP executable = GetTargetExecutable();
|
|
if (!executable.get())
|
|
return;
|
|
|
|
lldb::addr_t load_addr = GetLoadAddress(executable);
|
|
if (load_addr != LLDB_INVALID_ADDRESS) {
|
|
// Update the loaded sections so that the breakpoints can be resolved.
|
|
UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
|
|
|
|
ModuleList module_list;
|
|
module_list.Append(executable);
|
|
m_process->GetTarget().ModulesDidLoad(module_list);
|
|
auto error = m_process->LoadModules();
|
|
LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
|
|
}
|
|
}
|
|
|
|
Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }
|
|
|
|
ConstString DynamicLoaderWindowsDYLD::GetPluginName() {
|
|
return GetPluginNameStatic();
|
|
}
|
|
|
|
uint32_t DynamicLoaderWindowsDYLD::GetPluginVersion() { return 1; }
|
|
|
|
ThreadPlanSP
|
|
DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
|
|
bool stop) {
|
|
auto arch = m_process->GetTarget().GetArchitecture();
|
|
if (arch.GetMachine() != llvm::Triple::x86) {
|
|
return ThreadPlanSP();
|
|
}
|
|
|
|
uint64_t pc = thread.GetRegisterContext()->GetPC();
|
|
// Max size of an instruction in x86 is 15 bytes.
|
|
AddressRange range(pc, 2 * 15);
|
|
|
|
DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
|
|
arch, nullptr, nullptr, m_process->GetTarget(), range, true);
|
|
if (!disassembler_sp) {
|
|
return ThreadPlanSP();
|
|
}
|
|
|
|
InstructionList *insn_list = &disassembler_sp->GetInstructionList();
|
|
if (insn_list == nullptr) {
|
|
return ThreadPlanSP();
|
|
}
|
|
|
|
// First instruction in a x86 Windows trampoline is going to be an indirect
|
|
// jump through the IAT and the next one will be a nop (usually there for
|
|
// alignment purposes). e.g.:
|
|
// 0x70ff4cfc <+956>: jmpl *0x7100c2a8
|
|
// 0x70ff4d02 <+962>: nop
|
|
|
|
auto first_insn = insn_list->GetInstructionAtIndex(0);
|
|
auto second_insn = insn_list->GetInstructionAtIndex(1);
|
|
|
|
ExecutionContext exe_ctx(m_process->GetTarget());
|
|
if (first_insn == nullptr || second_insn == nullptr ||
|
|
strcmp(first_insn->GetMnemonic(&exe_ctx), "jmpl") != 0 ||
|
|
strcmp(second_insn->GetMnemonic(&exe_ctx), "nop") != 0) {
|
|
return ThreadPlanSP();
|
|
}
|
|
|
|
assert(first_insn->DoesBranch() && !second_insn->DoesBranch());
|
|
|
|
return ThreadPlanSP(new ThreadPlanStepInstruction(
|
|
thread, false, false, eVoteNoOpinion, eVoteNoOpinion));
|
|
}
|