[Windows] Fix a bug that causes lldb to freeze

[asmith]

Summary

If the process exits before any initial stop then notify the debugger
of the error otherwise WaitForDebuggerConnection() will be blocked.
An example of this issue is when a process fails to load a dependent DLL.

In addition to the fix, remove a duplicate call to FreeProcessHandles() in
DebuggerThread::HandleExitProcessEvent() and use decimal format
for all thread IDs.

[zturner]

Nice find, thanks

[labath]

Do we have a test for this? It sounds like it shouldn't be hard to replicate the dependent library load failure in a test...

source/Plugins/Process/Windows/Common/DebuggerThread.cpp

 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;
 };
-}
+} // namespace
 
 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); }
if (handle != nullptr && handle != LLDB_INVALID_PROCESS) {
       // 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})",
+               "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.
void DebuggerThread::DebugLoop() {
   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;
if (wait_result) {
                ::GetLastError());
 
       should_debug = false;
     }
   }
   FreeProcessHandles();
 
   LLDB_LOG(log, "WaitForDebugEvent loop completed, exiting.");
-  SetEvent(m_debugging_ended_event);
+  ::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) {
DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
   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,
+  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::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) {

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

if (target) {
     ModuleSP executable_module = target->GetExecutableModule();
     ModuleList unloaded_modules;
     unloaded_modules.Append(executable_module);
     target->ModulesDidUnload(unloaded_modules, true);
   }
 
   SetProcessExitStatus(GetID(), true, 0, exit_code);
   SetPrivateState(eStateExited);
+
+  // If the process exits before any initial stop then notify the debugger 
+  // of the error otherwise WaitForDebuggerConnection() will be blocked.
+  // An example of this issue is when a process fails to load a dependent DLL. 
+  if (!m_session_data->m_initial_stop_received) {
+    Status error(exit_code, eErrorTypeWin32);
+    OnDebuggerError(error, 0);
+  }
 }
 
 void ProcessWindows::OnDebuggerConnected(lldb::addr_t image_base) {
   DebuggerThreadSP debugger = m_session_data->m_debugger;
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "Debugger connected to process {0}.  Image base = {1:x}",
            debugger->GetProcess().GetProcessId(), image_base);