//===-- 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/LazyImport.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 "lldb/Utility/LLDBLog.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/ConvertUTF.h" #include "llvm/Support/Threading.h" #include "llvm/Support/raw_ostream.h" #include #include #include #ifndef STATUS_WX86_BREAKPOINT #define STATUS_WX86_BREAKPOINT 0x4000001FL // For WOW64 #endif using namespace lldb; using namespace lldb_private; typedef BOOL WINAPI WaitForDebugEventFn(LPDEBUG_EVENT, DWORD); static WaitForDebugEventFn *g_wait_for_debug_event = nullptr; /// WaitForDebugEventEx is only available on Windows 10+. This lazily checks if /// the function is available and falls back to WaitForDebugEvent if /// unavailable. The -Ex version ensures correct forwarding of /// OutputDebugStringW events. static void InitializeWaitForDebugEvent() { static LazyImport s_wait_for_debug_event_ex = { L"kernel32.dll", "WaitForDebugEventEx"}; if (g_wait_for_debug_event) return; if (!s_wait_for_debug_event_ex) { LLDB_LOG( GetLog(LLDBLog::Host), "WaitForDebugEventEx unavailable, using WaitForDebugEvent instead. " "Unicode strings from OutputDebugStringW might show incorrectly."); g_wait_for_debug_event = &WaitForDebugEvent; } else { g_wait_for_debug_event = *s_wait_for_debug_event_ex; } } DebuggerThread::DebuggerThread(DebugDelegateSP debug_delegate) : m_debug_delegate(debug_delegate), m_pid_to_detach(0), m_is_shutting_down(false) { InitializeWaitForDebugEvent(); 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 secondary_thread = ThreadLauncher::LaunchThread( "lldb.plugin.process-windows.secondary[?]", [this, launch_info] { return DebuggerThreadLaunchRoutine(launch_info); }); if (!secondary_thread) { result = Status::FromError(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 secondary_thread = ThreadLauncher::LaunchThread( "lldb.plugin.process-windows.secondary[?]", [this, pid, attach_info] { return DebuggerThreadAttachRoutine(pid, attach_info); }); if (!secondary_thread) { result = Status::FromError(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 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 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(static_cast(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 // WaitForDebugEventEx 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 = Status(::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 = Status(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_LOG_VERBOSE(log, "Entering WaitForDebugEventEx loop"); while (should_debug) { LLDB_LOG_VERBOSE(log, "Calling WaitForDebugEvent"); BOOL wait_result = g_wait_for_debug_event(&dbe, INFINITE); if (wait_result) { DWORD continue_status = DBG_CONTINUE; bool shutting_down = m_is_shutting_down; switch (dbe.dwDebugEventCode) { default: llvm_unreachable("Unhandle debug event code!"); case EXCEPTION_DEBUG_EVENT: { ExceptionResult status = HandleExceptionEvent( dbe.u.Exception, dbe.dwThreadId, shutting_down); 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_LOG_VERBOSE( log, "calling ContinueDebugEvent({0}, {1}, {2}) on thread {3}.", dbe.dwProcessId, dbe.dwThreadId, continue_status, ::GetCurrentThreadId()); ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status); // We have to DebugActiveProcessStop after ContinueDebugEvent, otherwise // the target process will crash if (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 && (dbe.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT || dbe.u.Exception.ExceptionRecord.ExceptionCode == STATUS_WX86_BREAKPOINT)) { LLDB_LOG(log, "Breakpoint exception is cue to detach from process {0:x}", m_pid_to_detach.load()); // detaching with leaving breakpoint exception event on the queue may // cause target process to crash so process events as possible since // target threads are running at this time, there is possibility to // have some breakpoint exception between last WaitForDebugEventEx and // DebugActiveProcessStop but ignore for now. while (g_wait_for_debug_event(&dbe, 0)) { continue_status = DBG_CONTINUE; if (dbe.dwDebugEventCode == EXCEPTION_DEBUG_EVENT && !(dbe.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT || dbe.u.Exception.ExceptionRecord.ExceptionCode == STATUS_WX86_BREAKPOINT || dbe.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_SINGLE_STEP)) continue_status = DBG_EXCEPTION_NOT_HANDLED; ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status); } ::DebugActiveProcessStop(m_pid_to_detach); m_detached = true; } } if (m_detached) { should_debug = false; } } else { LLDB_LOG(log, "returned FALSE from WaitForDebugEventEx. Error = {0}", ::GetLastError()); should_debug = false; } } FreeProcessHandles(); LLDB_LOG(log, "WaitForDebugEventEx loop completed, exiting."); ::SetEvent(m_debugging_ended_event); } ExceptionResult DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info, DWORD thread_id, bool shutting_down) { Log *log = GetLog(WindowsLog::Event | WindowsLog::Exception); if (shutting_down) { bool is_breakpoint = (info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT || info.ExceptionRecord.ExceptionCode == STATUS_WX86_BREAKPOINT); // Don't perform any blocking operations while we're shutting down. That // will cause TerminateProcess -> WaitForSingleObject to time out. // We should not send breakpoint exceptions to the application. return is_breakpoint ? ExceptionResult::MaskException : 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 << "]"; 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(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 std::optional ConvertNtDevicePathToDosPath(llvm::ArrayRef nt_path) { Log *log = GetLog(WindowsLog::Event); llvm::SmallVector vol_name(MAX_PATH); HANDLE vol_iter = ::FindFirstVolumeW(vol_name.data(), vol_name.size()); if (vol_iter == INVALID_HANDLE_VALUE) { LLDB_LOG(log, "ConvertNtDevicePathToDosPath: FindFirstVolumeW failed, " "error={0}", ::GetLastError()); return std::nullopt; } llvm::scope_exit close_iter([&] { ::FindVolumeClose(vol_iter); }); do { // FindFirstVolumeW yields "\\?\Volume{GUID}\". // QueryDosDeviceW expects "Volume{GUID}". size_t vol_len = ::wcsnlen(vol_name.data(), vol_name.size()); if (vol_len < 5 || vol_name[vol_len - 1] != L'\\') continue; vol_name[vol_len - 1] = L'\0'; // strip trailing '\' for QueryDosDeviceW llvm::SmallVector dev_name(MAX_PATH); bool ok = ::QueryDosDeviceW(vol_name.data() + 4, // skip "\\?\" dev_name.data(), dev_name.size()); vol_name[vol_len - 1] = L'\\'; // restore if (!ok) continue; // Check that nt_path begins with this device name followed by '\'. size_t dev_len = ::wcsnlen(dev_name.data(), dev_name.size()); if (dev_len == 0 || dev_len >= nt_path.size()) continue; if (_wcsnicmp(nt_path.data(), dev_name.data(), dev_len) != 0) continue; if (nt_path[dev_len] != L'\\') continue; // Prefer a drive-letter/mount-point over the raw volume GUID path. llvm::ArrayRef mount(vol_name.data(), vol_len); llvm::SmallVector mount_names; DWORD names_size = 0; ::GetVolumePathNamesForVolumeNameW(vol_name.data(), nullptr, 0, &names_size); if (names_size > 1) { mount_names.resize(names_size); DWORD written = 0; if (::GetVolumePathNamesForVolumeNameW( vol_name.data(), mount_names.data(), names_size, &written) && mount_names[0] != L'\0') { mount = llvm::ArrayRef( mount_names.data(), ::wcsnlen(mount_names.data(), mount_names.size())); } } // Build the final path: mount point + rest of nt_path. llvm::SmallVector dos_wide(mount.begin(), mount.end()); if (!dos_wide.empty() && dos_wide.back() == L'\\') dos_wide.pop_back(); dos_wide.append(nt_path.begin() + dev_len, nt_path.end()); std::string result; llvm::convertWideToUTF8(std::wstring(dos_wide.begin(), dos_wide.end()), result); return result; } while (::FindNextVolumeW(vol_iter, vol_name.data(), vol_name.size())); LLDB_LOG(log, "ConvertNtDevicePathToDosPath: no matching volume found"); return std::nullopt; } static std::optional 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 std::nullopt; AutoHandle filemap( ::CreateFileMappingW(hFile, nullptr, PAGE_READONLY, 0, 1, nullptr), nullptr); if (!filemap.IsValid()) return std::nullopt; auto view_deleter = [](void *pMem) { ::UnmapViewOfFile(pMem); }; std::unique_ptr pMem( ::MapViewOfFile(filemap.get(), FILE_MAP_READ, 0, 0, 1), view_deleter); if (!pMem) return std::nullopt; std::array mapped_filename; if (!::GetMappedFileNameW(::GetCurrentProcess(), pMem.get(), mapped_filename.data(), mapped_filename.size())) return std::nullopt; return ConvertNtDevicePathToDosPath(mapped_filename); } static std::optional GetFileNameByLoadAddress(HANDLE process, LPVOID base_addr) { std::array module_filename; DWORD len = ::GetModuleFileNameExW(process, reinterpret_cast(base_addr), module_filename.data(), module_filename.size()); if (len > 0 && len < module_filename.size()) { std::string path_utf8; llvm::convertWideToUTF8(std::wstring(module_filename.data(), len), path_utf8); return path_utf8; } // Fallback: ask the kernel for the file backing the mapping at this address. std::vector mapped_filename(MAX_PATH + 1); DWORD mapped_len = 0; while (mapped_filename.size() <= PATHCCH_MAX_CCH) { mapped_len = ::GetMappedFileNameW( process, base_addr, mapped_filename.data(), mapped_filename.size()); if (mapped_len < mapped_filename.size()) break; if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER) return std::nullopt; mapped_filename.resize(mapped_filename.size() * 2); } std::optional dos_path = ConvertNtDevicePathToDosPath( llvm::ArrayRef(mapped_filename.data(), mapped_len + 1)); return dos_path; } // Determine how many bytes can be read at `addr` in `process` before crossing // out of the committed memory region containing it. Returns 0 if the address is // not within a committed region. static SIZE_T BytesReadableAt(HANDLE process, LPCVOID addr) { MEMORY_BASIC_INFORMATION mbi{}; if (!::VirtualQueryEx(process, addr, &mbi, sizeof(mbi))) return 0; if (mbi.State != MEM_COMMIT) return 0; uintptr_t region_end = reinterpret_cast(mbi.BaseAddress) + mbi.RegionSize; uintptr_t a = reinterpret_cast(addr); assert(a < region_end); return region_end - a; } static std::optional ReadRemotePathStringW(HANDLE process, LPCVOID addr) { SIZE_T to_read = std::min((MAX_PATH + 1) * sizeof(wchar_t), BytesReadableAt(process, addr)); to_read &= ~SIZE_T(1); // round down to a wchar_t boundary if (to_read < sizeof(wchar_t)) return std::nullopt; std::array buf{}; SIZE_T bytes_read = 0; if (!::ReadProcessMemory(process, addr, buf.data(), to_read, &bytes_read)) return std::nullopt; size_t max_chars = bytes_read / sizeof(wchar_t); size_t len = ::wcsnlen(buf.data(), max_chars); if (len == max_chars) // no null terminator found return std::nullopt; if (len == 0) // empty string return std::nullopt; std::string result; llvm::convertWideToUTF8(std::wstring(buf.data(), len), result); return result; } static std::optional ReadRemotePathStringA(HANDLE process, LPCVOID addr) { SIZE_T to_read = std::min(MAX_PATH + 1, BytesReadableAt(process, addr)); if (to_read == 0) return std::nullopt; std::array buf{}; SIZE_T bytes_read = 0; if (!::ReadProcessMemory(process, addr, buf.data(), to_read, &bytes_read)) return std::nullopt; size_t len = ::strnlen(buf.data(), bytes_read); if (len == bytes_read) // no null terminator found return std::nullopt; if (len == 0) // empty string return std::nullopt; return std::string(buf.data(), len); } // Resolve the LOAD_DLL_DEBUG_INFO::lpImageName field. static std::optional GetFileNameFromImageNameField(HANDLE process, const LOAD_DLL_DEBUG_INFO &info) { if (info.lpImageName == nullptr) return std::nullopt; LPVOID string_addr = nullptr; SIZE_T bytes_read = 0; if (!::ReadProcessMemory(process, info.lpImageName, &string_addr, sizeof(string_addr), &bytes_read) || bytes_read != sizeof(string_addr)) return std::nullopt; if (info.fUnicode) return ReadRemotePathStringW(process, string_addr); return ReadRemotePathStringA(process, string_addr); } DWORD DebuggerThread::HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info, DWORD thread_id) { Log *log = GetLog(WindowsLog::Event); auto on_load_dll = [&](llvm::StringRef path) { FileSpec file_spec(path); ModuleSpec module_spec(file_spec); lldb::addr_t load_addr = reinterpret_cast(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::optional resolved_path; if (info.hFile != nullptr) { std::vector buffer(1); DWORD required_size = GetFinalPathNameByHandleW(info.hFile, &buffer[0], 0, VOLUME_NAME_DOS); if (required_size > 0) { buffer.resize(required_size + 1); 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; path_str.consume_front("\\\\?\\"); resolved_path = path_str.str(); } else { resolved_path = GetFileNameFromHandleFallback(info.hFile); } } HANDLE process = m_process.GetNativeProcess().GetSystemHandle(); if (!resolved_path) resolved_path = GetFileNameFromImageNameField(process, info); if (!resolved_path) resolved_path = GetFileNameByLoadAddress(process, info.lpBaseOfDll); if (resolved_path) on_load_dll(*resolved_path); else LLDB_LOG(log, "Inferior {0} - could not resolve path for LOAD_DLL_DEBUG_EVENT " "(hFile={1}, base={2:x}, last error={3})", m_process.GetProcessId(), info.hFile, info.lpBaseOfDll, ::GetLastError()); // Windows does not automatically close info.hFile, so we need to do it. if (info.hFile != nullptr) ::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(info.lpBaseOfDll)); return DBG_CONTINUE; } DWORD DebuggerThread::HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info, DWORD thread_id) { m_debug_delegate->OnDebugString( static_cast( reinterpret_cast(info.lpDebugStringData)), info.fUnicode == TRUE, info.nDebugStringLength); 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; }