523 lines
18 KiB
C++
523 lines
18 KiB
C++
//===-- DebuggerThread.cpp --------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "DebuggerThread.h"
|
|
#include "ExceptionRecord.h"
|
|
#include "IDebugDelegate.h"
|
|
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Host/Predicate.h"
|
|
#include "lldb/Host/ThreadLauncher.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/Target/ProcessLaunchInfo.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/Log.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"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
namespace {
|
|
struct DebugLaunchContext {
|
|
DebugLaunchContext(DebuggerThread *thread,
|
|
const ProcessLaunchInfo &launch_info)
|
|
: m_thread(thread), m_launch_info(launch_info) {}
|
|
DebuggerThread *m_thread;
|
|
ProcessLaunchInfo m_launch_info;
|
|
};
|
|
|
|
struct DebugAttachContext {
|
|
DebugAttachContext(DebuggerThread *thread, lldb::pid_t pid,
|
|
const ProcessAttachInfo &attach_info)
|
|
: m_thread(thread), m_pid(pid), m_attach_info(attach_info) {}
|
|
DebuggerThread *m_thread;
|
|
lldb::pid_t m_pid;
|
|
ProcessAttachInfo m_attach_info;
|
|
};
|
|
}
|
|
|
|
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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
|
|
LLDB_LOG(log, "launching '{0}'", launch_info.GetExecutableFile().GetPath());
|
|
|
|
Status error;
|
|
DebugLaunchContext *context = new DebugLaunchContext(this, launch_info);
|
|
HostThread slave_thread(ThreadLauncher::LaunchThread(
|
|
"lldb.plugin.process-windows.slave[?]", DebuggerThreadLaunchRoutine,
|
|
context, &error));
|
|
|
|
if (!error.Success())
|
|
LLDB_LOG(log, "couldn't launch debugger thread. {0}", error);
|
|
|
|
return error;
|
|
}
|
|
|
|
Status DebuggerThread::DebugAttach(lldb::pid_t pid,
|
|
const ProcessAttachInfo &attach_info) {
|
|
Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
|
|
LLDB_LOG(log, "attaching to '{0}'", pid);
|
|
|
|
Status error;
|
|
DebugAttachContext *context = new DebugAttachContext(this, pid, attach_info);
|
|
HostThread slave_thread(ThreadLauncher::LaunchThread(
|
|
"lldb.plugin.process-windows.slave[?]", DebuggerThreadAttachRoutine,
|
|
context, &error));
|
|
|
|
if (!error.Success())
|
|
LLDB_LOG(log, "couldn't attach to process '{0}'. {1}", pid, error);
|
|
|
|
return error;
|
|
}
|
|
|
|
lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(void *data) {
|
|
DebugLaunchContext *context = static_cast<DebugLaunchContext *>(data);
|
|
lldb::thread_result_t result =
|
|
context->m_thread->DebuggerThreadLaunchRoutine(context->m_launch_info);
|
|
delete context;
|
|
return result;
|
|
}
|
|
|
|
lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(void *data) {
|
|
DebugAttachContext *context = static_cast<DebugAttachContext *>(data);
|
|
lldb::thread_result_t result = context->m_thread->DebuggerThreadAttachRoutine(
|
|
context->m_pid, context->m_attach_info);
|
|
delete context;
|
|
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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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 0;
|
|
}
|
|
|
|
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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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 0;
|
|
}
|
|
|
|
// 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 0;
|
|
}
|
|
|
|
Status DebuggerThread::StopDebugging(bool terminate) {
|
|
Status error;
|
|
|
|
lldb::pid_t pid = m_process.GetProcessId();
|
|
|
|
Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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) {
|
|
// 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);
|
|
}
|
|
|
|
// 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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS |
|
|
WINDOWS_LOG_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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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) {
|
|
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 =
|
|
ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_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) {
|
|
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");
|
|
m_exception_pred.WaitForValueNotEqualTo(ExceptionResult::BreakInDebugger,
|
|
result);
|
|
|
|
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 =
|
|
ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD);
|
|
LLDB_LOG(log, "Thread {0:x} 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 =
|
|
ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_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.slave[" << 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 =
|
|
ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_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 =
|
|
ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD);
|
|
LLDB_LOG(log, "process {0} exited with code {1}", m_process.GetProcessId(),
|
|
info.dwExitCode);
|
|
|
|
m_debug_delegate->OnExitProcess(info.dwExitCode);
|
|
|
|
FreeProcessHandles();
|
|
return DBG_CONTINUE;
|
|
}
|
|
|
|
DWORD
|
|
DebuggerThread::HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info,
|
|
DWORD thread_id) {
|
|
Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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;
|
|
}
|
|
|
|
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;
|
|
|
|
FileSpec file_spec(path, false);
|
|
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);
|
|
} 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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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 = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_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;
|
|
}
|