87a2dba14e
The WinAPI `GetFinalPathNameByHandle` is used to retrieve the DLL file name from the HANDLE provided to `LOAD_DLL_DEBUG_EVENT` in the debug loop. When this API fails, lldb will simply ignore that module. Certain ramdisk (e.g. ImDisk) does not work with this API, which means it is impossible to use lldb to debug a process which loads DLLs located on this type of ramdisk. In order to make this work, we need to use a fallback routine which involves creating a file mapping, using `GetMappedFileName` to get a device path, then substitutes the device path with its drive letter. References: * https://developercommunity.visualstudio.com/t/cannot-debug-program-when-compiled-to-ram-drive/43004#T-N109926 * https://github.com/jrfonseca/drmingw/issues/65 * https://docs.microsoft.com/en-us/windows/win32/memory/obtaining-a-file-name-from-a-file-handle Reviewed By: labath Differential Revision: https://reviews.llvm.org/D126657
550 lines
20 KiB
C++
550 lines
20 KiB
C++
//===-- DebuggerThread.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 "DebuggerThread.h"
|
|
#include "ExceptionRecord.h"
|
|
#include "IDebugDelegate.h"
|
|
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Host/ProcessLaunchInfo.h"
|
|
#include "lldb/Host/ThreadLauncher.h"
|
|
#include "lldb/Host/windows/AutoHandle.h"
|
|
#include "lldb/Host/windows/HostProcessWindows.h"
|
|
#include "lldb/Host/windows/HostThreadWindows.h"
|
|
#include "lldb/Host/windows/ProcessLauncherWindows.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Predicate.h"
|
|
#include "lldb/Utility/Status.h"
|
|
|
|
#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/Support/ConvertUTF.h"
|
|
#include "llvm/Support/Threading.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <psapi.h>
|
|
|
|
#ifndef STATUS_WX86_BREAKPOINT
|
|
#define STATUS_WX86_BREAKPOINT 0x4000001FL // For WOW64
|
|
#endif
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
DebuggerThread::DebuggerThread(DebugDelegateSP debug_delegate)
|
|
: m_debug_delegate(debug_delegate), m_pid_to_detach(0),
|
|
m_is_shutting_down(false) {
|
|
m_debugging_ended_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
|
|
}
|
|
|
|
DebuggerThread::~DebuggerThread() { ::CloseHandle(m_debugging_ended_event); }
|
|
|
|
Status DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
|
|
Log *log = GetLog(WindowsLog::Process);
|
|
LLDB_LOG(log, "launching '{0}'", launch_info.GetExecutableFile().GetPath());
|
|
|
|
Status result;
|
|
llvm::Expected<HostThread> secondary_thread = ThreadLauncher::LaunchThread(
|
|
"lldb.plugin.process-windows.secondary[?]",
|
|
[this, launch_info] { return DebuggerThreadLaunchRoutine(launch_info); });
|
|
if (!secondary_thread) {
|
|
result = Status(secondary_thread.takeError());
|
|
LLDB_LOG(log, "couldn't launch debugger thread. {0}", result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Status DebuggerThread::DebugAttach(lldb::pid_t pid,
|
|
const ProcessAttachInfo &attach_info) {
|
|
Log *log = GetLog(WindowsLog::Process);
|
|
LLDB_LOG(log, "attaching to '{0}'", pid);
|
|
|
|
Status result;
|
|
llvm::Expected<HostThread> secondary_thread = ThreadLauncher::LaunchThread(
|
|
"lldb.plugin.process-windows.secondary[?]", [this, pid, attach_info] {
|
|
return DebuggerThreadAttachRoutine(pid, attach_info);
|
|
});
|
|
if (!secondary_thread) {
|
|
result = Status(secondary_thread.takeError());
|
|
LLDB_LOG(log, "couldn't attach to process '{0}'. {1}", pid, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(
|
|
const ProcessLaunchInfo &launch_info) {
|
|
// Grab a shared_ptr reference to this so that we know it won't get deleted
|
|
// until after the thread routine has exited.
|
|
std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
|
|
|
|
Log *log = GetLog(WindowsLog::Process);
|
|
LLDB_LOG(log, "preparing to launch '{0}' on background thread.",
|
|
launch_info.GetExecutableFile().GetPath());
|
|
|
|
Status error;
|
|
ProcessLauncherWindows launcher;
|
|
HostProcess process(launcher.LaunchProcess(launch_info, error));
|
|
// If we couldn't create the process, notify waiters immediately. Otherwise
|
|
// enter the debug loop and wait until we get the create process debug
|
|
// notification. Note that if the process was created successfully, we can
|
|
// throw away the process handle we got from CreateProcess because Windows
|
|
// will give us another (potentially more useful?) handle when it sends us
|
|
// the CREATE_PROCESS_DEBUG_EVENT.
|
|
if (error.Success())
|
|
DebugLoop();
|
|
else
|
|
m_debug_delegate->OnDebuggerError(error, 0);
|
|
|
|
return {};
|
|
}
|
|
|
|
lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
|
|
lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
|
|
// Grab a shared_ptr reference to this so that we know it won't get deleted
|
|
// until after the thread routine has exited.
|
|
std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
|
|
|
|
Log *log = GetLog(WindowsLog::Process);
|
|
LLDB_LOG(log, "preparing to attach to process '{0}' on background thread.",
|
|
pid);
|
|
|
|
if (!DebugActiveProcess((DWORD)pid)) {
|
|
Status error(::GetLastError(), eErrorTypeWin32);
|
|
m_debug_delegate->OnDebuggerError(error, 0);
|
|
return {};
|
|
}
|
|
|
|
// The attach was successful, enter the debug loop. From here on out, this
|
|
// is no different than a create process operation, so all the same comments
|
|
// in DebugLaunch should apply from this point out.
|
|
DebugLoop();
|
|
|
|
return {};
|
|
}
|
|
|
|
Status DebuggerThread::StopDebugging(bool terminate) {
|
|
Status error;
|
|
|
|
lldb::pid_t pid = m_process.GetProcessId();
|
|
|
|
Log *log = GetLog(WindowsLog::Process);
|
|
LLDB_LOG(log, "terminate = {0}, inferior={1}.", terminate, pid);
|
|
|
|
// Set m_is_shutting_down to true if it was false. Return if it was already
|
|
// true.
|
|
bool expected = false;
|
|
if (!m_is_shutting_down.compare_exchange_strong(expected, true))
|
|
return error;
|
|
|
|
// Make a copy of the process, since the termination sequence will reset
|
|
// DebuggerThread's internal copy and it needs to remain open for the Wait
|
|
// operation.
|
|
HostProcess process_copy = m_process;
|
|
lldb::process_t handle = m_process.GetNativeProcess().GetSystemHandle();
|
|
|
|
if (terminate) {
|
|
if (handle != nullptr && handle != LLDB_INVALID_PROCESS) {
|
|
// Initiate the termination before continuing the exception, so that the
|
|
// next debug event we get is the exit process event, and not some other
|
|
// event.
|
|
BOOL terminate_suceeded = TerminateProcess(handle, 0);
|
|
LLDB_LOG(log,
|
|
"calling TerminateProcess({0}, 0) (inferior={1}), success={2}",
|
|
handle, pid, terminate_suceeded);
|
|
} else {
|
|
LLDB_LOG(log,
|
|
"NOT calling TerminateProcess because the inferior is not valid "
|
|
"({0}, 0) (inferior={1})",
|
|
handle, pid);
|
|
}
|
|
}
|
|
|
|
// If we're stuck waiting for an exception to continue (e.g. the user is at a
|
|
// breakpoint messing around in the debugger), continue it now. But only
|
|
// AFTER calling TerminateProcess to make sure that the very next call to
|
|
// WaitForDebugEvent is an exit process event.
|
|
if (m_active_exception.get()) {
|
|
LLDB_LOG(log, "masking active exception");
|
|
ContinueAsyncException(ExceptionResult::MaskException);
|
|
}
|
|
|
|
if (!terminate) {
|
|
// Indicate that we want to detach.
|
|
m_pid_to_detach = GetProcess().GetProcessId();
|
|
|
|
// Force a fresh break so that the detach can happen from the debugger
|
|
// thread.
|
|
if (!::DebugBreakProcess(
|
|
GetProcess().GetNativeProcess().GetSystemHandle())) {
|
|
error.SetError(::GetLastError(), eErrorTypeWin32);
|
|
}
|
|
}
|
|
|
|
LLDB_LOG(log, "waiting for detach from process {0} to complete.", pid);
|
|
|
|
DWORD wait_result = WaitForSingleObject(m_debugging_ended_event, 5000);
|
|
if (wait_result != WAIT_OBJECT_0) {
|
|
error.SetError(GetLastError(), eErrorTypeWin32);
|
|
LLDB_LOG(log, "error: WaitForSingleObject({0}, 5000) returned {1}",
|
|
m_debugging_ended_event, wait_result);
|
|
} else
|
|
LLDB_LOG(log, "detach from process {0} completed successfully.", pid);
|
|
|
|
if (!error.Success()) {
|
|
LLDB_LOG(log, "encountered an error while trying to stop process {0}. {1}",
|
|
pid, error);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
void DebuggerThread::ContinueAsyncException(ExceptionResult result) {
|
|
if (!m_active_exception.get())
|
|
return;
|
|
|
|
Log *log = GetLog(WindowsLog::Process | WindowsLog::Exception);
|
|
LLDB_LOG(log, "broadcasting for inferior process {0}.",
|
|
m_process.GetProcessId());
|
|
|
|
m_active_exception.reset();
|
|
m_exception_pred.SetValue(result, eBroadcastAlways);
|
|
}
|
|
|
|
void DebuggerThread::FreeProcessHandles() {
|
|
m_process = HostProcess();
|
|
m_main_thread = HostThread();
|
|
if (m_image_file) {
|
|
::CloseHandle(m_image_file);
|
|
m_image_file = nullptr;
|
|
}
|
|
}
|
|
|
|
void DebuggerThread::DebugLoop() {
|
|
Log *log = GetLog(WindowsLog::Event);
|
|
DEBUG_EVENT dbe = {};
|
|
bool should_debug = true;
|
|
LLDB_LOGV(log, "Entering WaitForDebugEvent loop");
|
|
while (should_debug) {
|
|
LLDB_LOGV(log, "Calling WaitForDebugEvent");
|
|
BOOL wait_result = WaitForDebugEvent(&dbe, INFINITE);
|
|
if (wait_result) {
|
|
DWORD continue_status = DBG_CONTINUE;
|
|
switch (dbe.dwDebugEventCode) {
|
|
default:
|
|
llvm_unreachable("Unhandle debug event code!");
|
|
case EXCEPTION_DEBUG_EVENT: {
|
|
ExceptionResult status =
|
|
HandleExceptionEvent(dbe.u.Exception, dbe.dwThreadId);
|
|
|
|
if (status == ExceptionResult::MaskException)
|
|
continue_status = DBG_CONTINUE;
|
|
else if (status == ExceptionResult::SendToApplication)
|
|
continue_status = DBG_EXCEPTION_NOT_HANDLED;
|
|
|
|
break;
|
|
}
|
|
case CREATE_THREAD_DEBUG_EVENT:
|
|
continue_status =
|
|
HandleCreateThreadEvent(dbe.u.CreateThread, dbe.dwThreadId);
|
|
break;
|
|
case CREATE_PROCESS_DEBUG_EVENT:
|
|
continue_status =
|
|
HandleCreateProcessEvent(dbe.u.CreateProcessInfo, dbe.dwThreadId);
|
|
break;
|
|
case EXIT_THREAD_DEBUG_EVENT:
|
|
continue_status =
|
|
HandleExitThreadEvent(dbe.u.ExitThread, dbe.dwThreadId);
|
|
break;
|
|
case EXIT_PROCESS_DEBUG_EVENT:
|
|
continue_status =
|
|
HandleExitProcessEvent(dbe.u.ExitProcess, dbe.dwThreadId);
|
|
should_debug = false;
|
|
break;
|
|
case LOAD_DLL_DEBUG_EVENT:
|
|
continue_status = HandleLoadDllEvent(dbe.u.LoadDll, dbe.dwThreadId);
|
|
break;
|
|
case UNLOAD_DLL_DEBUG_EVENT:
|
|
continue_status = HandleUnloadDllEvent(dbe.u.UnloadDll, dbe.dwThreadId);
|
|
break;
|
|
case OUTPUT_DEBUG_STRING_EVENT:
|
|
continue_status = HandleODSEvent(dbe.u.DebugString, dbe.dwThreadId);
|
|
break;
|
|
case RIP_EVENT:
|
|
continue_status = HandleRipEvent(dbe.u.RipInfo, dbe.dwThreadId);
|
|
if (dbe.u.RipInfo.dwType == SLE_ERROR)
|
|
should_debug = false;
|
|
break;
|
|
}
|
|
|
|
LLDB_LOGV(log, "calling ContinueDebugEvent({0}, {1}, {2}) on thread {3}.",
|
|
dbe.dwProcessId, dbe.dwThreadId, continue_status,
|
|
::GetCurrentThreadId());
|
|
|
|
::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status);
|
|
|
|
if (m_detached) {
|
|
should_debug = false;
|
|
}
|
|
} else {
|
|
LLDB_LOG(log, "returned FALSE from WaitForDebugEvent. Error = {0}",
|
|
::GetLastError());
|
|
|
|
should_debug = false;
|
|
}
|
|
}
|
|
FreeProcessHandles();
|
|
|
|
LLDB_LOG(log, "WaitForDebugEvent loop completed, exiting.");
|
|
::SetEvent(m_debugging_ended_event);
|
|
}
|
|
|
|
ExceptionResult
|
|
DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event | WindowsLog::Exception);
|
|
if (m_is_shutting_down) {
|
|
// A breakpoint that occurs while `m_pid_to_detach` is non-zero is a magic
|
|
// exception that
|
|
// we use simply to wake up the DebuggerThread so that we can close out the
|
|
// debug loop.
|
|
if (m_pid_to_detach != 0 &&
|
|
(info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT ||
|
|
info.ExceptionRecord.ExceptionCode == STATUS_WX86_BREAKPOINT)) {
|
|
LLDB_LOG(log, "Breakpoint exception is cue to detach from process {0:x}",
|
|
m_pid_to_detach.load());
|
|
::DebugActiveProcessStop(m_pid_to_detach);
|
|
m_detached = true;
|
|
}
|
|
|
|
// Don't perform any blocking operations while we're shutting down. That
|
|
// will cause TerminateProcess -> WaitForSingleObject to time out.
|
|
return ExceptionResult::SendToApplication;
|
|
}
|
|
|
|
bool first_chance = (info.dwFirstChance != 0);
|
|
|
|
m_active_exception.reset(
|
|
new ExceptionRecord(info.ExceptionRecord, thread_id));
|
|
LLDB_LOG(log, "encountered {0} chance exception {1:x} on thread {2:x}",
|
|
first_chance ? "first" : "second",
|
|
info.ExceptionRecord.ExceptionCode, thread_id);
|
|
|
|
ExceptionResult result =
|
|
m_debug_delegate->OnDebugException(first_chance, *m_active_exception);
|
|
m_exception_pred.SetValue(result, eBroadcastNever);
|
|
|
|
LLDB_LOG(log, "waiting for ExceptionPred != BreakInDebugger");
|
|
result = *m_exception_pred.WaitForValueNotEqualTo(
|
|
ExceptionResult::BreakInDebugger);
|
|
|
|
LLDB_LOG(log, "got ExceptionPred = {0}", (int)m_exception_pred.GetValue());
|
|
return result;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event | WindowsLog::Thread);
|
|
LLDB_LOG(log, "Thread {0} spawned in process {1}", thread_id,
|
|
m_process.GetProcessId());
|
|
HostThread thread(info.hThread);
|
|
thread.GetNativeThread().SetOwnsHandle(false);
|
|
m_debug_delegate->OnCreateThread(thread);
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event | WindowsLog::Process);
|
|
uint32_t process_id = ::GetProcessId(info.hProcess);
|
|
|
|
LLDB_LOG(log, "process {0} spawned", process_id);
|
|
|
|
std::string thread_name;
|
|
llvm::raw_string_ostream name_stream(thread_name);
|
|
name_stream << "lldb.plugin.process-windows.secondary[" << process_id << "]";
|
|
name_stream.flush();
|
|
llvm::set_thread_name(thread_name);
|
|
|
|
// info.hProcess and info.hThread are closed automatically by Windows when
|
|
// EXIT_PROCESS_DEBUG_EVENT is received.
|
|
m_process = HostProcess(info.hProcess);
|
|
((HostProcessWindows &)m_process.GetNativeProcess()).SetOwnsHandle(false);
|
|
m_main_thread = HostThread(info.hThread);
|
|
m_main_thread.GetNativeThread().SetOwnsHandle(false);
|
|
m_image_file = info.hFile;
|
|
|
|
lldb::addr_t load_addr = reinterpret_cast<lldb::addr_t>(info.lpBaseOfImage);
|
|
m_debug_delegate->OnDebuggerConnected(load_addr);
|
|
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleExitThreadEvent(const EXIT_THREAD_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event | WindowsLog::Thread);
|
|
LLDB_LOG(log, "Thread {0} exited with code {1} in process {2}", thread_id,
|
|
info.dwExitCode, m_process.GetProcessId());
|
|
m_debug_delegate->OnExitThread(thread_id, info.dwExitCode);
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event | WindowsLog::Thread);
|
|
LLDB_LOG(log, "process {0} exited with code {1}", m_process.GetProcessId(),
|
|
info.dwExitCode);
|
|
|
|
m_debug_delegate->OnExitProcess(info.dwExitCode);
|
|
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
static llvm::Optional<std::string> GetFileNameFromHandleFallback(HANDLE hFile) {
|
|
// Check that file is not empty as we cannot map a file with zero length.
|
|
DWORD dwFileSizeHi = 0;
|
|
DWORD dwFileSizeLo = ::GetFileSize(hFile, &dwFileSizeHi);
|
|
if (dwFileSizeLo == 0 && dwFileSizeHi == 0)
|
|
return llvm::None;
|
|
|
|
AutoHandle filemap(
|
|
::CreateFileMappingW(hFile, nullptr, PAGE_READONLY, 0, 1, NULL), nullptr);
|
|
if (!filemap.IsValid())
|
|
return llvm::None;
|
|
|
|
auto view_deleter = [](void *pMem) { ::UnmapViewOfFile(pMem); };
|
|
std::unique_ptr<void, decltype(view_deleter)> pMem(
|
|
::MapViewOfFile(filemap.get(), FILE_MAP_READ, 0, 0, 1), view_deleter);
|
|
if (!pMem)
|
|
return llvm::None;
|
|
|
|
std::array<wchar_t, MAX_PATH + 1> mapped_filename;
|
|
if (!::GetMappedFileNameW(::GetCurrentProcess(), pMem.get(),
|
|
mapped_filename.data(), mapped_filename.size()))
|
|
return llvm::None;
|
|
|
|
// A series of null-terminated strings, plus an additional null character
|
|
std::array<wchar_t, 512> drive_strings;
|
|
drive_strings[0] = L'\0';
|
|
if (!::GetLogicalDriveStringsW(drive_strings.size(), drive_strings.data()))
|
|
return llvm::None;
|
|
|
|
std::array<wchar_t, 3> drive = {L"_:"};
|
|
for (const wchar_t *it = drive_strings.data(); *it != L'\0';
|
|
it += wcslen(it) + 1) {
|
|
// Copy the drive letter to the template string
|
|
drive[0] = it[0];
|
|
std::array<wchar_t, MAX_PATH> device_name;
|
|
if (::QueryDosDeviceW(drive.data(), device_name.data(),
|
|
device_name.size())) {
|
|
size_t device_name_len = wcslen(device_name.data());
|
|
if (device_name_len < mapped_filename.size()) {
|
|
bool match = _wcsnicmp(mapped_filename.data(), device_name.data(),
|
|
device_name_len) == 0;
|
|
if (match && mapped_filename[device_name_len] == L'\\') {
|
|
// Replace device path with its drive letter
|
|
std::wstring rebuilt_path(drive.data());
|
|
rebuilt_path.append(&mapped_filename[device_name_len]);
|
|
std::string path_utf8;
|
|
llvm::convertWideToUTF8(rebuilt_path, path_utf8);
|
|
return path_utf8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return llvm::None;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event);
|
|
if (info.hFile == nullptr) {
|
|
// Not sure what this is, so just ignore it.
|
|
LLDB_LOG(log, "Warning: Inferior {0} has a NULL file handle, returning...",
|
|
m_process.GetProcessId());
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
auto on_load_dll = [&](llvm::StringRef path) {
|
|
FileSpec file_spec(path);
|
|
ModuleSpec module_spec(file_spec);
|
|
lldb::addr_t load_addr = reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll);
|
|
|
|
LLDB_LOG(log, "Inferior {0} - DLL '{1}' loaded at address {2:x}...",
|
|
m_process.GetProcessId(), path, info.lpBaseOfDll);
|
|
|
|
m_debug_delegate->OnLoadDll(module_spec, load_addr);
|
|
};
|
|
|
|
std::vector<wchar_t> buffer(1);
|
|
DWORD required_size =
|
|
GetFinalPathNameByHandleW(info.hFile, &buffer[0], 0, VOLUME_NAME_DOS);
|
|
if (required_size > 0) {
|
|
buffer.resize(required_size + 1);
|
|
required_size = GetFinalPathNameByHandleW(info.hFile, &buffer[0],
|
|
required_size, VOLUME_NAME_DOS);
|
|
std::string path_str_utf8;
|
|
llvm::convertWideToUTF8(buffer.data(), path_str_utf8);
|
|
llvm::StringRef path_str = path_str_utf8;
|
|
const char *path = path_str.data();
|
|
if (path_str.startswith("\\\\?\\"))
|
|
path += 4;
|
|
|
|
on_load_dll(path);
|
|
} else if (llvm::Optional<std::string> path =
|
|
GetFileNameFromHandleFallback(info.hFile)) {
|
|
on_load_dll(*path);
|
|
} else {
|
|
LLDB_LOG(
|
|
log,
|
|
"Inferior {0} - Error {1} occurred calling GetFinalPathNameByHandle",
|
|
m_process.GetProcessId(), ::GetLastError());
|
|
}
|
|
// Windows does not automatically close info.hFile, so we need to do it.
|
|
::CloseHandle(info.hFile);
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event);
|
|
LLDB_LOG(log, "process {0} unloading DLL at addr {1:x}.",
|
|
m_process.GetProcessId(), info.lpBaseOfDll);
|
|
|
|
m_debug_delegate->OnUnloadDll(
|
|
reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll));
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info,
|
|
DWORD thread_id) {
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleRipEvent(const RIP_INFO &info, DWORD thread_id) {
|
|
Log *log = GetLog(WindowsLog::Event);
|
|
LLDB_LOG(log, "encountered error {0} (type={1}) in process {2} thread {3}",
|
|
info.dwError, info.dwType, m_process.GetProcessId(), thread_id);
|
|
|
|
Status error(info.dwError, eErrorTypeWin32);
|
|
m_debug_delegate->OnDebuggerError(error, info.dwType);
|
|
|
|
return DBG_CONTINUE;
|
|
}
|