Implement attach to process on windows

[zturner]

Add context

[amccarth]

My biggest concern is making the key explanation in the comments a little clearer. Other than that, this looks pretty good.

source/Plugins/Platform/Windows/PlatformWindows.cpp

535 ↗

(On Diff #25897)

I'm confused here. If you're attaching to a process that's already running, we can't spawn the process. Are you're talking only about launching and not "launching _or attaching_ to a process"?

541 ↗

(On Diff #25897)

s/it to stop/it stop/

545 ↗

(On Diff #25897)

s/into/in/

source/Plugins/Platform/Windows/PlatformWindows.h

124 ↗

(On Diff #25897)

Isn't the LLDB style to put the return type on a separate line?

source/Plugins/Process/Windows/ProcessWindows.cpp

347 ↗

(On Diff #25897)

I wonder if we should have some sort of finite timeout here. If something goes wrong, it would be nice for tests to fail rather than hang.

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.h

public:
     uint32_t
     FindProcesses(const lldb_private::ProcessInstanceInfoMatch &match_info,
                   lldb_private::ProcessInstanceInfoList &process_infos) override;
 
     lldb_private::Error
     LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) override;
 
     lldb::ProcessSP
-    Attach(lldb_private::ProcessAttachInfo &attach_info,
-           lldb_private::Debugger &debugger,
-           lldb_private::Target *target,
-           lldb_private::Error &error) override;
+    DebugProcess(lldb_private::ProcessLaunchInfo &launch_info, lldb_private::Debugger &debugger,
+                 lldb_private::Target *target, lldb_private::Error &error) override;
+
+    lldb::ProcessSP
+    Attach(lldb_private::ProcessAttachInfo &attach_info, lldb_private::Debugger &debugger,
+           lldb_private::Target *target, lldb_private::Error &error) override;
 
     lldb_private::Error
     GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                     const lldb_private::UUID* uuid, lldb_private::FileSpec &local_file) override;
 
     lldb_private::Error
     GetSharedModule(const lldb_private::ModuleSpec &module_spec,
                     lldb_private::Process* process,
                     lldb::ModuleSP &module_sp,
                     const lldb_private::FileSpecList *module_search_paths_ptr,
                     lldb::ModuleSP *old_module_sp_ptr,
                     bool *did_create_ptr) override;
 
     bool
     GetSupportedArchitectureAtIndex(uint32_t idx, lldb_private::ArchSpec &arch) override;
 
     void
     GetStatus(lldb_private::Stream &strm) override;
 
-    // Local debugging not yet supported
-    bool
-    CanDebugProcess(void) override
-    {
-        return false;
-    }
+    bool CanDebugProcess() override;
 
     // FIXME not sure what the _sigtramp equivalent would be on this platform
     void
     CalculateTrapHandlerSymbolNames () override
     {
     }
 
 protected:

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

else
         if (m_remote_platform_sp)
             error = m_remote_platform_sp->LaunchProcess (launch_info);
         else
             error.SetErrorString ("the platform is not currently connected");
     }
     return error;
 }
 
+ProcessSP
+PlatformWindows::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger, Target *target, Error &error)
+{
+    // Windows has special considerations that must be followed when launching or attaching to a process.  The
+    // key requirement is that when launching or attaching to a process, you must do it from the same the thread
+    // that will go into a permanent loop which will then receive debug events from the process.  In particular,
+    // this means we can't use any of LLDB's generic mechanisms to do it for us, because it doesn't have the
+    // special knowledge required for setting up the background thread or passing the right flags.  
+    //
+    // Another problem is that that LLDB's standard model for debugging a process is to first launch it, have
+    // it stop at the entry point, and then attach to it.  In Windows this doesn't quite work, you have to 
+    // specify as an argument to CreateProcess() that you're going to debug the process.  So we override DebugProcess
+    // here to handle this.  Launch operations go directly to the process plugin, and attach operations almost go
+    // directly to the process plugin (but we hijack the events first).  In essence, we encapsulate all the logic
+    // of Launching and Attaching in the process plugin, and PlatformWindows::DebugProcess is just a pass-through
+    // to get to the process plugin.
+
+    if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
+    {
+        // This is a process attach.  Don't need to launch anything.
+        ProcessAttachInfo attach_info(launch_info);
+        return Attach(attach_info, debugger, target, error);
+    }
+    else
+    {
+        ProcessSP process_sp = target->CreateProcess(launch_info.GetListenerForProcess(debugger),
+                                                     launch_info.GetProcessPluginName(),
+                                                     nullptr);
+
+        // We need to launch and attach to the process.
+        launch_info.GetFlags().Set(eLaunchFlagDebug);
+        if (process_sp)
+            error = process_sp->Launch(launch_info);
+
+        return process_sp;
+    }
+}
+
 lldb::ProcessSP
 PlatformWindows::Attach(ProcessAttachInfo &attach_info,
                         Debugger &debugger,
                         Target *target,
                         Error &error)
 {
+    error.Clear();
     lldb::ProcessSP process_sp;
-    if (IsHost())
+    if (!IsHost())
     {
-        if (target == NULL)
-        {
-            TargetSP new_target_sp;
-            FileSpec emptyFileSpec;
-            ArchSpec emptyArchSpec;
+        if (m_remote_platform_sp)
+            process_sp = m_remote_platform_sp->Attach (attach_info, debugger, target, error);
+        else
+            error.SetErrorString ("the platform is not currently connected");
+        return process_sp;
+    }
+
 
-            error = debugger.GetTargetList().CreateTarget (debugger,
-                                                           NULL,
-                                                           NULL,
-                                                           false,
-                                                           NULL,
-                                                           new_target_sp);
-            target = new_target_sp.get();
-        }
-        else
-            error.Clear();
 
-        if (target && error.Success())
-        {
-            debugger.GetTargetList().SetSelectedTarget(target);
-            // The Windows platform always currently uses the GDB remote debugger plug-in
-            // so even when debugging locally we are debugging remotely!
-            // Just like the darwin plugin.
-            process_sp = target->CreateProcess (attach_info.GetListenerForProcess(debugger), "gdb-remote", NULL);
+    if (!target || error.Fail())
+        return process_sp;
+
 
-            if (process_sp)
-                error = process_sp->Attach (attach_info);
-        }
-    }
-    else
-    {
-        if (m_remote_platform_sp)
-            process_sp = m_remote_platform_sp->Attach (attach_info, debugger, target, error);
-        else
-            error.SetErrorString ("the platform is not currently connected");
-    }
+    const char *plugin_name = attach_info.GetProcessPluginName();
+    process_sp = target->CreateProcess(attach_info.GetListenerForProcess(debugger), plugin_name, NULL);
+
+    process_sp->HijackProcessEvents(attach_info.GetHijackListener().get());
+
     return process_sp;
 }
 
 const char *
 PlatformWindows::GetUserName (uint32_t uid)
 {
     // Check the cache in Platform in case we have already looked this uid up
     const char *user_name = Platform::GetUserName(uid);
if (!HostInfo::GetOSVersion(major, minor, update))
         return;
     }
 
     strm << "Host: Windows " << major
          << '.' << minor
          << " Build: " << update << '\n';
 #endif
 }
+
+bool
+PlatformWindows::CanDebugProcess()
+{
+    return true;
+}

lldb/trunk/source/Plugins/Process/Windows/DebuggerThread.h

 //----------------------------------------------------------------------
 class DebuggerThread : public std::enable_shared_from_this<DebuggerThread>
 {
   public:
     DebuggerThread(DebugDelegateSP debug_delegate);
     virtual ~DebuggerThread();
 
     Error DebugLaunch(const ProcessLaunchInfo &launch_info);
+    Error DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info);
 
     HostProcess
     GetProcess() const
     {
         return m_process;
     }
     HostThread
     GetMainThread() const
private:
     HANDLE m_image_file;      // The image file of the process being debugged.
 
     ExceptionRecordSP m_active_exception; // The current exception waiting to be handled
 
     Predicate<ExceptionResult> m_exception_pred; // A predicate which gets signalled when an exception
                                                  // is finished processing and the debug loop can be
                                                  // continued.
 
-    static lldb::thread_result_t DebuggerThreadRoutine(void *data);
-    lldb::thread_result_t DebuggerThreadRoutine(const ProcessLaunchInfo &launch_info);
+    static lldb::thread_result_t DebuggerThreadLaunchRoutine(void *data);
+    lldb::thread_result_t DebuggerThreadLaunchRoutine(const ProcessLaunchInfo &launch_info);
+    static lldb::thread_result_t DebuggerThreadAttachRoutine(void *data);
+    lldb::thread_result_t DebuggerThreadAttachRoutine(lldb::pid_t pid, const ProcessAttachInfo &launch_info);
 };
 }
 
 #endif

lldb/trunk/source/Plugins/Process/Windows/DebuggerThread.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/ThisThread.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/ProcessLaunchInfo.h"
+#include "lldb/Target/Process.h"
 
 #include "Plugins/Process/Windows/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.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_image_file(nullptr)
 {
 }
 
 DebuggerThread::~DebuggerThread()
 {
 }
 
 Error
 DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info)
 {
     WINLOG_IFALL(WINDOWS_LOG_PROCESS,
         "DebuggerThread::DebugLaunch launching '%s'", launch_info.GetExecutableFile().GetPath().c_str());
 
     Error error;
     DebugLaunchContext *context = new DebugLaunchContext(this, launch_info);
     HostThread slave_thread(ThreadLauncher::LaunchThread("lldb.plugin.process-windows.slave[?]",
-                            DebuggerThreadRoutine, context, &error));
+                                                         DebuggerThreadLaunchRoutine, context, &error));
 
     if (!error.Success())
     {
         WINERR_IFALL(WINDOWS_LOG_PROCESS,
             "DebugLaunch couldn't launch debugger thread.  %s", error.AsCString());
     }
 
     return error;
 }
 
+Error
+DebuggerThread::DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
+{
+    WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DebuggerThread::DebugAttach attaching to '%u'", (DWORD)pid);
+
+    Error 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())
+    {
+        WINERR_IFALL(WINDOWS_LOG_PROCESS, "DebugAttach couldn't attach to process '%u'.  %s", (DWORD)pid,
+                     error.AsCString());
+    }
+
+    return error;
+}
+
 lldb::thread_result_t
-DebuggerThread::DebuggerThreadRoutine(void *data)
+DebuggerThread::DebuggerThreadLaunchRoutine(void *data)
 {
     DebugLaunchContext *context = static_cast<DebugLaunchContext *>(data);
-    lldb::thread_result_t result = context->m_thread->DebuggerThreadRoutine(context->m_launch_info);
+    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::DebuggerThreadRoutine(const ProcessLaunchInfo &launch_info)
+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());
 
-    WINLOG_IFALL(WINDOWS_LOG_PROCESS,
-        "DebuggerThread preparing to launch '%s'.",
+    WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DebuggerThread preparing to launch '%s' on background thread.",
                  launch_info.GetExecutableFile().GetPath().c_str());
 
     Error 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());
+
+    WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DebuggerThread preparing to attach to process '%u' on background thread.",
+                 (DWORD)pid);
+
+    if (!DebugActiveProcess((DWORD)pid))
+    {
+        Error 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;
+}
+
 Error
 DebuggerThread::StopDebugging(bool terminate)
 {
     Error error;
 
     lldb::pid_t pid = m_process.GetProcessId();
 
     WINLOG_IFALL(WINDOWS_LOG_PROCESS,

lldb/trunk/source/Plugins/Process/Windows/DynamicLoaderWindows.cpp

 //===-- DynamicLoaderWindows.cpp --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DynamicLoaderWindows.h"
+#include "ProcessWindowsLog.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "llvm/ADT/Triple.h"
 
 using namespace lldb;
DynamicLoader *DynamicLoaderWindows::CreateInstance(Process *process, bool force)
     {
         const llvm::Triple &triple_ref = process->GetTarget().GetArchitecture().GetTriple();
         if (triple_ref.getOS() == llvm::Triple::Win32)
             should_create = true;
     }
 
     if (should_create)
         return new DynamicLoaderWindows (process);
+
     return nullptr;
 }
 
 void DynamicLoaderWindows::DidAttach()
 {
 
 }
 
uint32_t DynamicLoaderWindows::GetPluginVersion()
     return 1;
 }
 
 ThreadPlanSP
 DynamicLoaderWindows::GetStepThroughTrampolinePlan(Thread &thread, bool stop)
 {
     return ThreadPlanSP();
 }
 No newline at end of file

lldb/trunk/source/Plugins/Process/Windows/ProcessWindows.h

 #include "lldb/Target/Process.h"
 
 #include "llvm/Support/Mutex.h"
 
 class ProcessMonitor;
 
 namespace lldb_private
 {
+class HostProcess;
 class ProcessWindowsData;
 }
 
 class ProcessWindows : public lldb_private::Process, public lldb_private::IDebugDelegate
 {
 public:
     //------------------------------------------------------------------
     // Static functions.
public:
     size_t GetSTDERR(char *buf, size_t buf_size, lldb_private::Error &error) override;
     size_t PutSTDIN(const char *buf, size_t buf_size, lldb_private::Error &error) override;
 
     lldb_private::Error EnableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
     lldb_private::Error DisableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
 
     lldb_private::Error DoDetach(bool keep_stopped) override;
     lldb_private::Error DoLaunch(lldb_private::Module *exe_module, lldb_private::ProcessLaunchInfo &launch_info) override;
+    lldb_private::Error DoAttachToProcessWithID(lldb::pid_t pid,
+                                                const lldb_private::ProcessAttachInfo &attach_info) override;
     lldb_private::Error DoResume() override;
     lldb_private::Error DoDestroy() override;
     lldb_private::Error DoHalt(bool &caused_stop) override;
 
     void DidLaunch() override;
+    void DidAttach(lldb_private::ArchSpec &arch_spec) override;
 
     void RefreshStateAfterStop() override;
     lldb::addr_t GetImageInfoAddress() override;
 
     bool CanDebug(lldb_private::Target &target, bool plugin_specified_by_name) override;
     bool
     DetachRequiresHalt() override
     {
public:
     void OnCreateThread(const lldb_private::HostThread &thread) override;
     void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
     void OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr) override;
     void OnUnloadDll(lldb::addr_t module_addr) override;
     void OnDebugString(const std::string &string) override;
     void OnDebuggerError(const lldb_private::Error &error, uint32_t type) override;
 
   private:
+    lldb_private::Error WaitForDebuggerConnection(lldb_private::DebuggerThreadSP debugger,
+                                                  lldb_private::HostProcess &process);
+
     llvm::sys::Mutex m_mutex;
 
     // Data for the active debugging session.
     std::unique_ptr<lldb_private::ProcessWindowsData> m_session_data;
 };
 
 #endif  // liblldb_Plugins_Process_Windows_ProcessWindows_H_

lldb/trunk/source/Plugins/Process/Windows/ProcessWindows.cpp

 namespace lldb_private
 {
 
 // We store a pointer to this class in the ProcessWindows, so that we don't expose Windows
 // OS specific types and implementation details from a public header file.
 class ProcessWindowsData
 {
   public:
-    ProcessWindowsData(const ProcessLaunchInfo &launch_info)
-        : m_launch_info(launch_info)
+    ProcessWindowsData(bool stop_at_entry)
+        : m_stop_at_entry(stop_at_entry)
         , m_initial_stop_event(nullptr)
         , m_initial_stop_received(false)
     {
         m_initial_stop_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
     }
 
     ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); }
 
-    ProcessLaunchInfo m_launch_info;
     lldb_private::Error m_launch_error;
     lldb_private::DebuggerThreadSP m_debugger;
     StopInfoSP m_pending_stop_info;
     HANDLE m_initial_stop_event;
+    bool m_stop_at_entry;
     bool m_initial_stop_received;
     std::map<lldb::tid_t, HostThread> m_new_threads;
     std::set<lldb::tid_t> m_exited_threads;
 };
 }
 //------------------------------------------------------------------------------
 // Static functions.
 
if (!launch_info.GetFlags().Test(eLaunchFlagDebug))
                       launch_info.GetExecutableFile().GetPath().c_str());
         std::string message = stream.GetString();
         result.SetErrorString(message.c_str());
 
         WINERR_IFALL(WINDOWS_LOG_PROCESS, message.c_str());
         return result;
     }
 
-    m_session_data.reset(new ProcessWindowsData(launch_info));
+    bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
+    m_session_data.reset(new ProcessWindowsData(stop_at_entry));
 
     SetPrivateState(eStateLaunching);
     DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this()));
     m_session_data->m_debugger.reset(new DebuggerThread(delegate));
     DebuggerThreadSP debugger = m_session_data->m_debugger;
 
     // Kick off the DebugLaunch asynchronously and wait for it to complete.
     result = debugger->DebugLaunch(launch_info);
+    if (result.Fail())
+    {
+        WINERR_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch failed launching '%s'.  %s",
+                     launch_info.GetExecutableFile().GetPath().c_str(), result.AsCString());
+        return result;
+    }
 
     HostProcess process;
-    if (result.Success())
+    Error error = WaitForDebuggerConnection(debugger, process);
+    if (error.Fail())
     {
-        WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch started asynchronous launch of '%s'.  Waiting for initial stop.",
-                     launch_info.GetExecutableFile().GetPath().c_str());
+        WINERR_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch failed launching '%s'.  %s",
+                     launch_info.GetExecutableFile().GetPath().c_str(), error.AsCString());
+        return error;
+    }
+
+    WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch successfully launched '%s'",
 
-        // Block this function until we receive the initial stop from the process.
-        if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) == WAIT_OBJECT_0)
-        {
-            process = debugger->GetProcess();
-            if (m_session_data->m_launch_error.Fail())
-                result = m_session_data->m_launch_error;
-        }
-        else
-            result.SetError(::GetLastError(), eErrorTypeWin32);
-    }
+    // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was specified, the private state
+    // should already be set to eStateStopped as a result of hitting the initial breakpoint.  If
+    // it was not set, the breakpoint should have already been resumed from and the private state
+    // should already be eStateRunning.
+    launch_info.SetProcessID(process.GetProcessId());
+    SetID(process.GetProcessId());
+
+    return result;
 
-    if (result.Success())
-    {
-        WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch successfully launched '%s'",
-                     launch_info.GetExecutableFile().GetPath().c_str());
+Error
+ProcessWindows::DoAttachToProcessWithID(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
+    m_session_data.reset(new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
+
+    DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this()));
+    DebuggerThreadSP debugger(new DebuggerThread(delegate));
+
+    m_session_data->m_debugger = debugger;
+
+    DWORD process_id = static_cast<DWORD>(pid);
+    Error error = debugger->DebugAttach(process_id, attach_info);
+    if (error.Fail())
+    {
+        WINLOG_IFALL(WINDOWS_LOG_PROCESS,
+                     "DoAttachToProcessWithID encountered an error occurred initiating the asynchronous attach.  %s",
+                     error.AsCString());
+        return error;
     }
-    else
+
+    HostProcess process;
+    error = WaitForDebuggerConnection(debugger, process);
+    if (error.Fail())
     {
-        WINERR_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch failed launching '%s'.  %s",
-                     launch_info.GetExecutableFile().GetPath().c_str(), result.AsCString());
-        return result;
+        WINLOG_IFALL(WINDOWS_LOG_PROCESS,
+                     "DoAttachToProcessWithID encountered an error waiting for the debugger to connect.  %s",
+                     error.AsCString());
+        return error;
     }
 
-    // We've hit the initial stop.  The private state should already be set to stopped as a result
-    // of encountering the breakpoint exception in ProcessWindows::OnDebugException.
-    launch_info.SetProcessID(process.GetProcessId());
+    WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoAttachToProcessWithID successfully attached to process with pid=%u",
+                 process_id);
+
+    // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was specified, the private state
+    // should already be set to eStateStopped as a result of hitting the initial breakpoint.  If
+    // it was not set, the breakpoint should have already been resumed from and the private state
+    // should already be eStateRunning.
     SetID(process.GetProcessId());
+    return error;
+}
 
-    return result;
+Error
+ProcessWindows::WaitForDebuggerConnection(DebuggerThreadSP debugger, HostProcess &process)
+{
+    Error result;
+    WINLOG_IFANY(WINDOWS_LOG_PROCESS|WINDOWS_LOG_BREAKPOINTS, "WaitForDebuggerConnection Waiting for loader breakpoint.");
+
+    // Block this function until we receive the initial stop from the process.
+    if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) == WAIT_OBJECT_0)
+    {
+        WINLOG_IFANY(WINDOWS_LOG_PROCESS|WINDOWS_LOG_BREAKPOINTS, "WaitForDebuggerConnection hit loader breakpoint, returning.");
+
+        process = debugger->GetProcess();
+        return m_session_data->m_launch_error;
+    }
+    else
+        return Error(::GetLastError(), eErrorTypeWin32);
 }
 
 Error
 ProcessWindows::DoResume()
 {
     llvm::sys::ScopedLock lock(m_mutex);
     Error error;
 
else
                          error.GetError());
         }
     }
     return error;
 }
 
 void ProcessWindows::DidLaunch()
 {
+    DidAttach(ArchSpec());
+}
+
+void
+ProcessWindows::DidAttach(ArchSpec &arch_spec)
+{
     llvm::sys::ScopedLock lock(m_mutex);
 
     // The initial stop won't broadcast the state change event, so account for that here.
-    if (m_session_data && GetPrivateState() == eStateStopped &&
-            m_session_data->m_launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
+    if (m_session_data && GetPrivateState() == eStateStopped && m_session_data->m_stop_at_entry)
         RefreshStateAfterStop();
 }
 
 size_t
 ProcessWindows::DoReadMemory(lldb::addr_t vm_addr,
                              void *buf,
                              size_t size,
                              Error &error)
ProcessWindows::DoReadMemory(lldb::addr_t vm_addr,
     }
     return bytes_read;
 }
 
 size_t
 ProcessWindows::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, Error &error)
 {
     llvm::sys::ScopedLock lock(m_mutex);
+    WINLOG_IFALL(WINDOWS_LOG_MEMORY, "DoWriteMemory attempting to write %u bytes into address 0x%I64x", size, vm_addr);
 
     if (!m_session_data)
+    {
+        WINERR_IFANY(WINDOWS_LOG_MEMORY, "DoWriteMemory cannot write, there is no active debugger connection.");
         return 0;
-
-    WINLOG_IFALL(WINDOWS_LOG_MEMORY, "DoWriteMemory attempting to write %u bytes into address 0x%I64x", size, vm_addr);
+    }
 
     HostProcess process = m_session_data->m_debugger->GetProcess();
     void *addr = reinterpret_cast<void *>(vm_addr);
     SIZE_T bytes_written = 0;
     lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
     if (WriteProcessMemory(handle, addr, buf, size, &bytes_written))
         FlushInstructionCache(handle, addr, bytes_written);
     else

 void
 ProcessWindows::OnDebuggerConnected(lldb::addr_t image_base)
 {
     DebuggerThreadSP debugger = m_session_data->m_debugger;
 
     WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Debugger established connected to process %I64u.  Image base = 0x%I64x",
                  debugger->GetProcess().GetProcessId(), image_base);
 
-    // Either we successfully attached to an existing process, or we successfully launched a new
-    // process under the debugger.
     ModuleSP module = GetTarget().GetExecutableModule();
     bool load_addr_changed;
     module->SetLoadAddress(GetTarget(), image_base, false, load_addr_changed);
 
-    // Notify the target that the executable module has loaded.  This will cause any pending
-    // breakpoints to be resolved to explicit brekapoint sites.
     ModuleList loaded_modules;
     loaded_modules.Append(module);
     GetTarget().ModulesDidLoad(loaded_modules);
 
+    // Add the main executable module to the list of pending module loads.  We can't call
+    // GetTarget().ModulesDidLoad() here because we still haven't returned from DoLaunch() / DoAttach() yet
+    // so the target may not have set the process instance to `this` yet.
     llvm::sys::ScopedLock lock(m_mutex);
-
     const HostThreadWindows &wmain_thread = debugger->GetMainThread().GetNativeThread();
     m_session_data->m_new_threads[wmain_thread.GetThreadId()] = debugger->GetMainThread();
 }
 
 ExceptionResult
 ProcessWindows::OnDebugException(bool first_chance, const ExceptionRecord &record)
 {
     llvm::sys::ScopedLock lock(m_mutex);
ProcessWindows::OnDebugException(bool first_chance, const ExceptionRecord &record)
     switch (record.GetExceptionCode())
     {
         case EXCEPTION_BREAKPOINT:
             // Handle breakpoints at the first chance.
             result = ExceptionResult::BreakInDebugger;
 
             if (!m_session_data->m_initial_stop_received)
             {
+                WINLOG_IFANY(WINDOWS_LOG_BREAKPOINTS,
+                             "Hit loader breakpoint at address 0x%I64x, setting initial stop event.",
+                             record.GetExceptionAddress());
                 m_session_data->m_initial_stop_received = true;
                 ::SetEvent(m_session_data->m_initial_stop_event);
             }
+            else
+            {
+                WINLOG_IFANY(WINDOWS_LOG_BREAKPOINTS,
+                             "Hit non-loader breakpoint at address 0x%I64x.",
+                             record.GetExceptionAddress());
+            }
             SetPrivateState(eStateStopped);
             break;
         case EXCEPTION_SINGLE_STEP:
             result = ExceptionResult::BreakInDebugger;
             SetPrivateState(eStateStopped);
             break;
         default:
             WINLOG_IFANY(WINDOWS_LOG_EXCEPTION,

lldb/trunk/source/Target/Process.cpp

Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
     if (log)
         log->Printf ("Process::AttachCompletionHandler::%s called with state %s (%d)", __FUNCTION__, StateAsCString(state), static_cast<int> (state));
 
     switch (state)
     {
+        case eStateAttaching:
+            return eEventActionSuccess;
+
         case eStateRunning:
         case eStateConnected:
             return eEventActionRetry;
         
         case eStateStopped:
         case eStateCrashed:
             {
                 // During attach, prior to sending the eStateStopped event, 
if (should_broadcast)
                          is_hijacked ? "hijacked" : "public");
         }
         Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
         if (StateIsRunningState (new_state))
         {
             // Only push the input handler if we aren't fowarding events,
             // as this means the curses GUI is in use...
             // Or don't push it if we are launching since it will come up stopped.
-            if (!GetTarget().GetDebugger().IsForwardingEvents() && new_state != eStateLaunching)
+            if (!GetTarget().GetDebugger().IsForwardingEvents() && new_state != eStateLaunching &&
+                new_state != eStateAttaching)
                 PushProcessIOHandler ();
             m_iohandler_sync.SetValue(true, eBroadcastAlways);
         }
         else if (StateIsStoppedState(new_state, false))
         {
             m_iohandler_sync.SetValue(false, eBroadcastNever);
             if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
             {