[lldb-server] Add initial support for lldb-server on Windows

[asmith]

Summary

Make lldb-server work on Windows. Implement some remote capability support in PlatformWindows, launch gdbserver, and launch/attach processes using Windows APIs.

Some changes in this commit include:

• #ifdef what's not supported on Windows, for example signals
• Add a dummy 'waitpid' to the Windows PosixApi along with some definitions that are needed for compilation.
• Better error handling in SocketAddress::GetAddressInfo.
• Clear the string before calling llvm::convertWideToUTF8 to avoid an unexpected assertion.
• Make some of the tests work and disable others that don't.

[labath]

include/lldb/Host/windows/PosixApi.h

78

I don't see WUNTRACED being used anywhere within lldb. Why did you need this?

106–109

What are your plans for this?

I assume you needed this for the fork-server in lldb-platform.cpp. I think the best way to address that would be to change the code from spawning a separate process for each connection to having a new thread for each connection. That should be much more portable and will avoid the need to mock posix apis on windows. I can help you with that if you run into any problems there.

source/Host/common/SocketAddress.cpp

267

Writing to stdout like this is very rude. If there isn't a suitable way to return this info, then I suggest writing this to the log instead.

tools/lldb-server/SystemInitializerLLGS.cpp

35–50

I think a better option here would be to move this code to something like Socket::Initialize. Then we could call this from SystemInitializerCommon::Initialize, and it would be available to everyone. This would allow us to remove the copy of this code in PlatformWindows, and replace the WSAStartup calls in various unittests with Socket::Initialize()

tools/lldb-server/lldb-server.cpp

40

In other places we use llgs (for LLdb Gdb Server), so I suggest sticking to that.

[clayborg]

excited to see this starting as well!

[krytarowski]

include/lldb/Host/windows/PosixApi.h

77

I think that these symbols should not be leaked here in the first place.

[zturner]

include/lldb/Host/windows/PosixApi.h

77–78

In general we should avoid mocking posix APIs for Windows. If something is currently implemented in terms of a Posix API that doesn't exist on Windows, we should provide an implementation of that function with an entirely new name and platform-agnostic set of parameters whose interface need not resemble the posix interface in any way..

For example, I see this is used in lldb-platform.cpp when we call waitpid(). Instead, we could add something like void WaitForAllChildProcessesToExit(); and then just implement that function on posix and Windows completely separately. This is more flexible and portable than trying to fit Windows semantics into a posix api, which doesn't always work.

106–109

Are you ok with the behavioral change? What if one connection crashes?

Assuming we wanted to implement this behavior on Windows, the way to do it would be to create all child processes in a single "job" (aka process group), as that is the best way to get notifications for when all childs have terminated.

source/Host/common/SocketAddress.cpp

262–266

Perhaps we could define something like lldb::eErrorTypeHostNative to avoid this ifdef.

tools/lldb-server/SystemInitializerLLGS.cpp

35–50

Also, why do we need the g_ref_count? Can't we just print an error message and call exit if the version is not what we expect?

55–58

I don't think Initialize and Terminate need to be re-entrant. So we can probably delete the ref count code here

tools/lldb-server/lldb-server.cpp

40

The static from before indicates that the function should not have external linkage, so I think we should keep that. Whether we put it in a namespace or not is orthogonal, but for global functions in cpp functions, we generally prefer to mark them all static.

[labath]

include/lldb/Host/windows/PosixApi.h

77–78

For the record, the intention of that code in lldb-platform is reapAllChildProcessesThatHaveAlreadyExited()

106–109

Yes, I would be fine with that (in fact I wanted to do that at some point anyway). The reason the fork server was added was to enable parallel running of remote tests (before that we only ever handled one concurrent connection). Also the platform mode of llgs doesn't do anything fancy. It's mostly just about copying files around and launching gdb-remote processes (so the real debugging still happens in a separate process), so the crashing surface is pretty limited.

BTW, the only reason we call waitpid there is that on unix, you *have* to do that or you will die of zombie infestation. So, if on windows you can create fire-and-forget child processes, then this whole code is unnecessary there.

[labath]

The patch is pretty big, so I haven't done an in-depth review yet. The fact that you've ran clang-format over entire files (and not just the diffs) does not help.

For a start, I've highlighted the parts that I believe can/should go into a separate patch. Some of them are obvious and can be committed immediately. Others should go through a separate review. We can get back to the core of the patch once these have been dealt with (FWIW, I haven't seen anything obviously wrong from a quick glance).

include/lldb/Core/Debugger.h

338

This looks like experimental code accidentally left in (?)

include/lldb/Target/Platform.h

599

To keep the scope of this patch (which is already pretty big) as small as possible, could you submit this as a separate patch? No review needed.

include/lldb/lldb-types.h

42–45

Please revert or submit as a separate patch.

lldb.xcodeproj/project.pbxproj

10522

I am surpised that you needed to change the xcode project in any way, as this code should not even build there. Please explain.

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteRegisterState.py

28

The fact that you were able to do this told me that this part of the test is actually irrelevant. So, I just went ahead and deleted this part altogether (r357451).

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

208–211

That sounds fun. Is that how things are supposed to work, or is that something you're planning to change/fix? (mostly just curious).

packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

674–675

delete ?

1494

The -1 looks like it needs to be windows-only.

packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

434

I don't think this can go in like this. However, I agree that this double-retry loop is pretty ugly. When I get some time, I'll try to see if I can rewrite this part to use reverse connects. That way we won't get any races at all. For the time being, I'd just revert this.

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

1

Could you (as a separate patch) convert this file to use c++ threads? That should allow us to cut down on the ifdefs by using standard std::thread and std::mutex.

source/Host/common/Socket.cpp

89–104

Please avoid spurious reformats of entire files. This makes it patches hard to review, particularly when they are as large as this one.

For the changes in this specific file, I think you can just commit them as a separate patch. Or revert the file completely, as the only thing you seem to be doing is adding logging.

source/Host/common/SocketAddress.cpp

267

This comment still stands.

source/Host/windows/HostInfoWindows.cpp

98

Move this into a separate patch, add a unit test checking that string is cleared when this function is called.

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

294

Move UUID handling into a separate patch.

source/Plugins/Process/Utility/RegisterContextWindows_x64.cpp

103

<iostream> is banned in llvm. (and it looks like you're not using it anyway).

source/Plugins/Process/Utility/RegisterContextWindows_x64.h

33

d_ ?

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

64

delete?

98

delete?

source/Plugins/Process/Windows/Common/NativeProcessWindows.h

16

It looks like IDebugDelegate.h is missing from the patch.

138

It looks like m_process will never be null. Convert it to a reference, and delete all the null-checks?

source/Plugins/Process/Windows/Common/ProcessDebugger.h

16

File missing from patch.

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

565–585

spurious reformats.

tools/lldb-server/SystemInitializerLLGS.cpp

35–50

I still believe this should go to Socket::Initialize (as a separate patch).

tools/lldb-server/lldb-server.cpp

38–74

The whole file looks good. You can commit this separately straight away. (Maybe add a comment somewhere that the namespace is there to avoid conflicts on windows. Otherwise someone in the future might get the idea to replace the file-local namespace with an anonymous one.)

[asmith]

Committed a few NFC changes

[asmith]

tools/lldb-server/SystemInitializerLLGS.cpp

35–50

This is done in https://reviews.llvm.org/D60440

[asmith]

source/Plugins/Process/Windows/Common/NativeProcessWindows.h

16

IDebugDelegate.h is located in source/Plugins/Process/Windows/Common

source/Plugins/Process/Windows/Common/ProcessDebugger.h

16

That's found in source/Plugins/Process/Windows/Common

[asmith]

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

294

The UUID change is being discussed here https://reviews.llvm.org/D56229

[asmith]

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

1

Done in https://reviews.llvm.org/D60496

[labath]

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

294

Ah, I completely forgot about that patch. Thanks for reminding me. This is actually very good timing because I was just diving into the topic of UUID matching in lldb on windows (in order to match up minidumps with respective exe/pdb files). I'll elaborate more there...

[asmith]

This was split into separate patches and committed. No longer need this review.

cmake/modules/LLDBConfig.cmake

 endif()
 
 list(APPEND system_libs ${CMAKE_DL_LIBS})
 
 SET(SKIP_LLDB_SERVER_BUILD OFF CACHE BOOL "Skip building lldb-server")
 
 # Figure out if lldb could use lldb-server.  If so, then we'll
 # ensure we build lldb-server when an lldb target is being built.
-if (CMAKE_SYSTEM_NAME MATCHES "Android|Darwin|FreeBSD|Linux|NetBSD")
+if (CMAKE_SYSTEM_NAME MATCHES "Android|Darwin|FreeBSD|Linux|NetBSD|Windows")
     set(LLDB_CAN_USE_LLDB_SERVER 1)
 else()
     set(LLDB_CAN_USE_LLDB_SERVER 0)
 endif()
 
 # Figure out if lldb could use debugserver.  If so, then we'll
 # ensure we build debugserver when we build lldb.
 if ( CMAKE_SYSTEM_NAME MATCHES "Darwin" )

include/lldb/Core/Debugger.h

public:
   // selected target, or if no target is present you want to prime the dummy
   // target with entities that will be copied over to new targets.
   Target *GetSelectedOrDummyTarget(bool prefer_dummy = false);
   Target *GetDummyTarget();
 
   lldb::BroadcasterManagerSP GetBroadcasterManager() {
     return m_broadcaster_manager_sp;
   }
+  bool StartEventHandlerThread();
 
 protected:
   friend class CommandInterpreter;
   friend class REPL;
 
-  bool StartEventHandlerThread();
+  //bool StartEventHandlerThread();
 
   void StopEventHandlerThread();
 
   static lldb::thread_result_t EventHandlerThread(lldb::thread_arg_t arg);
 
   bool HasIOHandlerThread();
 
   bool StartIOHandlerThread();

include/lldb/Host/common/NativeProcessProtocol.h

protected:
 
   // lldb_private::Host calls should be used to launch a process for debugging,
   // and then the process should be attached to. When attaching to a process
   // lldb_private::Host calls should be used to locate the process to attach
   // to, and then this function should be called.
   NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
                         NativeDelegate &delegate);
 
+  void SetID(lldb::pid_t pid) { m_pid = pid; }
+
   // ----------------------------------------------------------- Internal
   // interface for state handling
   // -----------------------------------------------------------
   void SetState(lldb::StateType state, bool notify_delegates = true);
 
   // Derived classes need not implement this.  It can be used as a hook to
   // clear internal caches that should be invalidated when stop ids change.
   //

include/lldb/Host/windows/PosixApi.h

 #define S_IFDIR _S_IFDIR
 
 #ifndef S_ISDIR
 #define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
 #endif
 
 #endif // _MSC_VER
 
+#define WNOHANG 1
+
 // Various useful posix functions that are not present in Windows.  We provide
 // custom implementations.
 int vasprintf(char **ret, const char *fmt, va_list ap);
 char *strcasestr(const char *s, const char *find);
 char *realpath(const char *name, char *resolved);
 
 int usleep(uint32_t useconds);
 char *basename(char *path);

 
 inline int unlockpt(int fd) { LLVM_BUILTIN_UNREACHABLE; }
 inline int grantpt(int fd) { LLVM_BUILTIN_UNREACHABLE; }
 inline char *ptsname(int fd) { LLVM_BUILTIN_UNREACHABLE; }
 
 inline pid_t fork(void) { LLVM_BUILTIN_UNREACHABLE; }
 inline pid_t setsid(void) { LLVM_BUILTIN_UNREACHABLE; }
 
+inline pid_t waitpid(pid_t pid, int *status, int options) {
+  // To be implemented.
+  return pid_t(-1);
+}
 #endif

include/lldb/Target/Platform.h

error.SetErrorStringWithFormat(
         "Platform::ReadFile() is not supported in the %s platform",
         GetName().GetCString());
     return -1;
   }
 
   virtual uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset,
                              const void *src, uint64_t src_len, Status &error) {
     error.SetErrorStringWithFormat(
-        "Platform::ReadFile() is not supported in the %s platform",
+        "Platform::WriteFile() is not supported in the %s platform",
         GetName().GetCString());
     return -1;
   }
 
   virtual Status GetFile(const FileSpec &source, const FileSpec &destination);
 
   virtual Status PutFile(const FileSpec &source, const FileSpec &destination,
                          uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX);

include/lldb/lldb-types.h

 // that is what lldb was first developed for.
 
 #ifdef _WIN32
 
 #include <process.h>
 
 namespace lldb {
 typedef void *rwlock_t;
-typedef void *process_t;             // Process type is HANDLE
-typedef void *thread_t;              // Host thread type
-typedef void *file_t;                // Host file type
-typedef unsigned int __w64 socket_t; // Host socket type
+typedef void *process_t;                          // Process type is HANDLE
+typedef void *thread_t;                           // Host thread type
+typedef void *file_t;                             // Host file type
+typedef unsigned int __w64 socket_t;              // Host socket type
 typedef void *thread_arg_t;                       // Host thread argument type
 typedef unsigned thread_result_t;                 // Host thread result type
 typedef thread_result_t (*thread_func_t)(void *); // Host thread function type
 typedef void *pipe_t;                             // Host pipe type is HANDLE
 } // namespace lldb
 
 #else
 
 #include <pthread.h>
 
 namespace lldb {
 //----------------------------------------------------------------------
 // MacOSX Types
 //----------------------------------------------------------------------
 typedef pthread_rwlock_t rwlock_t;
-typedef uint64_t process_t; // Process type is just a pid.
-typedef pthread_t thread_t; // Host thread type
-typedef int file_t;         // Host file type
-typedef int socket_t;       // Host socket type
+typedef uint64_t process_t;             // Process type is just a pid.
+typedef pthread_t thread_t;             // Host thread type
+typedef int file_t;                     // Host file type
+typedef int socket_t;                   // Host socket type
 typedef void *thread_arg_t;             // Host thread argument type
 typedef void *thread_result_t;          // Host thread result type
 typedef void *(*thread_func_t)(void *); // Host thread function type
 typedef int pipe_t;                     // Host pipe type
 } // namespace lldb
 
 #endif
 

lit/Modules/PECOFF/export-dllfunc.yaml

 # REQUIRES: system-windows
 # RUN: yaml2obj < %s > %t.obj
 #
 # RUN: lld-link /machine:x64 /out:%t.dll /noentry /nodefaultlib /dll %t.obj /export:DllFunc
 #
 # RUN: lldb-test object-file %t.dll | FileCheck -check-prefix=BASIC-CHECK %s
 # RUN: lldb-test object-file -dep-modules %t.dll | FileCheck -check-prefix=DEPS %s
 
+# BASIC-CHECK: Plugin name: pe-coff
+
+# timestamp and build id of debug info in the coff header varies. So does its UUID.
+# BASIC-CHECK-DAG: UUID: {{[0-9A-F]{7,}[0-9A-F]}}-{{.*}}
 
 # BASIC-CHECK: Showing 3 subsections
 # BASIC-CHECK:  Index: 0
 # BASIC-CHECK:  Name: .text
 # BASIC-CHECK:  Type: code
 # BASIC-CHECK:  VM size: 22
 # BASIC-CHECK:  File size: 512
 #

lldb.xcodeproj/project.pbxproj

26DC6A121337FE6A00FF7998 /* Debug */ = {
         "OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*]" = "$(OTHER_CFLAGS)";
         OTHER_LDFLAGS = (
           "$(inherited)",
           "-filelist",
           "$(LLVM_BUILD_DIR)/archives.txt",
           "-L/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/config",
           "-lpython2.7",
           "-lxml2",
+          "-lLLVMSupport",
           "-framework",
           DebugSymbols,
           "-framework",
           Foundation,
           "-framework",
           Carbon,
           "-framework",
           Security,
26DC6A131337FE6A00FF7998 /* Release */ = {
           "$(inherited)",
           "\"$(SYSTEM_LIBRARY_DIR)/PrivateFrameworks\"",
         );
         GCC_ENABLE_CPP_RTTI = NO;
         GCC_INLINES_ARE_PRIVATE_EXTERN = NO;
         INFOPLIST_PREPROCESSOR_DEFINITIONS = (
           "-lobjc",
           "-lpython",
+          "-lLLVMSupport",
           "-framework",
           DebugSymbols,
           "-framework",
           Carbon,
           "-framework",
           Foundation,
           "-framework",
           AppKit,

packages/Python/lldbsuite/test/dotest.py

def run_suite():
     checkLibcxxSupport()
     checkLibstdcxxSupport()
     checkDebugInfoSupport()
 
     # Don't do debugserver tests on anything except OS X.
     configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform
 
     # Don't do lldb-server (llgs) tests on anything except Linux.
-    configuration.dont_do_llgs_test = not ("linux" in target_platform)
+    configuration.dont_do_llgs_test = not ("linux" in target_platform) and not ("windows" in target_platform)
 
     # Collect tests from the specified testing directories. If a test
     # subdirectory filter is explicitly specified, limit the search to that
     # subdirectory.
     exclusive_test_subdir = configuration.get_absolute_path_to_exclusive_test_subdir()
     if exclusive_test_subdir:
         dirs_to_search = [exclusive_test_subdir]
     else:

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteAuxvSupport.py

class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
     #
     # We skip the "supports_auxv" test on debugserver.  The rest of the tests
     # appropriately skip the auxv tests if the support flag is not present
     # in the qSupported response, so the debugserver test bits are still there
     # in case debugserver code one day does have auxv support and thus those
     # tests don't get skipped.
     #
 
+    @skipIfWindows # no auxv support.
     @llgs_test
     def test_supports_auxv_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.supports_auxv()
 
     def auxv_data_is_correct_size(self):
         (word_size, auxv_data) = self.get_raw_auxv_data()
         self.assertIsNotNone(auxv_data)
 
         # Ensure auxv data is a multiple of 2*word_size (there should be two
         # unsigned long fields per auxv entry).
         self.assertEqual(len(auxv_data) % (2 * word_size), 0)
         # print("auxv contains {} entries".format(len(auxv_data) / (2*word_size)))
 
     @debugserver_test
     def test_auxv_data_is_correct_size_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_data_is_correct_size()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_data_is_correct_size_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_data_is_correct_size()
 
     def auxv_keys_look_valid(self):
class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_auxv_keys_look_valid_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_keys_look_valid()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_keys_look_valid_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_keys_look_valid()
 
     def auxv_chunked_reads_work(self):
class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @debugserver_test
     def test_auxv_chunked_reads_work_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_chunked_reads_work()
 
+    @skipIfWindows
     @llgs_test
     def test_auxv_chunked_reads_work_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.auxv_chunked_reads_work()

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteKill.py

 from __future__ import print_function
 
 
 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
 
     def attach_commandline_kill_after_initial_stop(self):
+        reg_expr = r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+
+        # No signal support on Windwos. Only W* response is sent.
+        if re.match(".*-.*-windows", triple):
+            reg_expr = r"^\$W[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"
+
         procs = self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines([
             "read packet: $k#6b",
-            {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+            {"direction": "send", "regex": reg_expr},
         ], True)
 
         if self.stub_sends_two_stop_notifications_on_kill:
             # Add an expectation for a second X result for stubs that send two
             # of these.
             self.test_sequence.add_log_lines([
-                {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+                {"direction": "send", "regex": reg_expr},
             ], True)
 
         self.expect_gdbremote_sequence()
 
         # Wait a moment for completed and now-detached inferior process to
         # clear.
         time.sleep(1)
 

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

class TestGdbRemoteModuleInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def module_info(self):
         procs = self.prep_debug_monitor_and_inferior()
         self.add_process_info_collection_packets()
         context = self.expect_gdbremote_sequence()
         info = self.parse_process_info_response(context)
 
+        module_path = lldbutil.append_to_process_working_directory(self, "a.out")
+
+        # Replace path separators in the json string either with "\\\\" or "/" on Windows.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-windows", triple):
+            module_path = module_path.replace(os.path.sep, '/')
+
         self.test_sequence.add_log_lines([
-            'read packet: $jModulesInfo:[{"file":"%s","triple":"%s"}]]#00' % (
-                lldbutil.append_to_process_working_directory(self, "a.out"),
+            'read packet: $jModulesInfo:[{"file":"%s","triple":"%s"}]]#00' % (module_path,
                 seven.unhexlify(info["triple"])),
             {"direction": "send",
              "regex": r'^\$\[{(.*)}\]\]#[0-9A-Fa-f]{2}',
              "capture": {1: "spec"}},
         ], True)
 
         context = self.expect_gdbremote_sequence()
         spec = context.get("spec")

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     @skipUnlessPlatform(["linux"])
     @llgs_test
     def test_qProcessInfo_contains_triple_llgs_linux(self):
         self.init_llgs_test()
         self.build()
         self.qProcessInfo_contains_keys(set(['triple']))
 
+    @skipUnlessPlatform(["windows"])
+    @llgs_test
+    def test_qProcessInfo_contains_triple_ppid_llgs_windows(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_contains_keys(set(['triple', 'parent-pid']))
+
     @skipUnlessDarwin
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qProcessInfo_does_not_contain_triple_debugserver_darwin(self):
         self.init_debugserver_test()
         self.build()
         # We don't expect to see triple on darwin.  If we do, we'll prefer triple
         # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
def test_qProcessInfo_does_not_contain_triple_llgs_darwin(self):
         self.qProcessInfo_does_not_contain_keys(set(['triple']))
 
     @skipUnlessPlatform(["linux"])
     @llgs_test
     def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_linux(self):
         self.init_llgs_test()
         self.build()
         self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))
+
+    @skipUnlessPlatform(["windows"])
+    @llgs_test
+    def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_windows(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteRegisterState.py

def grp_register_save_restore_works(self, with_suffix):
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=inferior_args)
 
         self.add_process_info_collection_packets()
         self.add_register_info_collection_packets()
         if with_suffix:
             self.add_thread_suffix_request_packets()
         self.add_threadinfo_collection_packets()
+
+        # Skip O* packet test for Windows. Will add it back when pty is supported.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-windows", triple):
+            self.test_sequence.add_log_lines([
+                # Start the inferior...
+                "read packet: $c#63"], True)
+        else:
             self.test_sequence.add_log_lines([
                 # Start the inferior...
                 "read packet: $c#63",
                 # ... match output....
                 {"type": "output_match", "regex": self.maybe_strict_output_regex(
                     r"message:main entered\r\n")},
         ], True)
+
         # ... then interrupt.
         self.add_interrupt_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Gather process info.
         process_info = self.parse_process_info_response(context)

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteSingleStep.py

class TestGdbRemoteSingleStep(gdbremote_testcase.GdbRemoteTestCaseBase):
     @debugserver_test
     def test_single_step_only_steps_one_instruction_with_s_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=True, step_instruction="s")
 
+    @skipIfWindows # No pty support to test any inferior std -i/e/o
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

class TestGdbRemoteThreadsInStopReply(
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_reports_multiple_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_multiple_threads(5)
 
+    # In current implementation of llgs on Windows, as a response to '\x03' packet, the debugger
+    # of the native process will trigger a call to DebugBreakProcess that will create a new thread
+    # to handle the exception debug event. So one more stop thread will be notified to the
+    # delegate, e.g. llgs.  So tests below to assert the stop threads number will all fail.
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_reports_multiple_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_multiple_threads(5)
 
     def no_QListThreadsInStopReply_supplies_no_threads(self, thread_count):
         # Gather threads from stop notification when QThreadsInStopReply is not
         # enabled.
         stop_reply_threads = self.gather_stop_reply_threads(None, thread_count)
         self.assertEqual(len(stop_reply_threads), 0)
 
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_no_QListThreadsInStopReply_supplies_no_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.no_QListThreadsInStopReply_supplies_no_threads(5)
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_no_QListThreadsInStopReply_supplies_no_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.no_QListThreadsInStopReply_supplies_no_threads(5)
 
     def stop_reply_reports_correct_threads(self, thread_count):
class TestGdbRemoteThreadsInStopReply(
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_reports_correct_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_correct_threads(5)
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_reports_correct_threads_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_reports_correct_threads(5)
 
     def stop_reply_contains_thread_pcs(self, thread_count):
         results = self.gather_stop_reply_pcs(
                 self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, thread_count)
         stop_reply_pcs = results["thread_pcs"]
         pc_register = results["pc_register"]
         little_endian = results["little_endian"]
         self.assertEqual(len(stop_reply_pcs), thread_count)
 
         threads_info_pcs = self.gather_threads_info_pcs(pc_register,
                 little_endian)
 
         self.assertEqual(len(threads_info_pcs), thread_count)
         for thread_id in stop_reply_pcs:
             self.assertTrue(thread_id in threads_info_pcs)
             self.assertTrue(int(stop_reply_pcs[thread_id], 16)
                     == int(threads_info_pcs[thread_id], 16))
 
+    @expectedFailureAll(oslist=["windows"])
     @llgs_test
     def test_stop_reply_contains_thread_pcs_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_contains_thread_pcs(5)
 
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     @debugserver_test
     def test_stop_reply_contains_thread_pcs_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_reply_contains_thread_pcs(5)

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
             ],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Wait until all threads have started.
         threads = self.wait_for_thread_count(thread_count, timeout_seconds=3)
         self.assertIsNotNone(threads)
+
+        # On Windows, there could be more threads spawned. For example, DebugBreakProcess will
+        # create a new thread from the debugged process to handle an exception event. So here we
+        # assert 'GreaterEqual' condition.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(len(threads), thread_count)
+        else:
             self.assertEqual(len(threads), thread_count)
 
         # Grab stop reply for each thread via qThreadStopInfo{tid:hex}.
         stop_replies = {}
         thread_dicts = {}
         for thread in threads:
             # Run the qThreadStopInfo command.
             self.reset_test_sequence()
             self.test_sequence.add_log_lines(
def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
 
             # Hang on to the key-val dictionary for the thread.
             thread_dicts[kv_thread_id] = kv_dict
 
         return (stop_replies, thread_dicts)
 
     def qThreadStopInfo_works_for_multiple_threads(self, thread_count):
         (stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        # Consider one more thread created by calling DebugBreakProcess.
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(len(stop_replies), thread_count)
+        else:
             self.assertEqual(len(stop_replies), thread_count)
 
     @debugserver_test
     def test_qThreadStopInfo_works_for_multiple_threads_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
 
def qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
         no_stop_reason_count = sum(
             1 for stop_reason in list(
                 stop_replies.values()) if stop_reason == 0)
         with_stop_reason_count = sum(
             1 for stop_reason in list(
                 stop_replies.values()) if stop_reason != 0)
 
         # All but one thread should report no stop reason.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+
+        # Consider one more thread created by calling DebugBreakProcess.
+        if re.match(".*-.*-windows", triple):
+            self.assertGreaterEqual(no_stop_reason_count, thread_count - 1)
+        else:
             self.assertEqual(no_stop_reason_count, thread_count - 1)
 
         # Only one thread should should indicate a stop reason.
         self.assertEqual(with_stop_reason_count, 1)
 
     @debugserver_test
     def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_debugserver(
             self):
         self.init_debugserver_test()
class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     @debugserver_test
     def test_qThreadStopInfo_has_valid_thread_names_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
 
     # test requires OS with set, equal thread names by default.
-    @skipUnlessPlatform(["linux"])
+    # Windows thread does not have name property, equal names as the process's by default.
+    @skipUnlessPlatform(["linux", "windows"])
     @llgs_test
     def test_qThreadStopInfo_has_valid_thread_names_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_vCont.py

class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=True, step_instruction="vCont;s")
 
+    @skipIfWindows # No pty support to test O* & I* notification packets.
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],
class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_single_step_only_steps_one_instruction_with_vCont_s_thread_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.single_step_only_steps_one_instruction(
             use_Hc_packet=False, step_instruction="vCont;s:{thread}")
 
+    @skipIfWindows # No pty support to test O* & I* notification packets.
     @llgs_test
     @expectedFailureAndroid(
         bugnumber="llvm.org/pr24739",
         archs=[
             "arm",
             "aarch64"])
     @expectedFailureAll(
         oslist=["linux"],

packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_inferior_print_exit_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.inferior_print_exit()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_inferior_print_exit_llgs(self):
         self.init_llgs_test()
         self.build()
         self.inferior_print_exit()
 
     def first_launch_stop_reply_thread_matches_first_qC(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_first_launch_stop_reply_thread_matches_first_qC_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.first_launch_stop_reply_thread_matches_first_qC()
 
+    #@expectedFailureAll(oslist=["windows"]) # No pty support to test any inferior output
     @llgs_test
     def test_first_launch_stop_reply_thread_matches_first_qC_llgs(self):
         self.init_llgs_test()
         self.build()
         self.first_launch_stop_reply_thread_matches_first_qC()
 
     def attach_commandline_continue_app_exits(self):
         procs = self.prep_debug_monitor_and_inferior()
def qRegisterInfo_contains_avx_registers(self):
 
         # Collect all generics found.
         register_sets = {
             reg_info['set']: 1 for reg_info in reg_infos if 'set' in reg_info}
         self.assertEqual(
             self.targetHasAVX(),
             "Advanced Vector Extensions" in register_sets)
 
+    @expectedFailureAll(oslist=["windows"]) # no avx for now.
     @llgs_test
     def test_qRegisterInfo_contains_avx_registers_llgs(self):
         self.init_llgs_test()
         self.build()
         self.qRegisterInfo_contains_avx_registers()
 
     def qThreadInfo_contains_thread(self):
         procs = self.prep_debug_monitor_and_inferior()
def Hg_switches_to_3_threads(self):
             inferior_args=["thread:new", "thread:new"])
 
         # Let the inferior process have a few moments to start up the thread
         # when launched.  (The launch scenario has no time to run, so threads
         # won't be there yet.)
         self.run_process_then_stop(run_seconds=1)
 
         # Wait at most x seconds for 3 threads to be present.
-        threads = self.wait_for_thread_count(3, timeout_seconds=5)
+        threads = self.wait_for_thread_count(4, timeout_seconds=5)
         self.assertEqual(len(threads), 3)
 
         # verify we can $H to each thead, and $qC matches the thread we set.
         for thread in threads:
             # Change to each thread, verify current thread id.
             self.reset_test_sequence()
             self.test_sequence.add_log_lines(
                 ["read packet: $Hg{0:x}#00".format(thread),  # Set current thread.
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_Hg_switches_to_3_threads_launch_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
+    #@expectedFailureAll(oslist=["windows"])
+    #skipIfWindows
     @llgs_test
     def test_Hg_switches_to_3_threads_launch_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_Hg_switches_to_3_threads_attach_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
+    @expectedFailureAll(oslist=["windows"]) # expecting one more thread
     @llgs_test
     def test_Hg_switches_to_3_threads_attach_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
     def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         # Darwin debugserver translates some signals like SIGSEGV into some gdb
         # expectations about fixed signal numbers.
         self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
 
+    @skipIfWindows # no SIGSEGV support
     @llgs_test
     def test_Hc_then_Csignal_signals_correct_thread_launch_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hc_then_Csignal_signals_correct_thread(
             lldbutil.get_signal_number('SIGSEGV'))
 
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_m_packet_reads_memory_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.m_packet_reads_memory()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_m_packet_reads_memory_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.m_packet_reads_memory()
 
     def qMemoryRegionInfo_is_supported(self):
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_code_address_as_executable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_code_address_as_executable_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_code_address_as_executable()
 
     def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):

     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
 

     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
def test_software_breakpoint_set_and_remove_work_debugserver(self):
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
         self.breakpoint_set_and_remove_work(want_hardware=False)
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_software_breakpoint_set_and_remove_work_llgs(self):
         self.init_llgs_test()
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:

     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_written_M_content_reads_back_correctly_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.written_M_content_reads_back_correctly()
 
+    @skipIfWindows # No pty support to test any inferior output
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_written_M_content_reads_back_correctly_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.written_M_content_reads_back_correctly()
 
def P_and_p_thread_suffix_work(self):
 
         # Run the process a bit so threads can start up, and collect register
         # info.
         context = self.run_process_then_stop(run_seconds=1)
         self.assertIsNotNone(context)
 
         # Wait for 3 threads to be present.
         threads = self.wait_for_thread_count(3, timeout_seconds=5)
-        self.assertEqual(len(threads), 3)
+        self.assertEqual(len(threads) - 1, 3)
 
         expected_reg_values = []
         register_increment = 1
         next_value = None
 
         # Set the same register in each of 3 threads to a different value.
         # Verify each one has the unique value.
         for thread in threads:

packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def get_stub_port_from_named_socket(self, read_timeout_seconds=5):
 
         return stub_port
 
     def init_llgs_test(self, use_named_pipe=True):
         if lldb.remote_platform:
             # Remote platforms don't support named pipe based port negotiation
             use_named_pipe = False
 
+            triple = self.dbg.GetSelectedPlatform().GetTriple()
+            if re.match(".*-.*-windows", triple):
+                self.skipTest("Remotely testing is not supported on Windows yet.")
+
             # Grab the ppid from /proc/[shell pid]/stat
             err, retcode, shell_stat = self.run_platform_command(
                 "cat /proc/$$/stat")
             self.assertTrue(
                 err.Success() and retcode == 0,
                 "Failed to read file /proc/$$/stat: %s, retcode: %d" %
                 (err.GetCString(),
                  retcode))
def init_llgs_test(self, use_named_pipe=True):
                  err.GetCString(),
                  retcode))
             exe = ls_output.split()[-1]
 
             # If the binary has been deleted, the link name has " (deleted)" appended.
             # Remove if it's there.
             self.debug_monitor_exe = re.sub(r' \(deleted\)$', '', exe)
         else:
+            # Need to figure out how to create a named pipe on Windows.
+            if platform.system() == 'Windows':
+                use_named_pipe = False
+
             self.debug_monitor_exe = get_lldb_server_exe()
             if not self.debug_monitor_exe:
                 self.skipTest("lldb-server exe not found")
 
         self.debug_monitor_extra_args = ["gdbserver"]
         self.setUpServerLogging(is_llgs=True)
 
         if use_named_pipe:
def connect_to_debug_monitor(self, attach_pid=None):
 
             # Attach to the stub and return a socket opened to it.
             self.sock = self.create_socket()
             return server
 
         # We're using a random port algorithm to try not to collide with other ports,
         # and retry a max # times.
         attempts = 0
-        MAX_ATTEMPTS = 20
+        MAX_ATTEMPTS = 1
 
         while attempts < MAX_ATTEMPTS:
             server = self.launch_debug_monitor(attach_pid=attach_pid)
 
             # Schedule debug monitor to be shut down during teardown.
             logger = self.logger
 
             def shutdown_debug_monitor():

packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

def process_is_running(pid, unknown_value=True):
     elif platform.system() in ['Darwin', 'Linux', 'FreeBSD', 'NetBSD']:
         # Build the list of running process ids
         output = subprocess.check_output(
             "ps ax | awk '{ print $1; }'", shell=True).decode("utf-8")
         text_process_ids = output.split('\n')[1:]
         # Convert text pids to ints
         process_ids = [int(text_pid)
                        for text_pid in text_process_ids if text_pid != '']
+    elif platform.system() == 'Windows':
+        output = subprocess.check_output(
+            "for /f \"tokens=2 delims=,\" %F in ('tasklist /nh /fi \"PID ne 0\" /fo csv') do @echo %~F", shell=True).decode("utf-8")
+        text_process_ids = output.split('\n')[1:]
+        process_ids = [int(text_pid)
+                       for text_pid in text_process_ids if text_pid != '']
     # elif {your_platform_here}:
     #   fill in process_ids as a list of int type process IDs running on
     #   the local system.
     else:
         # Don't know how to get list of running process IDs on this
         # OS, so return the "don't know" value.
         return unknown_value
 

packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 // 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 <cstdlib>
 #include <cstring>
 #include <errno.h>
 #include <inttypes.h>
 #include <memory>
+#if !defined(_WIN32)
 #include <pthread.h>
-#include <setjmp.h>
 #include <signal.h>
+#include <unistd.h>
+#endif
+#include <setjmp.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
 #include <vector>
 
 #if defined(__APPLE__)
 __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
 int pthread_threadid_np(pthread_t, __uint64_t *);
 #elif defined(__linux__)
 #include <sys/syscall.h>
 #elif defined(__NetBSD__)
 #include <lwp.h>
 #endif
 
+#if defined(_WIN32)
+#include <windows.h>
+
+typedef HANDLE pthread_t;
+typedef HANDLE pthread_mutex_t;
+
+static unsigned int sleep(unsigned int seconds) {
+  ::Sleep(seconds * 1000);
+  return 0;
+}
+
+static int pthread_mutex_lock(pthread_mutex_t *mutex) {
+  ::WaitForSingleObject(*mutex, INFINITE);
+  return 0;
+}
+
+static int pthread_mutex_unlock(pthread_mutex_t *mutex) {
+  ::ReleaseMutex(*mutex);
+  return 0;
+}
+
+#define PTHREAD_MUTEX_INITIALIZER ::CreateMutex(NULL, FALSE, NULL)
+#endif
+
 static const char *const RETVAL_PREFIX = "retval:";
 static const char *const SLEEP_PREFIX = "sleep:";
 static const char *const STDERR_PREFIX = "stderr:";
 static const char *const SET_MESSAGE_PREFIX = "set-message:";
 static const char *const PRINT_MESSAGE_COMMAND = "print-message:";
 static const char *const GET_DATA_ADDRESS_PREFIX = "get-data-address-hex:";
 static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-address-hex:";
 static const char *const GET_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:";

 static bool g_is_segfaulting = false;
 
 static char g_message[256];
 
 static volatile char g_c1 = '0';
 static volatile char g_c2 = '1';
 
 static void print_pid() {
+#if defined(_WIN32)
+  fprintf(stderr, "PID: %d\n", ::GetCurrentProcessId());
+#else
   fprintf(stderr, "PID: %d\n", getpid());
+#endif
 }
 
 static void print_thread_id() {
 // Put in the right magic here for your platform to spit out the thread id (tid)
 // that debugserver/lldb-gdbserver would see as a TID. Otherwise, let the else
 // clause print out the unsupported text so that the unit test knows to skip
 // verifying thread ids.
 #if defined(__APPLE__)
   __uint64_t tid = 0;
   pthread_threadid_np(pthread_self(), &tid);
   printf("%" PRIx64, tid);
 #elif defined(__linux__)
   // This is a call to gettid() via syscall.
   printf("%" PRIx64, static_cast<uint64_t>(syscall(__NR_gettid)));
 #elif defined(__NetBSD__)
   // Technically lwpid_t is 32-bit signed integer
   printf("%" PRIx64, static_cast<uint64_t>(_lwp_self()));
+#elif defined(_WIN32)
+  printf("%" PRIx64, static_cast<uint64_t>(::GetCurrentThreadId()));
 #else
   printf("{no-tid-support}");
 #endif
 }
 
 static void signal_handler(int signo) {
+#if defined(_WIN32)
+  // No signal support on Windows.
+#else
   const char *signal_name = nullptr;
   switch (signo) {
   case SIGUSR1:
     signal_name = "SIGUSR1";
     break;
   case SIGSEGV:
     signal_name = "SIGSEGV";
     break;
#else
   }
 
   // Reset the signal handler.
   sig_t sig_result = signal(signo, signal_handler);
   if (sig_result == SIG_ERR) {
     fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
     exit(1);
   }
+#endif
 }
 
 static void swap_chars() {
   g_c1 = '1';
   g_c2 = '0';
 
   g_c1 = '0';
   g_c2 = '1';
 }
 
 static void hello() {
   pthread_mutex_lock(&g_print_mutex);
   printf("hello, world\n");
   pthread_mutex_unlock(&g_print_mutex);
 }
 
+#if !defined(_WIN32)
 static void *thread_func(void *arg) {
+#else
+static DWORD thread_func(void *arg) {
+#endif
   static pthread_mutex_t s_thread_index_mutex = PTHREAD_MUTEX_INITIALIZER;
   static int s_thread_index = 1;
 
   pthread_mutex_lock(&s_thread_index_mutex);
   const int this_thread_index = s_thread_index++;
   pthread_mutex_unlock(&s_thread_index_mutex);
 
   if (g_print_thread_ids) {
if (g_threads_do_segfault) {
     pthread_mutex_unlock(&g_print_mutex);
   }
 
   int sleep_seconds_remaining = 60;
   while (sleep_seconds_remaining > 0) {
     sleep_seconds_remaining = sleep(sleep_seconds_remaining);
   }
 
+#if defined(_WIN32)
+  return 0;
+#else
   return nullptr;
+#endif
 }
 
 int main(int argc, char **argv) {
   lldb_enable_attach();
 
   std::vector<pthread_t> threads;
   std::unique_ptr<uint8_t[]> heap_array_up;
   int return_value = 0;
 
+#if !defined(_WIN32)
   // Set the signal handler.
   sig_t sig_result = signal(SIGALRM, signal_handler);
   if (sig_result == SIG_ERR) {
     fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
     exit(1);
   }
 
   sig_result = signal(SIGUSR1, signal_handler);
   if (sig_result == SIG_ERR) {
     fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
     exit(1);
   }
 
   sig_result = signal(SIGSEGV, signal_handler);
   if (sig_result == SIG_ERR) {
     fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
     exit(1);
   }
+#endif
 
   // Process command line args.
   for (int i = 1; i < argc; ++i) {
     if (std::strstr(argv[i], STDERR_PREFIX)) {
       // Treat remainder as text to go to stderr.
       fprintf(stderr, "%s\n", (argv[i] + strlen(STDERR_PREFIX)));
     } else if (std::strstr(argv[i], RETVAL_PREFIX)) {
       // Treat as the return value for the program.
if (std::strstr(argv[i], STDERR_PREFIX)) {
       }
       if (func_p)
         func_p();
     } else if (std::strstr(argv[i], THREAD_PREFIX)) {
       // Check if we're creating a new thread.
       if (std::strstr(argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) {
         // Create a new thread.
         pthread_t new_thread;
+#if !defined(_WIN32)
         const int err =
             ::pthread_create(&new_thread, nullptr, thread_func, nullptr);
         if (err) {
           fprintf(stderr, "pthread_create() failed with error code %d\n", err);
           exit(err);
         }
+#else
+        new_thread = ::CreateThread(NULL, 0, thread_func, nullptr, 0, nullptr);
+        if (new_thread == NULL) {
+          fprintf(stderr, "CreateThread() failed with error code %d\n",
+                  ::GetLastError());
+          exit(3);
+        }
+#endif
         threads.push_back(new_thread);
       } else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
                              THREAD_COMMAND_PRINT_IDS)) {
         // Turn on thread id announcing.
         g_print_thread_ids = true;
 
         // And announce us.
         pthread_mutex_lock(&g_print_mutex);
#endif
     } else if (std::strstr(argv[i], PRINT_PID_COMMAND)) {
         print_pid();
     } else {
       // Treat the argument as text for stdout.
       printf("%s\n", argv[i]);
     }
   }
 
+#if defined(_WIN32)
+  {
+    ::WaitForMultipleObjects(threads.size(), threads.data(), TRUE, INFINITE);
+    ::CloseHandle(g_print_mutex);
+    ::CloseHandle(g_jump_buffer_mutex);
+  }
+#else
   // If we launched any threads, join them
   for (std::vector<pthread_t>::iterator it = threads.begin();
        it != threads.end(); ++it) {
     void *thread_retval = nullptr;
     const int err = ::pthread_join(*it, &thread_retval);
     if (err != 0)
       fprintf(stderr, "pthread_join() failed with error code %d\n", err);
   }
+#endif
 
   return return_value;
 }

packages/Python/lldbsuite/test/tools/lldb-server/thread-name/TestGdbRemoteThreadName.py

def run_and_check_name(self, expected_name):
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         sigint = lldbutil.get_signal_number("SIGINT")
         self.assertEqual(sigint, int(context.get("signal"), 16))
         kv_dict = self.parse_key_val_dict(context.get("key_vals_text"))
         self.assertEqual(expected_name, kv_dict.get("name"))
 
+    @skipIfWindows # the test is not updated for Windows.
     @llgs_test
     def test(self):
         """ Make sure lldb-server can retrieve inferior thread name"""
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         procs = self.prep_debug_monitor_and_inferior()
 
         self.run_and_check_name("hello world")
         self.run_and_check_name("goodbye world")

source/Host/common/File.cpp

while (bytes_left > 0) {
         break;
     }
     return error;
   }
 #endif
 
   ssize_t bytes_read = -1;
   if (DescriptorIsValid()) {
-    bytes_read = llvm::sys::RetryAfterSignal(-1, ::read, m_descriptor, buf, num_bytes);
+    bytes_read =
+        llvm::sys::RetryAfterSignal(-1, ::read, m_descriptor, buf, num_bytes);
     if (bytes_read == -1) {
       error.SetErrorToErrno();
       num_bytes = 0;
     } else
       num_bytes = bytes_read;
   } else if (StreamIsValid()) {
     bytes_read = ::fread(buf, 1, num_bytes, m_stream);
 
if (num_bytes > MAX_WRITE_SIZE) {
     }
     return error;
   }
 #endif
 
   int fd = GetDescriptor();
   if (fd != kInvalidDescriptor) {
 #ifndef _WIN32
-    ssize_t bytes_written =
-        llvm::sys::RetryAfterSignal(-1, ::pwrite, m_descriptor, buf, num_bytes, offset);
+    ssize_t bytes_written = llvm::sys::RetryAfterSignal(
+        -1, ::pwrite, m_descriptor, buf, num_bytes, offset);
     if (bytes_written < 0) {
       num_bytes = 0;
       error.SetErrorToErrno();
     } else {
       offset += bytes_written;
       num_bytes = bytes_written;
     }
 #else
mode_t File::ConvertOpenOptionsForPOSIXOpen(uint32_t open_options) {
   if (open_options & eOpenOptionNonBlocking)
     mode |= O_NONBLOCK;
 
   if (open_options & eOpenOptionCanCreateNewOnly)
     mode |= O_CREAT | O_EXCL;
   else if (open_options & eOpenOptionCanCreate)
     mode |= O_CREAT;
 
+#ifdef _WIN32
+  mode |= O_BINARY;
+#endif
+
   return mode;
 }
 
 void File::CalculateInteractiveAndTerminal() {
   const int fd = GetDescriptor();
   if (fd >= 0) {
     m_is_interactive = eLazyBoolNo;
     m_is_real_terminal = eLazyBoolNo;

source/Host/common/Host.cpp

if (::dladdr(host_addr, &info)) {
     }
   }
 #endif
   return module_filespec;
 }
 
 #endif
 
-#if !defined(__linux__)
+#if !defined(__linux__) && !defined(_WIN32)
 bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
   return false;
 }
 #endif
 
 struct ShellInfo {
   ShellInfo()
       : process_reaped(false), pid(LLDB_INVALID_PROCESS_ID), signo(-1),

source/Host/common/Socket.cpp

 #ifdef __linux__
 #include "lldb/Host/linux/AbstractSocket.h"
 #endif
 
 #ifdef __ANDROID__
 #include <arpa/inet.h>
 #include <asm-generic/errno-base.h>
 #include <errno.h>
-#include <linux/tcp.h>
 #include <fcntl.h>
+#include <linux/tcp.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 #endif // __ANDROID__
 
 using namespace lldb;
 using namespace lldb_private;
 
 #if defined(_WIN32)

 
 bool IsInterrupted() {
 #if defined(_WIN32)
   return ::WSAGetLastError() == WSAEINTR;
 #else
   return errno == EINTR;
 #endif
 }
-}
+} // namespace
 
 Socket::Socket(SocketProtocol protocol, bool should_close,
                bool child_processes_inherit)
     : IOObject(eFDTypeSocket, should_close), m_protocol(protocol),
       m_socket(kInvalidSocketValue),
       m_child_processes_inherit(child_processes_inherit) {}
 
 Socket::~Socket() { Close(); }
 
 std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
                                        bool child_processes_inherit,
                                        Status &error) {
   error.Clear();
 
   std::unique_ptr<Socket> socket_up;
   switch (protocol) {
   case ProtocolTcp:
-    socket_up =
-        llvm::make_unique<TCPSocket>(true, child_processes_inherit);
+    socket_up = llvm::make_unique<TCPSocket>(true, child_processes_inherit);
     break;
   case ProtocolUdp:
-    socket_up =
-        llvm::make_unique<UDPSocket>(true, child_processes_inherit);
+    socket_up = llvm::make_unique<UDPSocket>(true, child_processes_inherit);
     break;
   case ProtocolUnixDomain:
 #ifndef LLDB_DISABLE_POSIX
-    socket_up =
-        llvm::make_unique<DomainSocket>(true, child_processes_inherit);
+    socket_up = llvm::make_unique<DomainSocket>(true, child_processes_inherit);
 #else
     error.SetErrorString(
         "Unix domain sockets are not supported on this platform.");
 #endif
     break;
   case ProtocolUnixAbstract:
 #ifdef __linux__
-    socket_up =
-        llvm::make_unique<AbstractSocket>(child_processes_inherit);
+    socket_up = llvm::make_unique<AbstractSocket>(child_processes_inherit);
 #else
     error.SetErrorString(
         "Abstract domain sockets are not supported on this platform.");
 #endif
     break;
   }
 
   if (error.Fail())

 #ifdef SOCK_CLOEXEC
   if (!child_processes_inherit)
     socket_type |= SOCK_CLOEXEC;
 #endif
   auto sock = ::socket(domain, socket_type, protocol);
   if (sock == kInvalidSocketValue)
     SetLastError(error);
 
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+  if (log) {
+    log->Printf(
+        "Socket::CreateSocket() (socket = %" PRIu64
+        ", domain = %i, type = %i, protocol = %i, child_processes_inherit = %i)"
+        " (error = %s)",
+        static_cast<uint64_t>(sock), domain, type, protocol,
+        child_processes_inherit, error.AsCString());
+  }
   return sock;
 }
 
 NativeSocket Socket::AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
                                   socklen_t *addrlen,
                                   bool child_processes_inherit, Status &error) {
   error.Clear();
 #if defined(ANDROID_USE_ACCEPT_WORKAROUND)

source/Host/common/SocketAddress.cpp

 //===-- SocketAddress.cpp ---------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Note: This file is used on Darwin by debugserver, so it needs to remain as
-//       self contained as possible, and devoid of references to LLVM unless 
+//       self contained as possible, and devoid of references to LLVM unless
 //       there is compelling reason.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER)
 #define _WINSOCK_DEPRECATED_NO_WARNINGS
 #endif
 
 #include "lldb/Host/SocketAddress.h"
 #include <stddef.h>
 #include <stdio.h>
 
 #if !defined(_WIN32)
 #include <arpa/inet.h>
 #endif
 
 #include <assert.h>
 #include <string.h>
 
 #include "lldb/Host/PosixApi.h"
+#include "lldb/Utility/Status.h"
 
 // WindowsXP needs an inet_ntop implementation
 #ifdef _WIN32
 
 #ifndef INET6_ADDRSTRLEN // might not be defined in older Windows SDKs
 #define INET6_ADDRSTRLEN 46
 #endif
 
SocketAddress::GetAddressInfo(const char *hostname, const char *servname,
 
   struct addrinfo *service_info_list = NULL;
   int err = ::getaddrinfo(hostname, servname, &hints, &service_info_list);
   if (err == 0 && service_info_list) {
     for (struct addrinfo *service_ptr = service_info_list; service_ptr != NULL;
          service_ptr = service_ptr->ai_next) {
       addr_list.emplace_back(SocketAddress(service_ptr));
     }
+  } else if (err) {
+    // Consume the error here.
+    Status error;
+#ifdef _WIN32
+    error.SetError(err, lldb::eErrorTypeWin32);
+#else
+    error.SetError(err, lldb::eErrorTypePOSIX);
+#endif
+    printf("SocketAddress::GetAddressInfo - %s\n", error.AsCString());
   }
 
   if (service_info_list)
     ::freeaddrinfo(service_info_list);
   return addr_list;
 }
 
 bool SocketAddress::SetToLocalhost(sa_family_t family, uint16_t port) {

source/Host/windows/Host.cpp

do {
 
       if (match_info.MatchAllProcesses() || match_info.Matches(process))
         process_infos.Append(process);
     } while (Process32NextW(snapshot.get(), &pe));
   }
   return process_infos.GetSize();
 }
 
+bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
+  AutoHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0));
+  if (!snapshot.IsValid())
+    return false;
+
+  size_t old_size = tids_to_attach.size();
+  THREADENTRY32 te;
+  te.dwSize = sizeof(THREADENTRY32);
+  if (Thread32First(snapshot.get(), &te)) {
+    do {
+      if (te.th32OwnerProcessID == pid) {
+        tids_to_attach[te.th32ThreadID] = false;
+      }
+    } while (Thread32Next(snapshot.get(), &te));
+  }
+
+  return tids_to_attach.size() - old_size;
+}
+
 bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) {
   process_info.Clear();
 
   AutoHandle handle(
       ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid),
       nullptr);
   if (!handle.IsValid())
     return false;
 
   process_info.SetProcessID(pid);
   GetProcessExecutableAndTriple(handle, process_info);
 
   // Need to read the PEB to get parent process and command line arguments.
+
+  AutoHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
+  if (!snapshot.IsValid())
+    return false;
+
+  PROCESSENTRY32W pe;
+  pe.dwSize = sizeof(PROCESSENTRY32W);
+  if (Process32FirstW(snapshot.get(), &pe)) {
+    do {
+      if (pe.th32ProcessID == pid) {
+        process_info.SetParentProcessID(pe.th32ParentProcessID);
         return true;
       }
+    } while (Process32NextW(snapshot.get(), &pe));
+  }
+
+  return false;
+}
 
 HostThread Host::StartMonitoringChildProcess(
     const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
     bool monitor_signals) {
   return HostThread();
 }
 
 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {

source/Host/windows/HostInfoWindows.cpp

 }
 
 bool HostInfoWindows::GetHostname(std::string &s) {
   wchar_t buffer[MAX_COMPUTERNAME_LENGTH + 1];
   DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
   if (!::GetComputerNameW(buffer, &dwSize))
     return false;
 
+  s.clear();
   return llvm::convertWideToUTF8(buffer, s);
 }
 
 FileSpec HostInfoWindows::GetProgramFileSpec() {
   static llvm::once_flag g_once_flag;
   llvm::call_once(g_once_flag, []() {
     std::vector<wchar_t> buffer(PATH_MAX);
     ::GetModuleFileNameW(NULL, buffer.data(), buffer.size());

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

private:
   coff_header_t m_coff_header;
   coff_opt_header_t m_coff_header_opt;
   SectionHeaderColl m_sect_headers;
   lldb::addr_t m_image_base;
   lldb_private::Address m_entry_point_address;
   llvm::Optional<lldb_private::FileSpecList> m_deps_filespec;
   typedef llvm::object::OwningBinary<llvm::object::Binary> OWNBINType;
   llvm::Optional<OWNBINType> m_owningbin;
+
+  lldb_private::UUID m_uuid;
 };
 
 #endif // liblldb_ObjectFilePECOFF_h_

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (ObjectFilePECOFF::MagicBytesMatch(data_sp)) {
     coff_header_t coff_header;
 
     if (ParseDOSHeader(data, dos_header)) {
       lldb::offset_t offset = dos_header.e_lfanew;
       uint32_t pe_signature = data.GetU32(&offset);
       if (pe_signature != IMAGE_NT_SIGNATURE)
         return false;
       if (ParseCOFFHeader(data, &offset, coff_header)) {
-        ArchSpec spec;
+        ModuleSpec module_spec(file);
+        ArchSpec &spec = module_spec.GetArchitecture();
+
+        lldb_private::UUID &uuid = module_spec.GetUUID();
+        if (!uuid.IsValid()) {
+          if (auto Result = llvm::sys::fs::md5_contents(file.GetPath()))
+            uuid =
+                UUID::fromOptionalData(llvm::ArrayRef<uint8_t>(Result->Bytes));
+        }
+
         if (coff_header.machine == MachineAmd64) {
           spec.SetTriple("x86_64-pc-windows");
-          specs.Append(ModuleSpec(file, spec));
+          specs.Append(module_spec);
         } else if (coff_header.machine == MachineX86) {
           spec.SetTriple("i386-pc-windows");
-          specs.Append(ModuleSpec(file, spec));
+          specs.Append(module_spec);
           spec.SetTriple("i686-pc-windows");
-          specs.Append(ModuleSpec(file, spec));
+          specs.Append(module_spec);
         } else if (coff_header.machine == MachineArmNt) {
           spec.SetTriple("arm-pc-windows");
-          specs.Append(ModuleSpec(file, spec));
+          specs.Append(module_spec);
         }
       }
     }
   }
 
   return specs.GetSize() - initial_count;
 }
 
for (uint32_t idx = 0; idx < nsects; ++idx) {
           m_coff_header_opt.sect_alignment, // Section alignment
           m_sect_headers[idx].flags));      // Flags for this section
 
       image_sp->GetChildren().AddSection(std::move(section_sp));
     }
   }
 }
 
-UUID ObjectFilePECOFF::GetUUID() { return UUID(); }
+UUID ObjectFilePECOFF::GetUUID() {
+  if (m_uuid.IsValid())
+    return m_uuid;
+
+  // Use the object content's MD5 as UUID
+  auto Result = llvm::sys::fs::md5_contents(GetFileSpec().GetPath());
+  if (!Result)
+    return UUID();
+
+  m_uuid = UUID::fromOptionalData(llvm::ArrayRef<uint8_t>(Result->Bytes));
+  return m_uuid;
+}
 
 uint32_t ObjectFilePECOFF::ParseDependentModules() {
   ModuleSP module_sp(GetModule());
   if (!module_sp)
     return 0;
 
   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
   if (m_deps_filespec)
if (!ParseHeader() || !IsExecutable())
     return m_entry_point_address;
 
   SectionList *section_list = GetSectionList();
   addr_t file_addr = m_coff_header_opt.entry + m_coff_header_opt.image_base;
 
   if (!section_list)
     m_entry_point_address.SetOffset(file_addr);
   else
-    m_entry_point_address.ResolveAddressUsingFileSections(file_addr, section_list);
+    m_entry_point_address.ResolveAddressUsingFileSections(file_addr,
+                                                          section_list);
   return m_entry_point_address;
 }
 
 Address ObjectFilePECOFF::GetBaseAddress() {
   return Address(GetSectionList()->GetSectionAtIndex(0), 0);
 }
 
 //----------------------------------------------------------------------

source/Plugins/Process/Utility/CMakeLists.txt

add_lldb_library(lldbPluginProcessUtility PLUGIN
   RegisterContextPOSIX_arm.cpp
   RegisterContextPOSIX_arm64.cpp
   RegisterContextPOSIX_mips64.cpp
   RegisterContextPOSIX_powerpc.cpp
   RegisterContextPOSIX_ppc64le.cpp
   RegisterContextPOSIX_s390x.cpp
   RegisterContextPOSIX_x86.cpp
   RegisterContextThreadMemory.cpp
+  RegisterContextWindows_x64.cpp
   RegisterInfoPOSIX_arm.cpp
   RegisterInfoPOSIX_arm64.cpp
   RegisterInfoPOSIX_ppc64le.cpp
   StopInfoMachException.cpp
   ThreadMemory.cpp
   UnwindLLDB.cpp
   UnwindMacOSXFrameBackchain.cpp
 

source/Plugins/Process/Utility/RegisterContextWindows_x64.h

+//===-- RegisterContextWindows_x64.h ---   ----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_RegisterContextWindows_x64_H_
+#define liblldb_RegisterContextWindows_x64_H_
+
+#include "RegisterInfoInterface.h"
+
+class RegisterContextWindows_x64 : public lldb_private::RegisterInfoInterface {
+public:
+  RegisterContextWindows_x64(const lldb_private::ArchSpec &target_arch);
+
+  size_t GetGPRSize() const override;
+
+  const lldb_private::RegisterInfo *GetRegisterInfo() const override;
+
+  uint32_t GetRegisterCount() const override;
+
+  uint32_t GetUserRegisterCount() const override;
+
+  const std::vector<lldb_private::RegisterInfo> *
+  GetDynamicRegisterInfoP() const override;
+
+private:
+  const lldb_private::RegisterInfo *m_register_info_p;
+  uint32_t m_register_info_count;
+  uint32_t m_user_register_count;
+  std::vector<lldb_private::RegisterInfo> d_register_infos;
+};
+
+#endif

source/Plugins/Process/Utility/RegisterContextWindows_x64.cpp

+//===-- RegisterContextWindows_x86_64.cpp ----------------------*- C++ -*-===//
+//
+// 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 "RegisterContextWindows_x64.h"
+#include "RegisterContext_x86.h"
+#include "lldb-x86-register-enums.h"
+
+#include <vector>
+
+using namespace lldb_private;
+using namespace lldb;
+
+// Declare our g_register_infos_x86_64 structure.
+typedef struct _GPR {
+  uint64_t r15;
+  uint64_t r14;
+  uint64_t r13;
+  uint64_t r12;
+  uint64_t rbp;
+  uint64_t rbx;
+  uint64_t r11;
+  uint64_t r10;
+  uint64_t r9;
+  uint64_t r8;
+  uint64_t rax;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rsi;
+  uint64_t rdi;
+  uint64_t rip;
+  uint64_t rflags;
+  uint64_t rsp;
+  uint64_t cs;
+  uint64_t ds;
+  uint64_t es;
+  uint64_t fs;
+  uint64_t gs;
+  uint64_t ss;
+} GPR;
+
+struct DBG {
+  uint64_t dr[8];
+};
+
+struct UserArea {
+  GPR gpr; // General purpose registers.
+  DBG dbg; // Debug registers.
+};
+
+#define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
+
+#define DR_OFFSET(reg_index)                                                   \
+  (LLVM_EXTENSION offsetof(UserArea, dbg) +                                    \
+   LLVM_EXTENSION offsetof(DBG, dr[reg_index]))
+
+#define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
+  {                                                                            \
+#reg, alt, sizeof(((GPR *)nullptr)->reg), GPR_OFFSET(reg), eEncodingUint,  \
+        eFormatHex,                                                            \
+        {kind1, kind2, kind3, kind4, lldb_##reg##_x86_64 }, nullptr, nullptr,  \
+         nullptr, 0                                                            \
+  }
+
+// clang-format off
+static RegisterInfo g_register_infos_x86_64[] = {
+// General purpose registers     EH_Frame              DWARF                 Generic                     Process Plugin
+//  ===========================  ==================    ================      =========================   ====================
+    DEFINE_GPR(rax,    nullptr,  dwarf_rax_x86_64,     dwarf_rax_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rbx,    nullptr,  dwarf_rbx_x86_64,     dwarf_rbx_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rcx,    "arg4",   dwarf_rcx_x86_64,     dwarf_rcx_x86_64,     LLDB_REGNUM_GENERIC_ARG4,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rdx,    "arg3",   dwarf_rdx_x86_64,     dwarf_rdx_x86_64,     LLDB_REGNUM_GENERIC_ARG3,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rdi,    "arg1",   dwarf_rdi_x86_64,     dwarf_rdi_x86_64,     LLDB_REGNUM_GENERIC_ARG1,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rsi,    "arg2",   dwarf_rsi_x86_64,     dwarf_rsi_x86_64,     LLDB_REGNUM_GENERIC_ARG2,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rbp,    "fp",     dwarf_rbp_x86_64,     dwarf_rbp_x86_64,     LLDB_REGNUM_GENERIC_FP,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rsp,    "sp",     dwarf_rsp_x86_64,     dwarf_rsp_x86_64,     LLDB_REGNUM_GENERIC_SP,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r8,     "arg5",   dwarf_r8_x86_64,      dwarf_r8_x86_64,      LLDB_REGNUM_GENERIC_ARG5,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r9,     "arg6",   dwarf_r9_x86_64,      dwarf_r9_x86_64,      LLDB_REGNUM_GENERIC_ARG6,   LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r10,    nullptr,  dwarf_r10_x86_64,     dwarf_r10_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r11,    nullptr,  dwarf_r11_x86_64,     dwarf_r11_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r12,    nullptr,  dwarf_r12_x86_64,     dwarf_r12_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r13,    nullptr,  dwarf_r13_x86_64,     dwarf_r13_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r14,    nullptr,  dwarf_r14_x86_64,     dwarf_r14_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(r15,    nullptr,  dwarf_r15_x86_64,     dwarf_r15_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rip,    "pc",     dwarf_rip_x86_64,     dwarf_rip_x86_64,     LLDB_REGNUM_GENERIC_PC,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(rflags, "flags",  dwarf_rflags_x86_64,  dwarf_rflags_x86_64,  LLDB_REGNUM_GENERIC_FLAGS,  LLDB_INVALID_REGNUM),
+    DEFINE_GPR(cs,     nullptr,  dwarf_cs_x86_64,      dwarf_cs_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(fs,     nullptr,  dwarf_fs_x86_64,      dwarf_fs_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(gs,     nullptr,  dwarf_gs_x86_64,      dwarf_gs_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ss,     nullptr,  dwarf_ss_x86_64,      dwarf_ss_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ds,     nullptr,  dwarf_ds_x86_64,      dwarf_ds_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(es,     nullptr,  dwarf_es_x86_64,      dwarf_es_x86_64,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+};
+
+static std::vector<lldb_private::RegisterInfo> &GetPrivateRegisterInfoVector() {
+  static std::vector<lldb_private::RegisterInfo> g_register_infos;
+  return g_register_infos;
+}
+#include <iostream>
+static const RegisterInfo *GetRegisterInfoPtr(const ArchSpec &target_arch) {
+  switch (target_arch.GetMachine()) {
+  case llvm::Triple::x86_64:
+    return g_register_infos_x86_64;
+  default:
+    assert(false && "Unhandled target architecture.");
+    return nullptr;
+  }
+}
+
+static uint32_t GetRegisterInfoCount(const ArchSpec &target_arch) {
+  switch (target_arch.GetMachine()) {
+  case llvm::Triple::x86_64:
+    return static_cast<uint32_t>(sizeof(g_register_infos_x86_64) /
+                                 sizeof(g_register_infos_x86_64[0]));
+  default:
+    assert(false && "Unhandled target architecture.");
+    return 0;
+  }
+}
+
+static uint32_t GetUserRegisterInfoCount(const ArchSpec &target_arch) {
+  switch (target_arch.GetMachine()) {
+  case llvm::Triple::x86_64:
+    return static_cast<uint32_t>(sizeof(g_register_infos_x86_64) /
+                                 sizeof(g_register_infos_x86_64[0]));
+  default:
+    assert(false && "Unhandled target architecture.");
+    return 0;
+  }
+}
+
+RegisterContextWindows_x64::RegisterContextWindows_x64(
+    const ArchSpec &target_arch)
+    : lldb_private::RegisterInfoInterface(target_arch),
+      m_register_info_p(GetRegisterInfoPtr(target_arch)),
+      m_register_info_count(GetRegisterInfoCount(target_arch)),
+      m_user_register_count(GetUserRegisterInfoCount(target_arch)) {
+
+}
+
+size_t RegisterContextWindows_x64::GetGPRSize() const { return sizeof(GPR); }
+
+const std::vector<lldb_private::RegisterInfo> *
+RegisterContextWindows_x64::GetDynamicRegisterInfoP() const {
+  return &d_register_infos;
+}
+
+const RegisterInfo *RegisterContextWindows_x64::GetRegisterInfo() const {
+  return m_register_info_p;
+}
+
+uint32_t RegisterContextWindows_x64::GetRegisterCount() const {
+  return m_register_info_count;
+}
+
+uint32_t RegisterContextWindows_x64::GetUserRegisterCount() const {
+  return m_user_register_count;
+}

source/Plugins/Process/Windows/Common/CMakeLists.txt

 set(PROC_WINDOWS_COMMON_SOURCES
   DebuggerThread.cpp
   LocalDebugDelegate.cpp
+  NativeProcessWindows.cpp
+  NativeRegisterContextWindows.cpp
+  NativeRegisterContextWindows_x64.cpp
+  NativeThreadWindows.cpp
+  ProcessDebugger.cpp
   ProcessWindows.cpp
   ProcessWindowsLog.cpp
   RegisterContextWindows.cpp
   TargetThreadWindows.cpp
   )
 
 if (CMAKE_SIZEOF_VOID_P EQUAL 4)
   set(PROC_WINDOWS_COMMON_SOURCES ${PROC_WINDOWS_COMMON_SOURCES}

source/Plugins/Process/Windows/Common/NativeProcessWindows.h

+//===-- NativeProcessWindows.h ----------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_NativeProcessWindows_h_
+#define liblldb_NativeProcessWindows_h_
+
+#include "lldb/Host/common/NativeProcessProtocol.h"
+#include "lldb/lldb-forward.h"
+#include "llvm/Support/Mutex.h"
+
+#include "IDebugDelegate.h"
+#include "ProcessDebugger.h"
+
+namespace lldb_private {
+
+class HostProcess;
+class ProcessWindowsData;
+class NativeProcessWindows;
+class NativeThreadWindows;
+class NativeDebugDelegate;
+
+typedef std::shared_ptr<NativeDebugDelegate> NativeDebugDelegateSP;
+
+//------------------------------------------------------------------
+// NativeProcessWindows
+//------------------------------------------------------------------
+class NativeProcessWindows : public NativeProcessProtocol,
+                             public ProcessDebugger {
+
+public:
+  class Factory : public NativeProcessProtocol::Factory {
+  public:
+    llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
+    Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
+           MainLoop &mainloop) const override;
+
+    llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
+    Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
+           MainLoop &mainloop) const override;
+  };
+
+  Status DoLaunch(ProcessLaunchInfo &launch_info);
+
+  Status DoAttachToProcessWithID(lldb::pid_t pid,
+                                 const ProcessAttachInfo &attach_info);
+
+  Status Resume(const ResumeActionList &resume_actions) override;
+
+  Status Halt() override;
+
+  Status Detach() override;
+
+  Status Signal(int signo) override;
+
+  Status Interrupt() override;
+
+  Status Kill() override;
+
+  Status IgnoreSignals(llvm::ArrayRef<int> signals) override;
+
+  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+                             MemoryRegionInfo &range_info) override;
+
+  Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    size_t &bytes_read) override;
+
+  Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
+                     size_t &bytes_written) override;
+
+  Status AllocateMemory(size_t size, uint32_t permissions,
+                        lldb::addr_t &addr) override;
+
+  Status DeallocateMemory(lldb::addr_t addr) override;
+
+  lldb::addr_t GetSharedLibraryInfoAddress() override;
+
+  bool IsAlive() const override;
+
+  size_t UpdateThreads() override;
+
+  const ArchSpec &GetArchitecture() const override { return m_arch; }
+
+  void SetArchitecture(const ArchSpec &arch_spec) { m_arch = arch_spec; }
+
+  Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
+                       bool hardware) override;
+
+  Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
+
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+  GetAuxvData() const override;
+
+  Status GetLoadedModuleFileSpec(const char *module_path,
+                                 FileSpec &file_spec) override;
+
+  Status GetFileLoadAddress(const llvm::StringRef &file_name,
+                            lldb::addr_t &load_addr) override;
+
+  // Overrides
+  void OnExitProcess(uint32_t exit_code) override;
+  void OnDebuggerConnected(lldb::addr_t image_base) override;
+  ExceptionResult OnDebugException(bool first_chance,
+                                   const ExceptionRecord &record) override;
+  void OnCreateThread(const HostThread &thread) override;
+  void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
+
+protected:
+  NativeThreadWindows *GetThreadByID(lldb::tid_t thread_id);
+
+  bool FindSoftwarepoint(lldb::addr_t addr);
+
+  void StopThread(lldb::tid_t thread_id, lldb::StopReason reason,
+                  std::string description = "");
+  void SetStopReasonForThread(NativeThreadWindows &thread,
+                              lldb::StopReason reason,
+                              std::string description = "");
+  void RefreshStateAfterStop();
+
+private:
+  ArchSpec m_arch;
+  NativeProcessWindows(lldb::pid_t pid, int terminal_fd,
+                       NativeDelegate &delegate, const ArchSpec &arch);
+};
+
+//------------------------------------------------------------------
+// NativeDebugDelegate
+//------------------------------------------------------------------
+class NativeDebugDelegate : public IDebugDelegate {
+public:
+  NativeDebugDelegate(NativeProcessWindows *process) : m_process(process) {}
+
+  void OnExitProcess(uint32_t exit_code) {
+    if (m_process)
+      m_process->OnExitProcess(exit_code);
+  }
+
+  void OnDebuggerConnected(lldb::addr_t image_base) {
+    if (m_process)
+      m_process->OnDebuggerConnected(image_base);
+  }
+
+  ExceptionResult OnDebugException(bool first_chance,
+                                   const ExceptionRecord &record) {
+    if (m_process)
+      return m_process->OnDebugException(first_chance, record);
+    return ExceptionResult::MaskException;
+  }
+
+  void OnCreateThread(const HostThread &thread) {
+    if (m_process)
+      m_process->OnCreateThread(thread);
+  }
+
+  void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {
+    if (m_process)
+      m_process->OnExitThread(thread_id, exit_code);
+  }
+
+  void OnLoadDll(const lldb_private::ModuleSpec &module_spec,
+                 lldb::addr_t module_addr) {
+    if (m_process)
+      m_process->OnLoadDll(module_spec, module_addr);
+  }
+
+  void OnUnloadDll(lldb::addr_t module_addr) {
+    if (m_process)
+      m_process->OnUnloadDll(module_addr);
+  }
+
+  void OnDebugString(const std::string &string) {
+    if (m_process)
+      m_process->OnDebugString(string);
+  }
+
+  void OnDebuggerError(const Status &error, uint32_t type) {
+    if (m_process)
+      return m_process->OnDebuggerError(error, type);
+  }
+
+private:
+  NativeProcessWindows *m_process;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef liblldb_NativeProcessWindows_h_

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

+//===-- NativeProcessWindows.cpp --------------------------------*- C++ -*-===//
+//
+// 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 "lldb/Host/windows/windows.h"
+#include <psapi.h>
+
+#include "NativeProcessWindows.h"
+#include "NativeThreadWindows.h"
+
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostNativeProcessBase.h"
+#include "lldb/Host/HostProcess.h"
+#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Host/windows/AutoHandle.h"
+#include "lldb/Host/windows/HostThreadWindows.h"
+#include "lldb/Host/windows/ProcessLauncherWindows.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Process.h"
+#include "llvm/Support/Error.h"
+
+#include "lldb/Utility/State.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/Threading.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "DebuggerThread.h"
+#include "ExceptionRecord.h"
+#include "ProcessWindowsLog.h"
+
+// Windows includes
+#include <iostream>
+#include <tlhelp32.h>
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+namespace {
+Status GetProcessBaseAddress(lldb::pid_t pid, lldb::addr_t &base_addr) {
+  Status error;
+  base_addr = LLDB_INVALID_ADDRESS;
+
+  AutoHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid));
+  if (snapshot.IsValid()) {
+    MODULEENTRY32W me;
+    me.dwSize = sizeof(MODULEENTRY32W);
+    if (Module32FirstW(snapshot.get(), &me)) {
+      // The first module is always the EXE or DLL itself.
+      base_addr = (addr_t)me.modBaseAddr;
+      return Status();
+    }
+  }
+
+  error.SetError(::GetLastError(), lldb::ErrorType::eErrorTypeWin32);
+  return error;
+}
+} // namespace
+
+namespace lldb_private {
+#if 1
+class ProcessWindowsData {
+public:
+  ProcessWindowsData(bool stop_at_entry) : m_stop_at_entry(stop_at_entry) {
+    m_initial_stop_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
+  }
+
+  ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); }
+
+  Status m_launch_error;
+  DebuggerThreadSP m_debugger;
+  StopInfoSP m_pending_stop_info;
+  HANDLE m_initial_stop_event = nullptr;
+  bool m_initial_stop_received = false;
+  bool m_stop_at_entry;
+  std::map<lldb::tid_t, HostThread> m_new_threads;
+  std::set<lldb::tid_t> m_exited_threads;
+};
+#endif
+
+NativeProcessWindows::NativeProcessWindows(lldb::pid_t pid, int terminal_fd,
+                                           NativeDelegate &delegate,
+                                           const ArchSpec &arch)
+    : NativeProcessProtocol(pid, terminal_fd, delegate), ProcessDebugger(),
+      m_arch(arch) {}
+
+Status NativeProcessWindows::Resume(const ResumeActionList &resume_actions) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  Status error;
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  StateType state = GetState();
+
+  // Python vcont_s test allows single step into a running process.
+  if (1) {//state == eStateStopped || state == eStateCrashed) {
+    LLDB_LOG(log, "process {0} is in state {1}.  Resuming...",
+             GetDebuggedProcess().GetProcessId(), state);
+
+    ExceptionRecordSP active_exception =
+        GetDebuggerThread()->GetActiveException().lock();
+    if (active_exception) {
+      // Resume the process and continue processing debug events.  Mask the
+      // exception so that from the process's view, there is no indication that
+      // anything happened.
+      GetDebuggerThread()->ContinueAsyncException(
+          ExceptionResult::MaskException);
+    }
+
+    LLDB_LOG(log, "resuming {0} threads.", m_threads.size());
+
+    bool failed = false;
+    for (uint32_t i = 0; i < m_threads.size(); ++i) {
+      auto thread = static_cast<NativeThreadWindows *>(m_threads[i].get());
+      const ResumeAction *const action =
+          resume_actions.GetActionForThread(thread->GetID(), true);
+      if (action == nullptr) {
+        LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
+                 thread->GetID());
+        continue;
+      }
+      LLDB_LOG(log, "processing resume action state {0} for pid {1} tid {2}",
+               action->state, GetID(), thread->GetID());
+
+      switch (action->state) {
+      case eStateRunning:
+      case eStateStepping: {
+        Status result = thread->DoResume(action->state);
+        if (result.Fail()) {
+          failed = true;
+          LLDB_LOG(log,
+                   "Trying to resume thread at index {0}, but failed with "
+                   "error {1}.",
+                   i, result);
+        }
+        break;
+      }
+      case eStateSuspended:
+      case eStateStopped:
+        llvm_unreachable("Unexpected state");
+
+      default:
+        return Status(
+            "NativeProcessLinux::%s (): unexpected state %s specified "
+            "for pid %" PRIu64 ", tid %" PRIu64,
+            __FUNCTION__, StateAsCString(action->state), GetID(),
+            thread->GetID());
+      }
+    }
+
+    if (failed) {
+      error.SetErrorString("ProcessWindows::DoResume failed");
+      return error;
+    } else {
+      SetState(eStateRunning);
+    }
+  } else {
+    LLDB_LOG(log, "error: process {0} is in state {1}.  Returning...",
+             GetDebuggedProcess().GetProcessId(), GetState());
+  }
+
+  return error;
+}
+
+NativeThreadWindows *
+NativeProcessWindows::GetThreadByID(lldb::tid_t thread_id) {
+  return static_cast<NativeThreadWindows *>(
+      NativeProcessProtocol::GetThreadByID(thread_id));
+}
+
+Status NativeProcessWindows::Halt() {
+  bool caused_stop = false;
+  StateType state = GetState();
+  if (state != eStateStopped)
+    return HaltProcess(caused_stop);
+  return Status();
+}
+
+Status NativeProcessWindows::Detach() {
+  Status error;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  StateType state = GetState();
+  if (state != eStateExited && state != eStateDetached) {
+    error = DetachProcess();
+    if (error.Success())
+      SetState(eStateDetached);
+  } else {
+    error.SetErrorStringWithFormat(
+        "error: process {0} in state = {1}, but cannot destroy in this state.",
+        GetID(), state);
+    LLDB_LOG(log, "error: {0}", error);
+  }
+  return error;
+}
+
+Status NativeProcessWindows::Signal(int signo) {
+  Status error;
+  error.SetErrorString("Windows does not support sending signals to processes");
+  return error;
+}
+
+Status NativeProcessWindows::Interrupt() { return Halt(); }
+
+Status NativeProcessWindows::Kill() {
+  Status error;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  StateType state = GetState();
+  if (state != eStateExited && state != eStateDetached)
+    return DestroyProcess();
+  else {
+    error.SetErrorStringWithFormat(
+        "cannot destroy process {0} while state = {1}", GetID(), state);
+    LLDB_LOG(log, "error: {0}", error);
+  }
+  return error;
+}
+
+Status NativeProcessWindows::IgnoreSignals(llvm::ArrayRef<int> signals) {
+  return Status();
+}
+
+Status NativeProcessWindows::GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                                 MemoryRegionInfo &range_info) {
+  return ProcessDebugger::GetMemoryRegionInfo(load_addr, range_info);
+}
+
+Status NativeProcessWindows::ReadMemory(lldb::addr_t addr, void *buf,
+                                        size_t size, size_t &bytes_read) {
+  return ProcessDebugger::ReadMemory(addr, buf, size, bytes_read);
+}
+
+Status NativeProcessWindows::WriteMemory(lldb::addr_t addr, const void *buf,
+                                         size_t size, size_t &bytes_written) {
+  return ProcessDebugger::WriteMemory(addr, buf, size, bytes_written);
+}
+
+Status NativeProcessWindows::AllocateMemory(size_t size, uint32_t permissions,
+                                            lldb::addr_t &addr) {
+  return ProcessDebugger::AllocateMemory(size, permissions, addr);
+}
+
+Status NativeProcessWindows::DeallocateMemory(lldb::addr_t addr) {
+  return ProcessDebugger::DeallocateMemory(addr);
+}
+
+lldb::addr_t NativeProcessWindows::GetSharedLibraryInfoAddress() { return 0; }
+
+bool NativeProcessWindows::IsAlive() const {
+  StateType state = GetState();
+  switch (state) {
+  case eStateCrashed:
+  case eStateDetached:
+  case eStateExited:
+  case eStateInvalid:
+  case eStateUnloaded:
+    return false;
+  default:
+    return true;
+  }
+}
+
+void NativeProcessWindows::SetStopReasonForThread(NativeThreadWindows &thread,
+                                                  lldb::StopReason reason,
+                                                  std::string description) {
+  SetCurrentThreadID(thread.GetID());
+
+  ThreadStopInfo stop_info;
+  stop_info.reason = reason;
+
+  // No signal support on Windows but required to provide a 'valid' signum.
+  if (reason == StopReason::eStopReasonException) {
+    stop_info.details.exception.type = 0;
+    stop_info.details.exception.data_count = 0;
+  } else
+    stop_info.details.signal.signo = SIGTRAP;
+  thread.SetStopReason(stop_info, description);
+}
+
+void NativeProcessWindows::StopThread(lldb::tid_t thread_id,
+                                      lldb::StopReason reason,
+                                      std::string description) {
+  NativeThreadWindows *thread = GetThreadByID(thread_id);
+  if (!thread)
+    return;
+
+  for (uint32_t i = 0; i < m_threads.size(); ++i) {
+    auto t = static_cast<NativeThreadWindows *>(m_threads[i].get());
+    Status error = t->DoStop();
+    if (error.Fail())
+      exit(1);
+  }
+  SetStopReasonForThread(*thread, reason, description);
+}
+
+size_t NativeProcessWindows::UpdateThreads() { return m_threads.size(); }
+
+llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
+NativeProcessWindows::GetAuxvData() const {
+  return nullptr;
+}
+
+bool NativeProcessWindows::FindSoftwarepoint(lldb::addr_t addr) {
+  auto it = m_software_breakpoints.find(addr);
+  if (it == m_software_breakpoints.end())
+    return false;
+  return true;
+}
+
+Status NativeProcessWindows::SetBreakpoint(lldb::addr_t addr, uint32_t size,
+                                           bool hardware) {
+  if (hardware)
+    return SetHardwareBreakpoint(addr, size);
+  return SetSoftwareBreakpoint(addr, size);
+}
+
+Status NativeProcessWindows::RemoveBreakpoint(lldb::addr_t addr,
+                                              bool hardware) {
+  if (hardware)
+    return RemoveHardwareBreakpoint(addr);
+  return RemoveSoftwareBreakpoint(addr);
+}
+
+Status NativeProcessWindows::GetLoadedModuleFileSpec(const char *module_path,
+                                                     FileSpec &file_spec) {
+  FileSpec module_file_spec(module_path);
+  FileSystem::Instance().Resolve(module_file_spec);
+  return Status();
+}
+
+Status
+NativeProcessWindows::GetFileLoadAddress(const llvm::StringRef &file_name,
+                                         lldb::addr_t &load_addr) {
+  return GetProcessBaseAddress(m_pid, load_addr);
+}
+
+void NativeProcessWindows::OnExitProcess(uint32_t exit_code) {
+  // No need to acquire the lock since m_session_data isn't accessed.
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  LLDB_LOG(log, "Process {0} exited with code {1}", GetID(), exit_code);
+
+  ProcessDebugger::OnExitProcess(exit_code);
+
+  // No signal involved.  It is just an exit event.
+  WaitStatus wait_status(WaitStatus::Exit, exit_code);
+  SetExitStatus(wait_status, true);
+
+  // Notify the native delegate.
+  SetState(eStateExited);
+}
+
+void NativeProcessWindows::OnDebuggerConnected(lldb::addr_t image_base) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  LLDB_LOG(log, "Debugger connected to process {0}. Image base = {1:x}",
+           GetDebuggedProcess().GetProcessId(), image_base);
+
+  // This is the only chance we can resolve the process ID and architecutre if
+  // we don't know them yet.
+  if (GetID() == LLDB_INVALID_PROCESS_ID)
+    SetID(GetDebuggedProcess().GetProcessId());
+
+  if (GetArchitecture().GetMachine() == llvm::Triple::UnknownArch) {
+    ProcessInstanceInfo process_info;
+    if (!Host::GetProcessInfo(GetDebuggedProcess().GetProcessId(),
+                              process_info)) {
+      LLDB_LOG(log, "Cannot get process information during debugger connecting "
+                    "to process");
+      return;
+    }
+    SetArchitecture(process_info.GetArchitecture());
+  }
+
+  // The very first one shall always be the matin thread.  If the process is
+  // redebugged, the threads record shall have been clear.
+  assert(m_threads.empty());
+  m_threads.push_back(
+      llvm::make_unique<NativeThreadWindows>(*this, GetMainThread()));
+}
+
+ExceptionResult
+NativeProcessWindows::OnDebugException(bool first_chance,
+                                       const ExceptionRecord &record) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EXCEPTION);
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  ProcessDebugger::OnDebugException(first_chance, record);
+
+  static bool initial_stop = false;
+
+  if (!first_chance) {
+    SetState(eStateStopped, false);
+  }
+
+  ExceptionResult result = ExceptionResult::SendToApplication;
+  switch (record.GetExceptionCode()) {
+  case EXCEPTION_SINGLE_STEP:
+    result = ExceptionResult::BreakInDebugger;
+    StopThread(record.GetThreadID(), StopReason::eStopReasonTrace);
+    SetState(eStateStopped, true);
+    return ExceptionResult::MaskException;
+    break;
+
+  case EXCEPTION_BREAKPOINT:
+    result = ExceptionResult::BreakInDebugger;
+
+    if (FindSoftwarepoint(record.GetExceptionAddress())) {
+      LLDB_LOG(log, "Hit non-loader breakpoint at address {0:x}.",
+               record.GetExceptionAddress());
+
+      StopThread(record.GetThreadID(), StopReason::eStopReasonBreakpoint);
+
+      if (NativeThreadWindows *stop_thread =
+              GetThreadByID(record.GetThreadID())) {
+        auto &register_context = stop_thread->GetRegisterContext();
+        // The current EIP is AFTER the BP opcode, which is one byte.
+        uint64_t pc = register_context.GetPC() - 1;
+        register_context.SetPC(pc);
+      }
+      SetState(eStateStopped, true);
+
+      // The application already stops. Continue the debugger.
+      return ExceptionResult::MaskException;
+    }
+
+    if (!initial_stop) {
+      initial_stop = true;
+      LLDB_LOG(
+          log,
+          "Hit loader breakpoint at address {0:x}, setting initial stop event.",
+          record.GetExceptionAddress());
+
+      // We are required to report the reason for the first stop after
+      // launching or being attached.
+      if (NativeThreadWindows *thread = GetThreadByID(record.GetThreadID()))
+        SetStopReasonForThread(*thread, StopReason::eStopReasonBreakpoint);
+
+      // Do not notify the native delegate (e.g. llgs) since at this moment
+      // the program hasn't returned from Factory::Launch() and the delegate
+      // might not have an valid native process to operate on.
+      SetState(eStateStopped, false);
+
+      // Let application run.
+      return ExceptionResult::BreakInDebugger;
+    }
+
+    LLDB_LOG(log,
+             "Debugger thread reported exception {0:x} at address {1:x} "
+             "(first_chance={2})",
+             record.GetExceptionCode(), record.GetExceptionAddress(),
+             first_chance);
+
+    {
+      std::string desc;
+      llvm::raw_string_ostream desc_stream(desc);
+      desc_stream << "Exception "
+                  << llvm::format_hex(record.GetExceptionCode(), 8)
+                  << " encountered at address "
+                  << llvm::format_hex(record.GetExceptionAddress(), 8);
+
+      StopThread(record.GetThreadID(), StopReason::eStopReasonException,
+                 desc_stream.str().c_str());
+
+      SetState(eStateStopped, true);
+
+      // let application handle the exception.
+      return ExceptionResult::BreakInDebugger;
+    }
+
+    break;
+
+  default:
+    LLDB_LOG(log,
+             "Debugger thread reported exception {0:x} at address {1:x} "
+             "(first_chance={2})",
+             record.GetExceptionCode(), record.GetExceptionAddress(),
+             first_chance);
+
+    // Can't control process state unless it is the first chance exception
+    if (!first_chance) {
+      std::string desc;
+      llvm::raw_string_ostream desc_stream(desc);
+      desc_stream << "Exception "
+                  << llvm::format_hex(record.GetExceptionCode(), 8)
+                  << " encountered at address "
+                  << llvm::format_hex(record.GetExceptionAddress(), 8);
+      StopThread(record.GetThreadID(), StopReason::eStopReasonException,
+                 desc_stream.str().c_str());
+
+      SetState(eStateStopped, true);
+    }
+
+    // For non-breakpoints, give the application a chance to handle the
+    // exception first.
+    if (first_chance)
+      result = ExceptionResult::SendToApplication;
+    else
+      result = ExceptionResult::BreakInDebugger;
+  }
+
+  return result;
+}
+
+void NativeProcessWindows::OnCreateThread(const HostThread &new_thread) {
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  m_threads.push_back(
+      llvm::make_unique<NativeThreadWindows>(*this, new_thread));
+}
+
+void NativeProcessWindows::OnExitThread(lldb::tid_t thread_id,
+                                        uint32_t exit_code) {
+  llvm::sys::ScopedLock lock(m_mutex);
+  NativeThreadWindows *thread = GetThreadByID(thread_id);
+  if (!thread)
+    return;
+
+  for (auto t = m_threads.begin(); t != m_threads.end(); ++t) {
+    if ((*t)->GetID() == thread_id) {
+      static_cast<NativeThreadWindows *>((*t).get())->DoDestroy();
+      t = m_threads.erase(t);
+    } else {
+      ++t;
+    }
+  }
+}
+
+Status NativeProcessWindows::DoLaunch(ProcessLaunchInfo &launch_info) {
+  DebugDelegateSP delegate(new NativeDebugDelegate(this));
+  return LaunchProcess(launch_info, delegate);
+}
+
+Status NativeProcessWindows::DoAttachToProcessWithID(
+    lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
+  DebugDelegateSP delegate(new NativeDebugDelegate(this));
+  Status error = AttachProcess(pid, attach_info, delegate);
+  if (error.Success())
+    SetID(GetDebuggedProcess().GetProcessId());
+  return error;
+}
+
+llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
+NativeProcessWindows::Factory::Launch(
+    ProcessLaunchInfo &launch_info,
+    NativeProcessProtocol::NativeDelegate &native_delegate,
+    MainLoop &mainloop) const {
+
+  // The process id and process architecture will be updated upon successfully
+  // launching.
+  std::unique_ptr<NativeProcessWindows> process_up(new NativeProcessWindows(
+      LLDB_INVALID_PROCESS_ID,
+      launch_info.GetPTY().ReleaseMasterFileDescriptor(), native_delegate,
+      launch_info.GetArchitecture()));
+
+  Status error = process_up->DoLaunch(launch_info);
+  if (error.Fail())
+    return error.ToError();
+
+  return std::move(process_up);
+}
+
+llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
+NativeProcessWindows::Factory::Attach(
+    lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate,
+    MainLoop &mainloop) const {
+  Status error;
+  // Query the process architecture to ensure that we could have a valid
+  // register context later.
+  ProcessInstanceInfo process_info;
+  if (!Host::GetProcessInfo(pid, process_info)) {
+    error.SetErrorString("Cannot get process information");
+    return error.ToError();
+  }
+
+  ProcessAttachInfo attach_info;
+  attach_info.SetProcessID(pid);
+  attach_info.SetArchitecture(process_info.GetArchitecture());
+
+  // Set pty master fd invalid since we can query from nowhere.
+  std::unique_ptr<NativeProcessWindows> process_up(new NativeProcessWindows(
+      pid, -1, native_delegate, process_info.GetArchitecture()));
+
+  error = process_up->DoAttachToProcessWithID(pid, attach_info);
+  if (error.Fail())
+    return error.ToError();
+
+  return std::move(process_up);
+}
+} // namespace lldb_private

source/Plugins/Process/Windows/Common/NativeRegisterContextWindows.h

+//===-- NativeRegisterContextWindows.h --------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_NativeRegisterContextWindows_h_
+#define liblldb_NativeRegisterContextWindows_h_
+
+#include "Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h"
+#include "lldb/Host/common/NativeThreadProtocol.h"
+
+namespace lldb_private {
+
+class NativeThreadWindows;
+
+class NativeRegisterContextWindows : public NativeRegisterContextRegisterInfo {
+public:
+  NativeRegisterContextWindows::NativeRegisterContextWindows(
+      NativeThreadProtocol &native_thread,
+      RegisterInfoInterface *reg_info_interface_p);
+
+  static std::unique_ptr<NativeRegisterContextWindows>
+  CreateHostNativeRegisterContextWindows(const ArchSpec &target_arch,
+                                         NativeThreadProtocol &native_thread);
+
+protected:
+  virtual Status ReadGPR();
+
+  virtual Status WriteGPR();
+
+  virtual Status ReadFPR();
+
+  virtual Status WriteFPR();
+
+  virtual Status ReadDBR();
+  virtual Status WriteDBR();
+
+  virtual void *GetGPRBuffer() { return nullptr; }
+
+  virtual size_t GetGPRSize() {
+    return GetRegisterInfoInterface().GetGPRSize();
+  }
+
+  virtual void *GetFPRBuffer() { return nullptr; }
+
+  virtual size_t GetFPRSize() { return 0; }
+#if 0
+  // The Do*** functions are executed on the privileged thread and can perform
+  // ptrace
+  // operations directly.
+  virtual Status DoReadRegisterValue(uint32_t offset, const char *reg_name,
+                                     uint32_t size, RegisterValue &value);
+
+  virtual Status DoWriteRegisterValue(uint32_t offset, const char *reg_name,
+                                      const RegisterValue &value);
+#endif
+  virtual Status DoReadGPR(void *buf, size_t buf_size);
+
+  virtual Status DoWriteGPR(void *buf, size_t buf_size);
+
+  virtual Status DoReadFPR(void *buf, size_t buf_size);
+
+  virtual Status DoWriteFPR(void *buf, size_t buf_size);
+
+  virtual Status DoReadDBR(void *buf, size_t buf_size);
+  virtual Status DoWriteDBR(void *buf, size_t buf_size);
+
+private:
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_h_

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

+//===-- NativeRegisterContextWindows.cpp ------------------------*- C++ -*-===//
+//
+// 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 "lldb/Host/HostThread.h"
+#include "lldb/Host/Windows/HostThreadWindows.h"
+#include "lldb/Host/windows/windows.h"
+#include "lldb/Utility/Log.h"
+
+#include "NativeRegisterContextWindows.h"
+#include "NativeThreadWindows.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+NativeRegisterContextWindows::NativeRegisterContextWindows(
+    NativeThreadProtocol &thread, RegisterInfoInterface *reg_info_interface_p)
+    : NativeRegisterContextRegisterInfo(thread, reg_info_interface_p) {}
+
+Status NativeRegisterContextWindows::ReadGPR() {
+  void *buf = GetGPRBuffer();
+  if (!buf)
+    return Status("GPR buffer is NULL");
+  size_t buf_size = GetGPRSize();
+  return DoReadGPR(buf, buf_size);
+}
+
+Status NativeRegisterContextWindows::WriteGPR() {
+  void *buf = GetGPRBuffer();
+  if (!buf)
+    return Status("GPR buffer is NULL");
+  size_t buf_size = GetGPRSize();
+  return DoWriteGPR(buf, buf_size);
+}
+
+Status NativeRegisterContextWindows::ReadFPR() {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::WriteFPR() {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::ReadDBR() {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::WriteDBR() {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::DoReadGPR(void *buf, size_t size) {
+  return Status("umplemented");
+}
+
+Status NativeRegisterContextWindows::DoWriteGPR(void *buf, size_t size) {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::DoReadFPR(void *buf, size_t size) {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::DoWriteFPR(void *buf, size_t size) {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::DoReadDBR(void *buf, size_t size) {
+  return Status("Unimplemented");
+}
+
+Status NativeRegisterContextWindows::DoWriteDBR(void *buf, size_t size) {
+  return Status("Unimplemented");
+}

source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x64.h

+//===-- NativeRegisterContextWindows_x64.h ----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_WIN64)
+#ifndef liblldb_NativeRegisterContextWindows_x64_h_
+#define liblldb_NativeRegisterContextWindows_x64_h_
+
+#include "Plugins/Process/Utility/RegisterContext_x86.h"
+#include "Plugins/Process/Utility/lldb-x86-register-enums.h"
+
+#include "NativeRegisterContextWindows.h"
+
+namespace lldb_private {
+
+class NativeThreadWindows;
+
+class NativeRegisterContextWindows_x64 : public NativeRegisterContextWindows {
+public:
+  NativeRegisterContextWindows_x64(const ArchSpec &target_arch,
+                                   NativeThreadProtocol &native_thread);
+
+  uint32_t GetRegisterSetCount() const override;
+
+  const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
+
+  Status ReadRegister(const RegisterInfo *reg_info,
+                      RegisterValue &reg_value) override;
+
+  Status WriteRegister(const RegisterInfo *reg_info,
+                       const RegisterValue &reg_value) override;
+
+  Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+  Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+  Status IsWatchpointHit(uint32_t wp_index, bool &is_hit) override;
+
+  Status GetWatchpointHitIndex(uint32_t &wp_index,
+                               lldb::addr_t trap_addr) override;
+
+  Status IsWatchpointVacant(uint32_t wp_index, bool &is_vacant) override;
+
+  bool ClearHardwareWatchpoint(uint32_t wp_index) override;
+
+  Status ClearAllHardwareWatchpoints() override;
+
+  Status SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size,
+                                        uint32_t watch_flags,
+                                        uint32_t wp_index);
+
+  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
+                                 uint32_t watch_flags) override;
+
+  lldb::addr_t GetWatchpointAddress(uint32_t wp_index) override;
+
+  uint32_t NumSupportedHardwareWatchpoints() override;
+
+protected:
+  void *GetGPRBuffer() override { return &m_gpr_x86_64; }
+
+private:
+  enum { GPRegSet };
+
+  uint64_t m_gpr_x86_64[k_first_alias_x86_64 - k_first_gpr_x86_64 + 1];
+  bool IsGPR(uint32_t reg_index) const;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_x64_h_
+#endif // defined(_WIN64)

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

+//===-- NativeRegisterContextWindows_x64.cpp --------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_WIN64)
+
+#include "NativeRegisterContextWindows_x64.h"
+
+#include "NativeThreadWindows.h"
+#include "Plugins/Process/Utility/RegisterContextWindows_x64.h"
+#include "ProcessWindowsLog.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/HostThread.h"
+#include "lldb/Host/Windows/HostThreadWindows.h"
+#include "lldb/Host/windows/windows.h"
+#include "lldb/Utility/DataBufferHeap.h"
+
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static const uint32_t g_gpr_regnums_x86_64[] = {
+    lldb_rax_x86_64,    lldb_rbx_x86_64,    lldb_rcx_x86_64, lldb_rdx_x86_64,
+    lldb_rdi_x86_64,    lldb_rsi_x86_64,    lldb_rbp_x86_64, lldb_rsp_x86_64,
+    lldb_r8_x86_64,     lldb_r9_x86_64,     lldb_r10_x86_64, lldb_r11_x86_64,
+    lldb_r12_x86_64,    lldb_r13_x86_64,    lldb_r14_x86_64, lldb_r15_x86_64,
+    lldb_rip_x86_64,    lldb_rflags_x86_64, lldb_cs_x86_64,  lldb_fs_x86_64,
+    lldb_gs_x86_64,     lldb_ss_x86_64,     lldb_ds_x86_64,  lldb_es_x86_64,
+    LLDB_INVALID_REGNUM // Register sets must be terminated with
+                        // LLDB_INVALID_REGNUM.
+};
+
+static const RegisterSet g_reg_sets_x86_64[] = {
+    {"General Purpose Registers", "gpr",
+     llvm::array_lengthof(g_gpr_regnums_x86_64) - 1, g_gpr_regnums_x86_64},
+};
+size_t k_num_register_sets = llvm::array_lengthof(g_gpr_regnums_x86_64);
+
+#define REG_CONTEXT_SIZE sizeof(::CONTEXT)
+
+std::unique_ptr<NativeRegisterContextWindows>
+NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return llvm::make_unique<NativeRegisterContextWindows_x64>(target_arch,
+                                                             native_thread);
+}
+
+static RegisterInfoInterface *
+CreateRegisterInfoInterface(const ArchSpec &target_arch) {
+  assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
+         "Register setting path assumes this is a 64-bit host");
+  return new RegisterContextWindows_x64(target_arch);
+}
+
+NativeRegisterContextWindows_x64::NativeRegisterContextWindows_x64(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextWindows(native_thread,
+                                   CreateRegisterInfoInterface(target_arch)) {}
+
+bool NativeRegisterContextWindows_x64::IsGPR(uint32_t reg_index) const {
+  return (reg_index < k_first_alias_x86_64);
+}
+
+uint32_t NativeRegisterContextWindows_x64::GetRegisterSetCount() const {
+  return llvm::array_lengthof(g_reg_sets_x86_64);
+}
+
+const RegisterSet *
+NativeRegisterContextWindows_x64::GetRegisterSet(uint32_t set_index) const {
+  if (set_index >= k_num_register_sets)
+    return nullptr;
+  return &g_reg_sets_x86_64[set_index];
+}
+
+const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
+Status
+NativeRegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info,
+                                               RegisterValue &reg_value) {
+  Status error;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+  if (reg == LLDB_INVALID_REGNUM) {
+    // This is likely an internal register for lldb use only and should not be
+    // directly queried.
+    error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
+                                   "register, cannot read directly",
+                                   reg_info->name);
+    return error;
+  }
+
+  if (!IsGPR(reg))
+    return Status("unimplemented");
+
+#if 0
+  error = ReadGPR();
+  if (error.Fail())
+    return error;
+#endif
+
+  ::CONTEXT tls_context;
+  NativeThreadWindows *wthread = static_cast<NativeThreadWindows *>(&m_thread);
+  auto host_thread = wthread->GetHostThread();
+  memset(&tls_context, 0, sizeof(tls_context));
+  tls_context.ContextFlags = kWinContextFlags;
+  if (!::GetThreadContext(host_thread.GetNativeThread().GetSystemHandle(),
+                          &tls_context)) {
+    LLDB_LOG(
+        log,
+        "GetThreadContext failed with error {0} while caching register values.",
+        ::GetLastError());
+    return Status("error");
+  }
+  LLDB_LOG(log, "successfully updated the register values.");
+
+  switch (reg) {
+  case lldb_rax_x86_64:
+    reg_value = (uint64_t)tls_context.Rax;
+    break;
+  case lldb_rbx_x86_64:
+    reg_value = (uint64_t)tls_context.Rbx;
+    break;
+  case lldb_rcx_x86_64:
+    reg_value = (uint64_t)tls_context.Rcx;
+    break;
+  case lldb_rdx_x86_64:
+    reg_value = (uint64_t)tls_context.Rdx;
+    break;
+  case lldb_rdi_x86_64:
+    reg_value = (uint64_t)tls_context.Rdi;
+    break;
+  case lldb_rsi_x86_64:
+    reg_value = (uint64_t)tls_context.Rsi;
+    break;
+  case lldb_rbp_x86_64:
+    reg_value = (uint64_t)tls_context.Rbp;
+    break;
+  case lldb_rsp_x86_64:
+    reg_value = (uint64_t)tls_context.Rsp;
+    break;
+  case lldb_r8_x86_64:
+    reg_value = (uint64_t)tls_context.R8;
+    break;
+  case lldb_r9_x86_64:
+    reg_value = (uint64_t)tls_context.R9;
+    break;
+  case lldb_r10_x86_64:
+    reg_value = (uint64_t)tls_context.R10;
+    break;
+  case lldb_r11_x86_64:
+    reg_value = (uint64_t)tls_context.R11;
+    break;
+  case lldb_r12_x86_64:
+    reg_value = (uint64_t)tls_context.R12;
+    break;
+  case lldb_r13_x86_64:
+    reg_value = (uint64_t)tls_context.R13;
+    break;
+  case lldb_r14_x86_64:
+    reg_value = (uint64_t)tls_context.R14;
+    break;
+  case lldb_r15_x86_64:
+    reg_value = (uint64_t)tls_context.R15;
+    break;
+  case lldb_rip_x86_64:
+    reg_value = (uint64_t)tls_context.Rip;
+    break;
+  case lldb_rflags_x86_64:
+    reg_value.SetUInt32(tls_context.EFlags | 0x2); // Bit #1 alwyas 1
+    break;
+  case lldb_cs_x86_64:
+    reg_value.SetUInt16(tls_context.SegCs);
+    break;
+  case lldb_fs_x86_64:
+    reg_value.SetUInt16(tls_context.SegFs);
+    break;
+  case lldb_gs_x86_64:
+    reg_value.SetUInt16(tls_context.SegGs);
+    break;
+  case lldb_ss_x86_64:
+    reg_value.SetUInt16(tls_context.SegSs);
+    break;
+  case lldb_ds_x86_64:
+    reg_value.SetUInt16(tls_context.SegDs);
+    break;
+  case lldb_es_x86_64:
+    reg_value.SetUInt16(tls_context.SegEs);
+    break;
+  }
+
+  return error;
+}
+
+Status NativeRegisterContextWindows_x64::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+  if (reg == LLDB_INVALID_REGNUM) {
+    // This is likely an internal register for lldb use only and should not be
+    // directly queried.
+    error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
+                                   "register, cannot read directly",
+                                   reg_info->name);
+    return error;
+  }
+
+  if (!IsGPR(reg))
+    return Status("unimplemented");
+
+  CONTEXT tls_context;
+  NativeThreadWindows *wthread = static_cast<NativeThreadWindows *>(&m_thread);
+  auto host_thread = wthread->GetHostThread();
+  memset(&tls_context, 0, sizeof(tls_context));
+  tls_context.ContextFlags = kWinContextFlags;
+  if (!::GetThreadContext(host_thread.GetNativeThread().GetSystemHandle(),
+                          &tls_context)) {
+    LLDB_LOG(
+        log,
+        "GetThreadContext failed with error {0} while caching register values.",
+        ::GetLastError());
+    return Status("error");
+  }
+  LLDB_LOG(log, "successfully updated the register values.");
+
+  switch (reg) {
+  case lldb_rax_x86_64:
+    tls_context.Rax = reg_value.GetAsUInt64();
+    break;
+  case lldb_rbx_x86_64:
+    tls_context.Rbx = reg_value.GetAsUInt64();
+    break;
+  case lldb_rcx_x86_64:
+    tls_context.Rcx = reg_value.GetAsUInt64();
+    break;
+  case lldb_rdx_x86_64:
+    tls_context.Rdx = reg_value.GetAsUInt64();
+    break;
+  case lldb_rdi_x86_64:
+    tls_context.Rdi = reg_value.GetAsUInt64();
+    break;
+  case lldb_rsi_x86_64:
+    tls_context.Rsi = reg_value.GetAsUInt64();
+    break;
+  case lldb_rbp_x86_64:
+    tls_context.Rbp = reg_value.GetAsUInt64();
+    break;
+  case lldb_rsp_x86_64:
+    tls_context.Rsp = reg_value.GetAsUInt64();
+    break;
+  case lldb_r8_x86_64:
+    tls_context.R8 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r9_x86_64:
+    tls_context.R9 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r10_x86_64:
+    tls_context.R10 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r11_x86_64:
+    tls_context.R11 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r12_x86_64:
+    tls_context.R12 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r13_x86_64:
+    tls_context.R13 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r14_x86_64:
+    tls_context.R14 = reg_value.GetAsUInt64();
+    break;
+  case lldb_r15_x86_64:
+    tls_context.R15 = reg_value.GetAsUInt64();
+    break;
+  case lldb_rip_x86_64:
+    tls_context.Rip = reg_value.GetAsUInt64();
+    break;
+  case lldb_rflags_x86_64:
+    tls_context.EFlags = reg_value.GetAsUInt32();
+    break;
+  case lldb_cs_x86_64:
+    tls_context.SegCs = reg_value.GetAsUInt16();
+    break;
+  case lldb_fs_x86_64:
+    tls_context.SegFs = reg_value.GetAsUInt16();
+    break;
+  case lldb_gs_x86_64:
+    tls_context.SegGs = reg_value.GetAsUInt16();
+    break;
+  case lldb_ss_x86_64:
+    tls_context.SegSs = reg_value.GetAsUInt16();
+    break;
+  case lldb_ds_x86_64:
+    tls_context.SegDs = reg_value.GetAsUInt16();
+    break;
+  case lldb_es_x86_64:
+    tls_context.SegEs = reg_value.GetAsUInt16();
+    break;
+  }
+
+  bool success = ::SetThreadContext(
+      host_thread.GetNativeThread().GetSystemHandle(), &tls_context);
+
+  if (success)
+    return Status();
+
+  return Status("error");
+}
+
+Status NativeRegisterContextWindows_x64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "failed to allocate DataBufferHeap instance of size %" PRIu64,
+        REG_CONTEXT_SIZE);
+    return error;
+  }
+
+  CONTEXT tls_context;
+  NativeThreadWindows *wthread = static_cast<NativeThreadWindows *>(&m_thread);
+  auto host_thread = wthread->GetHostThread();
+  memset(&tls_context, 0, sizeof(tls_context));
+  tls_context.ContextFlags = kWinContextFlags;
+  if (!::GetThreadContext(host_thread.GetNativeThread().GetSystemHandle(),
+                          &tls_context)) {
+    LLDB_LOG(
+        log,
+        "GetThreadContext failed with error {0} while caching register values.",
+        ::GetLastError());
+    return Status("error");
+  }
+  LLDB_LOG(log, "successfully updated the register values.");
+
+  uint8_t *dst = data_sp->GetBytes();
+  if (dst == nullptr) {
+    error.SetErrorStringWithFormat("DataBufferHeap instance of size %" PRIu64
+                                   " returned a null pointer",
+                                   REG_CONTEXT_SIZE);
+    return error;
+  }
+
+  ::memcpy(dst, &tls_context, REG_CONTEXT_SIZE);
+  return error;
+
+}
+
+Status NativeRegisterContextWindows_x64::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  //Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextWindows_64::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != REG_CONTEXT_SIZE) {
+    error.SetErrorStringWithFormatv(
+        "data_sp contained mismatched data size, expected {0}, actual {1}",
+        REG_CONTEXT_SIZE, data_sp->GetByteSize());
+    return error;
+  }
+
+  uint8_t *src = data_sp->GetBytes();
+  if (src == nullptr) {
+    error.SetErrorStringWithFormat("NativeRegisterContextWindows_64::%s "
+                                   "DataBuffer::GetBytes() returned a null "
+                                   "pointer",
+                                   __FUNCTION__);
+    return error;
+  }
+  ::CONTEXT tls_context;
+  memcpy(&tls_context, data_sp->GetBytes(), REG_CONTEXT_SIZE);
+
+  NativeThreadWindows *wthread = static_cast<NativeThreadWindows *>(&m_thread);
+  auto host_thread = wthread->GetHostThread();
+  if (!::SetThreadContext(host_thread.GetNativeThread().GetSystemHandle(),
+                          &tls_context))
+    return Status("error");
+
+  return error;
+}
+
+Status NativeRegisterContextWindows_x64::IsWatchpointHit(uint32_t wp_index,
+                                                         bool &is_hit) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x64::GetWatchpointHitIndex(
+    uint32_t &wp_index, lldb::addr_t trap_addr) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x64::IsWatchpointVacant(uint32_t wp_index,
+                                                            bool &is_vacant) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x64::SetHardwareWatchpointWithIndex(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
+  return Status("unimplemented");
+}
+
+bool NativeRegisterContextWindows_x64::ClearHardwareWatchpoint(
+    uint32_t wp_index) {
+  return false;
+}
+
+Status NativeRegisterContextWindows_x64::ClearAllHardwareWatchpoints() {
+  return Status("unimplemented");
+}
+
+uint32_t NativeRegisterContextWindows_x64::SetHardwareWatchpoint(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags) {
+  return LLDB_INVALID_INDEX32;
+}
+
+lldb::addr_t
+NativeRegisterContextWindows_x64::GetWatchpointAddress(uint32_t wp_index) {
+  return LLDB_INVALID_ADDRESS;
+}
+
+uint32_t NativeRegisterContextWindows_x64::NumSupportedHardwareWatchpoints() {
+  // Not implemented
+  return 0;
+}
+
+#endif // defined(_WIN64)

source/Plugins/Process/Windows/Common/NativeThreadWindows.h

+//===-- NativeThreadWindows.h -----------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_NativeThreadWindows_h_
+#define liblldb_NativeThreadWindows_h_
+
+#include "lldb/Host/HostThread.h"
+#include "lldb/Host/common/NativeThreadProtocol.h"
+#include "lldb/lldb-private-forward.h"
+
+#include "NativeRegisterContextWindows.h"
+
+namespace lldb_private {
+
+class NativeProcessWindows;
+
+class NativeThreadWindows : public NativeThreadProtocol {
+public:
+  NativeThreadWindows(NativeProcessWindows &process, const HostThread &thread);
+
+  ~NativeThreadWindows() {}
+
+  Status DoStop();
+  Status DoResume(lldb::StateType resume_state);
+  Status DoDestroy();
+
+  std::string GetName() override;
+
+  lldb::StateType GetState() override { return m_state; }
+
+  NativeRegisterContextWindows &GetRegisterContext() override {
+    return *m_reg_context_up;
+  }
+
+  bool GetStopReason(ThreadStopInfo &stop_info,
+                     std::string &description) override;
+
+  Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
+                       bool hardware) override;
+
+  Status RemoveWatchpoint(lldb::addr_t addr) override;
+
+  Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
+
+  Status RemoveHardwareBreakpoint(lldb::addr_t addr) override;
+
+  void SetStopReason(ThreadStopInfo stop_info, std::string description);
+
+  const HostThread &GetHostThread() { return m_host_thread; }
+
+protected:
+  lldb::StateType m_state = lldb::StateType::eStateInvalid;
+  std::string m_name;
+  ThreadStopInfo m_stop_info;
+  std::string m_stop_description;
+  std::unique_ptr<NativeRegisterContextWindows> m_reg_context_up;
+  // Cache address and index of the watchpoints and hardware breakpoints since
+  // the register context does not.
+  using IndexMap = std::map<lldb::addr_t, uint32_t>;
+  IndexMap m_watchpoint_index_map;
+  IndexMap m_hw_breakpoint_index_map;
+  HostThread m_host_thread;
+};
+} // namespace lldb_private
+
+#endif // #ifndef liblldb_NativeThreadWindows_h_

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

+//===-- NativeThreadWindows.cpp ---------------------------------*- C++ -*-===//
+//
+// 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 "NativeThreadWindows.h"
+#include "NativeProcessWindows.h"
+
+#include "lldb/Host/HostThread.h"
+#include "lldb/Host/Windows/HostThreadWindows.h"
+#include "lldb/Host/windows/windows.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/State.h"
+
+#include "lldb/lldb-forward.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+NativeThreadWindows::NativeThreadWindows(NativeProcessWindows &process,
+                                         const HostThread &thread)
+    : NativeThreadProtocol(process, thread.GetNativeThread().GetThreadId()),
+      m_stop_info(), m_stop_description(), m_host_thread(thread) {
+  m_reg_context_up =
+      (NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
+          process.GetArchitecture(), *this));
+}
+
+Status NativeThreadWindows::DoStop() {
+  if (m_state != eStateStopped) {
+    DWORD previous_suspend_count = ::SuspendThread(
+        m_host_thread.GetNativeThread().GetSystemHandle());
+    if (previous_suspend_count == (DWORD) -1)
+      return Status(::GetLastError(), eErrorTypeWin32);
+
+    m_state = eStateStopped;
+  }
+  return Status();
+}
+
+Status NativeThreadWindows::DoResume(lldb::StateType resume_state) {
+  StateType current_state = GetState();
+  if (resume_state == current_state)
+    return Status();
+
+  if (resume_state == eStateStepping) {
+    uint32_t flags_index =
+        GetRegisterContext().ConvertRegisterKindToRegisterNumber(
+            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+    uint64_t flags_value =
+        GetRegisterContext().ReadRegisterAsUnsigned(flags_index, 0);
+    flags_value |= 0x100; // Set the trap flag on the CPU
+    GetRegisterContext().WriteRegisterFromUnsigned(flags_index, flags_value);
+  }
+
+  if (resume_state == eStateStepping || resume_state == eStateRunning) {
+    DWORD previous_suspend_count = 0;
+    HANDLE thread_handle = m_host_thread.GetNativeThread().GetSystemHandle();
+    do {
+      // ResumeThread returns -1 on error, or the thread's *previous* suspend
+      // count on success. This means that the return value is 1 when the thread
+      // was restarted. Note that DWORD is an unsigned int, so we need to
+      // explicitly compare with -1.
+      previous_suspend_count = ::ResumeThread(thread_handle);
+
+      if (previous_suspend_count == (DWORD)-1)
+        return Status(::GetLastError(), eErrorTypeWin32);
+
+    } while (previous_suspend_count > 1);
+    m_state = eStateRunning;
+  }
+
+  return Status();
+}
+
+Status NativeThreadWindows::DoDestroy() {
+  m_state = eStateExited;
+  m_stop_info.reason = StopReason::eStopReasonThreadExiting;
+  return Status();
+}
+
+std::string NativeThreadWindows::GetName() {
+  if (!m_name.empty())
+    return m_name;
+
+  // Name is not a property of the Windows thread. Create one with the process's.
+  NativeProcessProtocol &process = GetProcess();
+  ProcessInstanceInfo process_info;
+  if (Host::GetProcessInfo(process.GetID(), process_info)) {
+    std::string process_name(process_info.GetName());
+    m_name = process_name;
+  }
+  return m_name;
+}
+
+void NativeThreadWindows::SetStopReason(ThreadStopInfo stop_info,
+                                        std::string description) {
+  m_state = eStateStopped;
+  m_stop_info = stop_info;
+  m_stop_description = description;
+}
+
+bool NativeThreadWindows::GetStopReason(ThreadStopInfo &stop_info,
+                                        std::string &description) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
+
+  switch (m_state) {
+  case eStateStopped:
+  case eStateCrashed:
+  case eStateExited:
+  case eStateSuspended:
+  case eStateUnloaded:
+    stop_info = m_stop_info;
+    description = m_stop_description;
+    return true;
+
+  case eStateInvalid:
+  case eStateConnected:
+  case eStateAttaching:
+  case eStateLaunching:
+  case eStateRunning:
+  case eStateStepping:
+  case eStateDetached:
+    if (log) {
+      log->Printf("NativeThreadWindows::%s tid %" PRIu64
+                  " in state %s cannot answer stop reason",
+                  __FUNCTION__, GetID(), StateAsCString(m_state));
+    }
+    return false;
+  }
+  llvm_unreachable("unhandled StateType!");
+}
+
+Status NativeThreadWindows::SetWatchpoint(lldb::addr_t addr, size_t size,
+                                          uint32_t watch_flags, bool hardware) {
+  if (!hardware)
+    return Status("not implemented");
+
+  if (m_state == eStateLaunching)
+    return Status();
+  Status error = RemoveWatchpoint(addr);
+  if (error.Fail())
+    return error;
+
+  uint32_t index =
+      m_reg_context_up->SetHardwareWatchpoint(addr, size, watch_flags);
+  if (index == LLDB_INVALID_INDEX32)
+    return Status("Setting hardware watchpoint failed.");
+
+  m_watchpoint_index_map.insert({addr, index});
+  return Status();
+}
+
+Status NativeThreadWindows::RemoveWatchpoint(lldb::addr_t addr) {
+  auto it = m_watchpoint_index_map.find(addr);
+  if (it == m_watchpoint_index_map.end())
+    return Status();
+
+  uint32_t index = it->second;
+  m_watchpoint_index_map.erase(it);
+  if (m_reg_context_up->ClearHardwareWatchpoint(index))
+    return Status();
+
+  return Status("Remove watchpoint failed.");
+}
+
+Status NativeThreadWindows::SetHardwareBreakpoint(lldb::addr_t addr,
+                                                  size_t size) {
+  if (m_state == eStateLaunching)
+    return Status();
+
+  Status error = RemoveHardwareBreakpoint(addr);
+  if (error.Fail())
+    return error;
+
+  uint32_t index = m_reg_context_up->SetHardwareBreakpoint(addr, size);
+  if (index == LLDB_INVALID_INDEX32)
+    return Status("Setting hardware breakpoint failed.");
+
+  m_hw_breakpoint_index_map.insert({addr, index});
+  return Status();
+}
+
+Status NativeThreadWindows::RemoveHardwareBreakpoint(lldb::addr_t addr) {
+  auto it = m_hw_breakpoint_index_map.find(addr);
+  if (it == m_hw_breakpoint_index_map.end())
+    return Status();
+
+  uint32_t index = it->second;
+  m_watchpoint_index_map.erase(it);
+  if (m_reg_context_up->ClearHardwareWatchpoint(index))
+    return Status();
+  return Status("Remove hardware breakpoint failed.");
+}

source/Plugins/Process/Windows/Common/ProcessDebugger.h

+//===-- NativeProcessWindows.h ----------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ProcessDebugger_h_
+#define liblldb_ProcessDebugger_h_
+
+#include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
+#include "llvm/Support/Mutex.h"
+
+#include "ForwardDecl.h"
+
+namespace lldb_private {
+
+class HostProcess;
+class HostThread;
+class ProcessWindowsData;
+class ProcessLaunchInfo;
+class ProcessAttachInfo;
+
+class ProcessDebugger {
+
+public:
+  virtual void OnExitProcess(uint32_t exit_code);
+  virtual void OnDebuggerConnected(lldb::addr_t image_base);
+  virtual ExceptionResult OnDebugException(bool first_chance,
+                                           const ExceptionRecord &record);
+  virtual void OnCreateThread(const HostThread &thread);
+  virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code);
+  virtual void OnLoadDll(const ModuleSpec &module_spec,
+                         lldb::addr_t module_addr);
+  virtual void OnUnloadDll(lldb::addr_t module_addr);
+  virtual void OnDebugString(const std::string &string);
+  virtual void OnDebuggerError(const Status &error, uint32_t type);
+
+protected:
+  Status DetachProcess();
+
+  Status LaunchProcess(ProcessLaunchInfo &launch_info,
+                       DebugDelegateSP delegate);
+
+  Status AttachProcess(lldb::pid_t pid, const ProcessAttachInfo &attach_info,
+                       DebugDelegateSP delegate);
+
+  Status DestroyProcess();
+
+  Status HaltProcess(bool &caused_stop);
+
+  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+                             MemoryRegionInfo &range_info);
+
+  Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    size_t &bytes_read);
+
+  Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
+                     size_t &bytes_written);
+
+  Status AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr);
+
+  Status DeallocateMemory(lldb::addr_t addr);
+
+  DebuggerThreadSP &GetDebuggerThread();
+  HostProcess GetDebuggedProcess() const;
+  HostThread ProcessDebugger::GetMainThread() const;
+
+  Status WaitForDebuggerConnection(DebuggerThreadSP debugger,
+                                   HostProcess &process);
+
+protected:
+  llvm::sys::Mutex m_mutex;
+
+private:
+  std::unique_ptr<ProcessWindowsData> m_session_data;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef liblldb_ProcessDebugger_h_

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

+//===-- ProcessDebugger.cpp -------------------------------------*- C++ -*-===//
+//
+// 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 "ProcessDebugger.h"
+
+// Windows includes
+#include "lldb/Host/windows/windows.h"
+#include <psapi.h>
+
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostNativeProcessBase.h"
+#include "lldb/Host/HostProcess.h"
+#include "lldb/Host/HostThread.h"
+#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Process.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Error.h"
+
+#include "DebuggerThread.h"
+#include "ExceptionRecord.h"
+#include "ProcessWindowsLog.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+std::string GetProcessExecutableName(HANDLE process_handle) {
+  std::vector<wchar_t> file_name;
+  DWORD file_name_size = MAX_PATH; // first guess, not an absolute limit
+  DWORD copied = 0;
+  do {
+    file_name_size *= 2;
+    file_name.resize(file_name_size);
+    copied = ::GetModuleFileNameExW(process_handle, NULL, file_name.data(),
+                                    file_name_size);
+  } while (copied >= file_name_size);
+  file_name.resize(copied);
+  std::string result;
+  llvm::convertWideToUTF8(file_name.data(), result);
+  return result;
+}
+
+std::string GetProcessExecutableName(DWORD pid) {
+  std::string file_name;
+  HANDLE process_handle =
+      ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
+  if (process_handle != NULL) {
+    file_name = GetProcessExecutableName(process_handle);
+    ::CloseHandle(process_handle);
+  }
+  return file_name;
+}
+
+DWORD ConvertLldbToWinApiProtect(uint32_t protect) {
+  // We also can process a read / write permissions here, but if the debugger
+  // will make later a write into the allocated memory, it will fail. To get
+  // around it is possible inside DoWriteMemory to remember memory permissions,
+  // allow write, write and restore permissions, but for now we process only
+  // the executable permission.
+  //
+  // TODO: Process permissions other than executable
+  if (protect & ePermissionsExecutable)
+    return PAGE_EXECUTE_READWRITE;
+
+  return PAGE_READWRITE;
+}
+
+// The Windows page protection bits are NOT independent masks that can be
+// bitwise-ORed together.  For example, PAGE_EXECUTE_READ is not (PAGE_EXECUTE
+// | PAGE_READ).  To test for an access type, it's necessary to test for any of
+// the bits that provide that access type.
+bool IsPageReadable(uint32_t protect) { return (protect & PAGE_NOACCESS) == 0; }
+
+bool IsPageWritable(uint32_t protect) {
+  return (protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY |
+                     PAGE_READWRITE | PAGE_WRITECOPY)) != 0;
+}
+
+bool IsPageExecutable(uint32_t protect) {
+  return (protect & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE |
+                     PAGE_EXECUTE_WRITECOPY)) != 0;
+}
+} // namespace
+
+namespace lldb_private {
+
+// We store a pointer to this class in the ProcessWindows, so that we don't
+// expose Windows-specific types and implementation details from a public
+// header file.
+class ProcessWindowsData {
+public:
+  ProcessWindowsData(bool stop_at_entry) : m_stop_at_entry(stop_at_entry) {
+    m_initial_stop_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
+  }
+
+  ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); }
+
+  Status m_launch_error;
+  DebuggerThreadSP m_debugger;
+  StopInfoSP m_pending_stop_info;
+  HANDLE m_initial_stop_event = nullptr;
+  bool m_initial_stop_received = false;
+  bool m_stop_at_entry;
+  std::map<lldb::tid_t, HostThread> m_new_threads;
+  std::set<lldb::tid_t> m_exited_threads;
+};
+
+DebuggerThreadSP &ProcessDebugger::GetDebuggerThread() {
+  return m_session_data->m_debugger;
+}
+
+HostProcess ProcessDebugger::GetDebuggedProcess() const {
+  return m_session_data->m_debugger->GetProcess();
+}
+
+HostThread ProcessDebugger::GetMainThread() const {
+  return m_session_data->m_debugger->GetMainThread();
+}
+
+Status ProcessDebugger::DetachProcess() {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  DebuggerThreadSP debugger_thread;
+  {
+    // Acquire the lock only long enough to get the DebuggerThread.
+    // StopDebugging() will trigger a call back into ProcessWindows which will
+    // also acquire the lock.  Thus we have to release the lock before calling
+    // StopDebugging().
+    llvm::sys::ScopedLock lock(m_mutex);
+
+    if (!m_session_data) {
+      LLDB_LOG(log, "there is no active session.");
+      return Status();
+    }
+
+    debugger_thread = m_session_data->m_debugger;
+  }
+
+  Status error;
+
+  LLDB_LOG(log, "detaching from process {0}.",
+           debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
+  error = debugger_thread->StopDebugging(false);
+
+  // By the time StopDebugging returns, there is no more debugger thread, so
+  // we can be assured that no other thread will race for the session data.
+  m_session_data.reset();
+
+  return error;
+}
+
+Status ProcessDebugger::LaunchProcess(ProcessLaunchInfo &launch_info,
+                                      DebugDelegateSP delegate) {
+  // Even though m_session_data is accessed here, it is before a debugger
+  // thread has been kicked off.  So there's no race conditions, and it
+  // shouldn't be necessary to acquire the mutex.
+
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  Status result;
+
+  FileSpec working_dir = launch_info.GetWorkingDirectory();
+  namespace fs = llvm::sys::fs;
+  if (working_dir) {
+    FileSystem::Instance().Resolve(working_dir);
+    if (!FileSystem::Instance().IsDirectory(working_dir)) {
+      result.SetErrorStringWithFormat("No such file or directory: %s",
+                                      working_dir.GetCString());
+      return result;
+    }
+  }
+
+  if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
+    StreamString stream;
+    stream.Printf("ProcessWindows unable to launch '%s'.  ProcessWindows can "
+                  "only be used for debug launches.",
+                  launch_info.GetExecutableFile().GetPath().c_str());
+    std::string message = stream.GetString();
+    result.SetErrorString(message.c_str());
+
+    LLDB_LOG(log, "error: {0}", message);
+    return result;
+  }
+
+  // Resolve the architecture if it is unknown.
+  if (launch_info.GetArchitecture().GetMachine() == llvm::Triple::UnknownArch) {
+#if 0
+    StreamString stream;
+    stream.Printf("ProcessWindows unable to launch '%s'.  ProcessWindows can "
+                  "only be used for debug launches.",
+                  launch_info.GetExecutableFile().GetPath().c_str());
+    std::string message = stream.GetString();
+    result.SetErrorString(message.c_str());
+
+    LLDB_LOG(log, "error: {0}", message);
+    return result;
+#endif
+  }
+
+  bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
+  m_session_data.reset(new ProcessWindowsData(stop_at_entry));
+  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()) {
+    LLDB_LOG(log, "failed launching '{0}'. {1}",
+             launch_info.GetExecutableFile().GetPath(), result);
+    return result;
+  }
+
+  HostProcess process;
+  Status error = WaitForDebuggerConnection(debugger, process);
+  if (error.Fail()) {
+    LLDB_LOG(log, "failed launching '{0}'. {1}",
+             launch_info.GetExecutableFile().GetPath(), error);
+    return error;
+  }
+
+  LLDB_LOG(log, "successfully launched '{0}'",
+           launch_info.GetExecutableFile().GetPath());
+
+  // 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());
+
+  return result;
+}
+
+Status ProcessDebugger::AttachProcess(lldb::pid_t pid,
+                                      const ProcessAttachInfo &attach_info,
+                                      DebugDelegateSP delegate) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  m_session_data.reset(
+      new ProcessWindowsData(!attach_info.GetContinueOnceAttached()));
+  DebuggerThreadSP debugger(new DebuggerThread(delegate));
+
+  m_session_data->m_debugger = debugger;
+
+  DWORD process_id = static_cast<DWORD>(pid);
+  Status error = debugger->DebugAttach(process_id, attach_info);
+  if (error.Fail()) {
+    LLDB_LOG(
+        log,
+        "encountered an error occurred initiating the asynchronous attach. {0}",
+        error);
+    return error;
+  }
+
+  HostProcess process;
+  error = WaitForDebuggerConnection(debugger, process);
+  if (error.Fail()) {
+    LLDB_LOG(log,
+             "encountered an error waiting for the debugger to connect. {0}",
+             error);
+    return error;
+  }
+
+  LLDB_LOG(log, "successfully attached to process with pid={0}", 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.
+  return error;
+}
+
+Status ProcessDebugger::DestroyProcess() {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  DebuggerThreadSP debugger_thread;
+  {
+    // Acquire this lock inside an inner scope, only long enough to get the
+    // DebuggerThread. StopDebugging() will trigger a call back into
+    // ProcessWindows which will acquire the lock again, so we need to not
+    // deadlock.
+    llvm::sys::ScopedLock lock(m_mutex);
+
+    if (!m_session_data) {
+      LLDB_LOG(log, "warning: there is no active session.");
+      return Status();
+    }
+
+    debugger_thread = m_session_data->m_debugger;
+  }
+
+  LLDB_LOG(log, "Shutting down process {0}.",
+           debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle());
+  Status error = debugger_thread->StopDebugging(true);
+
+  // By the time StopDebugging returns, there is no more debugger thread, so
+  // we can be assured that no other thread will race for the session data.
+  m_session_data.reset();
+
+  return error;
+}
+
+Status ProcessDebugger::HaltProcess(bool &caused_stop) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+  Status error;
+  llvm::sys::ScopedLock lock(m_mutex);
+  caused_stop = ::DebugBreakProcess(m_session_data->m_debugger->GetProcess()
+                                        .GetNativeProcess()
+                                        .GetSystemHandle());
+  if (!caused_stop) {
+    error.SetError(::GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "DebugBreakProcess failed with error {0}", error);
+  }
+
+  return error;
+}
+
+Status ProcessDebugger::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
+                                   size_t &bytes_read) {
+  Status error;
+  bytes_read = 0;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  if (!m_session_data) {
+    error.SetErrorString(
+        "cannot read, there is no active debugger connection.");
+    LLDB_LOG(log, "error: {0}", error);
+    return error;
+  }
+
+  LLDB_LOG(log, "attempting to read {0} bytes from address {1:x}", size,
+           vm_addr);
+
+  HostProcess process = m_session_data->m_debugger->GetProcess();
+  void *addr = reinterpret_cast<void *>(vm_addr);
+  SIZE_T num_of_bytes_read = 0;
+  if (!::ReadProcessMemory(process.GetNativeProcess().GetSystemHandle(), addr,
+                           buf, size, &num_of_bytes_read)) {
+    // Reading from the process can fail for a number of reasons - set the
+    // error code and make sure that the number of bytes read is set back to 0
+    // because in some scenarios the value of bytes_read returned from the API
+    // is garbage.
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "reading failed with error: {0}", error);
+  } else {
+    bytes_read = num_of_bytes_read;
+  }
+  return error;
+}
+
+Status ProcessDebugger::WriteMemory(lldb::addr_t vm_addr, const void *buf,
+                                    size_t size, size_t &bytes_written) {
+  Status error;
+  bytes_written = 0;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
+  llvm::sys::ScopedLock lock(m_mutex);
+  LLDB_LOG(log, "attempting to write {0} bytes into address {1:x}", size,
+           vm_addr);
+
+  if (!m_session_data) {
+    error.SetErrorString(
+        "cannot write, there is no active debugger connection.");
+    LLDB_LOG(log, "error: {0}", error);
+    return error;
+  }
+
+  HostProcess process = m_session_data->m_debugger->GetProcess();
+  void *addr = reinterpret_cast<void *>(vm_addr);
+  SIZE_T num_of_bytes_written = 0;
+  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
+  if (::WriteProcessMemory(handle, addr, buf, size, &num_of_bytes_written)) {
+    FlushInstructionCache(handle, addr, num_of_bytes_written);
+    bytes_written = num_of_bytes_written;
+  } else {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "writing failed with error: {0}", error);
+  }
+  return error;
+}
+
+Status ProcessDebugger::AllocateMemory(size_t size, uint32_t permissions,
+                                       lldb::addr_t &addr) {
+  Status error;
+  addr = LLDB_INVALID_ADDRESS;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
+  llvm::sys::ScopedLock lock(m_mutex);
+  LLDB_LOG(log, "attempting to allocate {0} bytes with permissions {1}", size,
+           permissions);
+
+  if (!m_session_data) {
+    error.SetErrorString(
+        "cannot allocate, there is no active debugger connection");
+    LLDB_LOG(log, "error: {0}", error);
+    return error;
+  }
+
+  HostProcess process = m_session_data->m_debugger->GetProcess();
+  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
+  auto protect = ConvertLldbToWinApiProtect(permissions);
+  auto result = ::VirtualAllocEx(handle, nullptr, size, MEM_COMMIT, protect);
+  if (!result) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "allocating failed with error: {0}", error);
+  } else {
+    addr = reinterpret_cast<addr_t>(result);
+  }
+  return error;
+}
+
+Status ProcessDebugger::DeallocateMemory(lldb::addr_t vm_addr) {
+  Status result;
+
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
+  llvm::sys::ScopedLock lock(m_mutex);
+  LLDB_LOG(log, "attempting to deallocate bytes at address {0}", vm_addr);
+
+  if (!m_session_data) {
+    result.SetErrorString(
+        "cannot deallocate, there is no active debugger connection");
+    LLDB_LOG(log, "error: {0}", result);
+    return result;
+  }
+
+  HostProcess process = m_session_data->m_debugger->GetProcess();
+  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
+  if (!::VirtualFreeEx(handle, reinterpret_cast<LPVOID>(vm_addr), 0,
+                       MEM_RELEASE)) {
+    result.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "deallocating failed with error: {0}", result);
+  }
+
+  return result;
+}
+
+Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
+                                            MemoryRegionInfo &info) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
+  Status error;
+  llvm::sys::ScopedLock lock(m_mutex);
+  info.Clear();
+
+  if (!m_session_data) {
+    error.SetErrorString(
+        "GetMemoryRegionInfo called with no debugging session.");
+    LLDB_LOG(log, "error: {0}", error);
+    return error;
+  }
+  HostProcess process = m_session_data->m_debugger->GetProcess();
+  lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
+  if (handle == nullptr || handle == LLDB_INVALID_PROCESS) {
+    error.SetErrorString(
+        "GetMemoryRegionInfo called with an invalid target process.");
+    LLDB_LOG(log, "error: {0}", error);
+    return error;
+  }
+
+  LLDB_LOG(log, "getting info for address {0:x}", vm_addr);
+
+  void *addr = reinterpret_cast<void *>(vm_addr);
+  MEMORY_BASIC_INFORMATION mem_info = {};
+  SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
+  if (result == 0) {
+    if (::GetLastError() == ERROR_INVALID_PARAMETER) {
+      // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with
+      // an address past the highest accessible address. We should return a
+      // range from the vm_addr to LLDB_INVALID_ADDRESS
+      info.GetRange().SetRangeBase(vm_addr);
+      info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS);
+      info.SetReadable(MemoryRegionInfo::eNo);
+      info.SetExecutable(MemoryRegionInfo::eNo);
+      info.SetWritable(MemoryRegionInfo::eNo);
+      info.SetMapped(MemoryRegionInfo::eNo);
+      return error;
+    } else {
+      error.SetError(::GetLastError(), eErrorTypeWin32);
+      LLDB_LOG(log,
+               "VirtualQueryEx returned error {0} while getting memory "
+               "region info for address {1:x}",
+               error, vm_addr);
+      return error;
+    }
+  }
+
+  // Protect bits are only valid for MEM_COMMIT regions.
+  if (mem_info.State == MEM_COMMIT) {
+    const bool readable = IsPageReadable(mem_info.Protect);
+    const bool executable = IsPageExecutable(mem_info.Protect);
+    const bool writable = IsPageWritable(mem_info.Protect);
+    info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+    info.SetExecutable(executable ? MemoryRegionInfo::eYes
+                                  : MemoryRegionInfo::eNo);
+    info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo);
+  } else {
+    info.SetReadable(MemoryRegionInfo::eNo);
+    info.SetExecutable(MemoryRegionInfo::eNo);
+    info.SetWritable(MemoryRegionInfo::eNo);
+  }
+
+  // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE.
+  if (mem_info.State != MEM_FREE) {
+    info.GetRange().SetRangeBase(
+        reinterpret_cast<addr_t>(mem_info.AllocationBase));
+    info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) +
+                                mem_info.RegionSize);
+    info.SetMapped(MemoryRegionInfo::eYes);
+  } else {
+    // In the unmapped case we need to return the distance to the next block of
+    // memory. VirtualQueryEx nearly does that except that it gives the
+    // distance from the start of the page containing vm_addr.
+    SYSTEM_INFO data;
+    ::GetSystemInfo(&data);
+    DWORD page_offset = vm_addr % data.dwPageSize;
+    info.GetRange().SetRangeBase(vm_addr);
+    info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
+    info.SetMapped(MemoryRegionInfo::eNo);
+  }
+
+  error.SetError(::GetLastError(), eErrorTypeWin32);
+  LLDB_LOGV(log,
+            "Memory region info for address {0}: readable={1}, "
+            "executable={2}, writable={3}",
+            vm_addr, info.GetReadable(), info.GetExecutable(),
+            info.GetWritable());
+  return error;
+}
+
+void ProcessDebugger::OnExitProcess(uint32_t exit_code) {
+  // 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_session_data->m_initial_stop_received) {
+    Status error(exit_code, eErrorTypeWin32);
+    OnDebuggerError(error, 0);
+  }
+}
+
+void ProcessDebugger::OnDebuggerConnected(lldb::addr_t image_base) {}
+
+ExceptionResult
+ProcessDebugger::OnDebugException(bool first_chance,
+                                  const ExceptionRecord &record) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EXCEPTION);
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  // FIXME: Without this check, occasionally when running the test suite there
+  // is
+  // an issue where m_session_data can be null.  It's not clear how this could
+  // happen but it only surfaces while running the test suite.  In order to
+  // properly diagnose this, we probably need to first figure allow the test
+  // suite to print out full lldb logs, and then add logging to the process
+  // plugin.
+  if (!m_session_data) {
+    LLDB_LOG(log,
+             "Debugger thread reported exception {0:x} at address {1:x}, "
+             "but there is no session.",
+             record.GetExceptionCode(), record.GetExceptionAddress());
+    return ExceptionResult::SendToApplication;
+  }
+
+  ExceptionResult result = ExceptionResult::SendToApplication;
+  if (record.GetExceptionCode() == EXCEPTION_BREAKPOINT &&
+      !m_session_data->m_initial_stop_received) {
+            // Handle breakpoints at the first chance.
+    result = ExceptionResult::BreakInDebugger;
+      LLDB_LOG(
+          log,
+          "Hit loader breakpoint at address {0:x}, setting initial stop event.",
+          record.GetExceptionAddress());
+      m_session_data->m_initial_stop_received = true;
+      ::SetEvent(m_session_data->m_initial_stop_event);
+  }  
+  return result;
+}
+
+void ProcessDebugger::OnCreateThread(const HostThread &thread) {}
+
+void ProcessDebugger::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {}
+
+void ProcessDebugger::OnLoadDll(const ModuleSpec &module_spec,
+                                lldb::addr_t module_addr) {
+  // Do nothing by default
+}
+
+void ProcessDebugger::OnUnloadDll(lldb::addr_t module_addr) {
+  // Do nothing by default
+}
+
+void ProcessDebugger::OnDebugString(const std::string &string) {}
+
+void ProcessDebugger::OnDebuggerError(const Status &error, uint32_t type) {
+  llvm::sys::ScopedLock lock(m_mutex);
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
+
+  if (m_session_data->m_initial_stop_received) {
+    // This happened while debugging.  Do we shutdown the debugging session,
+    // try to continue, or do something else?
+    LLDB_LOG(log,
+             "Error {0} occurred during debugging.  Unexpected behavior "
+             "may result.  {1}",
+             error.GetError(), error);
+  } else {
+    // If we haven't actually launched the process yet, this was an error
+    // launching the process.  Set the internal error and signal the initial
+    // stop event so that the DoLaunch method wakes up and returns a failure.
+    m_session_data->m_launch_error = error;
+    ::SetEvent(m_session_data->m_initial_stop_event);
+    LLDB_LOG(
+        log,
+        "Error {0} occurred launching the process before the initial stop. {1}",
+        error.GetError(), error);
+    return;
+  }
+}
+
+Status ProcessDebugger::WaitForDebuggerConnection(DebuggerThreadSP debugger,
+                                                  HostProcess &process) {
+  Status result;
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS |
+                                            WINDOWS_LOG_BREAKPOINTS);
+  LLDB_LOG(log, "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) {
+    LLDB_LOG(log, "hit loader breakpoint, returning.");
+
+    process = debugger->GetProcess();
+    return m_session_data->m_launch_error;
+  } else
+    return Status(::GetLastError(), eErrorTypeWin32);
+}
+
+} // namespace lldb_private

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

 //------------------------------------------------------------------
 uint32_t RegisterContextWindows::NumSupportedHardwareBreakpoints() {
   // Support for hardware breakpoints not yet implemented.
   return 0;
 }
 
 uint32_t RegisterContextWindows::SetHardwareBreakpoint(lldb::addr_t addr,
                                                        size_t size) {
-  return 0;
+  return LLDB_INVALID_INDEX32;
 }
 
 bool RegisterContextWindows::ClearHardwareBreakpoint(uint32_t hw_idx) {
   return false;
 }
 
 uint32_t RegisterContextWindows::NumSupportedHardwareWatchpoints() {
   // Support for hardware watchpoints not yet implemented.
   return 0;
 }
 
 uint32_t RegisterContextWindows::SetHardwareWatchpoint(lldb::addr_t addr,
                                                        size_t size, bool read,
                                                        bool write) {
-  return 0;
+  return LLDB_INVALID_INDEX32;
 }
 
 bool RegisterContextWindows::ClearHardwareWatchpoint(uint32_t hw_index) {
   return false;
 }
 
 bool RegisterContextWindows::HardwareSingleStep(bool enable) { return false; }
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "ProcessGDBRemoteLog.h"
 
 #if defined(__APPLE__)
 #define DEBUGSERVER_BASENAME "debugserver"
+#elif defined(_WIN32)
+#define DEBUGSERVER_BASENAME "lldb-server.exe"
 #else
 #define DEBUGSERVER_BASENAME "lldb-server"
 #endif
 
 #if defined(HAVE_LIBCOMPRESSION)
 #include <compression.h>
 #endif
 
if (decompressed_buffer == nullptr) {
       m_bytes.erase(0, size_of_first_packet);
       return false;
     }
   }
 
 #if defined(HAVE_LIBCOMPRESSION)
   if (m_compression_type == CompressionType::ZlibDeflate ||
       m_compression_type == CompressionType::LZFSE ||
-      m_compression_type == CompressionType::LZ4 || 
+      m_compression_type == CompressionType::LZ4 ||
       m_compression_type == CompressionType::LZMA) {
     compression_algorithm compression_type;
     if (m_compression_type == CompressionType::LZFSE)
       compression_type = COMPRESSION_LZFSE;
     else if (m_compression_type == CompressionType::ZlibDeflate)
       compression_type = COMPRESSION_ZLIB;
     else if (m_compression_type == CompressionType::LZ4)
       compression_type = COMPRESSION_LZ4_RAW;
     else if (m_compression_type == CompressionType::LZMA)
       compression_type = COMPRESSION_LZMA;
 
     if (m_decompression_scratch_type != m_compression_type) {
       if (m_decompression_scratch) {
-        free (m_decompression_scratch);
+        free(m_decompression_scratch);
         m_decompression_scratch = nullptr;
       }
       size_t scratchbuf_size = 0;
       if (m_compression_type == CompressionType::LZFSE)
-        scratchbuf_size = compression_decode_scratch_buffer_size (COMPRESSION_LZFSE);
+        scratchbuf_size =
+            compression_decode_scratch_buffer_size(COMPRESSION_LZFSE);
       else if (m_compression_type == CompressionType::LZ4)
-        scratchbuf_size = compression_decode_scratch_buffer_size (COMPRESSION_LZ4_RAW);
+        scratchbuf_size =
+            compression_decode_scratch_buffer_size(COMPRESSION_LZ4_RAW);
       else if (m_compression_type == CompressionType::ZlibDeflate)
-        scratchbuf_size = compression_decode_scratch_buffer_size (COMPRESSION_ZLIB);
+        scratchbuf_size =
+            compression_decode_scratch_buffer_size(COMPRESSION_ZLIB);
       else if (m_compression_type == CompressionType::LZMA)
-        scratchbuf_size = compression_decode_scratch_buffer_size (COMPRESSION_LZMA);
+        scratchbuf_size =
+            compression_decode_scratch_buffer_size(COMPRESSION_LZMA);
       else if (m_compression_type == CompressionType::LZFSE)
-        scratchbuf_size = compression_decode_scratch_buffer_size (COMPRESSION_LZFSE);
+        scratchbuf_size =
+            compression_decode_scratch_buffer_size(COMPRESSION_LZFSE);
       if (scratchbuf_size > 0) {
-        m_decompression_scratch = (void*) malloc (scratchbuf_size);
+        m_decompression_scratch = (void *)malloc(scratchbuf_size);
         m_decompression_scratch_type = m_compression_type;
       }
     }
 
     if (decompressed_bufsize != ULONG_MAX && decompressed_buffer != nullptr) {
       decompressed_bytes = compression_decode_buffer(
           decompressed_buffer, decompressed_bufsize,
-          (uint8_t *)unescaped_content.data(), unescaped_content.size(), 
+          (uint8_t *)unescaped_content.data(), unescaped_content.size(),
           m_decompression_scratch, compression_type);
     }
   }
 #endif
 
 #if defined(HAVE_LIBZ)
   if (decompressed_bytes == 0 && decompressed_bufsize != ULONG_MAX &&
       decompressed_buffer != nullptr &&

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

if (proc_arch.IsValid()) {
     response.PutStringAsRawHex8(proc_triple.getTriple());
     response.PutChar(';');
   }
 }
 
 void GDBRemoteCommunicationServerCommon::
     CreateProcessInfoResponse_DebugServerStyle(
         const ProcessInstanceInfo &proc_info, StreamString &response) {
+#if !defined(_WIN32)
   response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64
                   ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
                   proc_info.GetProcessID(), proc_info.GetParentProcessID(),
                   proc_info.GetUserID(), proc_info.GetGroupID(),
                   proc_info.GetEffectiveUserID(),
                   proc_info.GetEffectiveGroupID());
+#else
+  response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64 ";",
+                  proc_info.GetProcessID(), proc_info.GetParentProcessID());
+#endif
 
   const ArchSpec &proc_arch = proc_info.GetArchitecture();
   if (proc_arch.IsValid()) {
     const llvm::Triple &proc_triple = proc_arch.GetTriple();
 #if defined(__APPLE__)
     // We'll send cputype/cpusubtype.
     const uint32_t cpu_type = proc_arch.GetMachOCPUType();
     if (cpu_type != 0)

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
   const bool should_forward_stdio =
       m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr ||
       m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr ||
       m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr;
   m_process_launch_info.SetLaunchInSeparateProcessGroup(true);
   m_process_launch_info.GetFlags().Set(eLaunchFlagDebug);
 
   if (should_forward_stdio) {
+    // No pty support on Windows so far that means neither O* or I*
+    // notification packets will be generated about the inferior. However
+    // in most cases the missing notifications do not affect the major
+    // use of the lldb-server.  So here temporarily relax the following
+    // for Windows.
+#if !defined(_WIN32)
     if (llvm::Error Err = m_process_launch_info.SetUpPtyRedirection())
       return Status(std::move(Err));
+#endif
   }
 
   {
     std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
     assert(!m_debugged_process_up && "lldb-server creating debugged "
                                      "process but one already exists");
     auto process_or =
         m_process_factory.Launch(m_process_launch_info, *this, m_mainloop);

tools/lldb-server/CMakeLists.txt

 if(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
   list(APPEND LLDB_PLUGINS lldbPluginProcessNetBSD)
 endif()
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
   list(APPEND LLDB_PLUGINS lldbPluginObjectFileMachO)
 elseif(CMAKE_SYSTEM_NAME MATCHES "Windows")
   list(APPEND LLDB_PLUGINS lldbPluginObjectFilePECOFF)
+  list(APPEND LLDB_PLUGINS lldbPluginPlatformWindows)
+  list(APPEND LLDB_PLUGINS lldbPluginProcessWindowsCommon)
+  list(APPEND LLDB_PLUGINS lldbPluginABISysV_arm)
+  list(APPEND LLDB_PLUGINS lldbPluginABISysV_arm64)
+  list(APPEND LLDB_PLUGINS lldbPluginABISysV_i386)
+  list(APPEND LLDB_PLUGINS lldbPluginABISysV_x86_64)
+  list(APPEND LLDB_PLUGINS lldbPluginSymbolFilePDB)
+  list(APPEND LLDB_PLUGINS lldbPluginUnwindAssemblyX86)
 else()
   list(APPEND LLDB_PLUGINS lldbPluginObjectFileELF)
 endif()
 
 if(IOS)
   if(LLDB_CODESIGN_IDENTITY)
     # Use explicit LLDB identity
     set(LLVM_CODESIGNING_IDENTITY ${LLDB_CODESIGN_IDENTITY})
add_lldb_tool(lldb-server
     SystemInitializerLLGS.cpp
 
     LINK_LIBS
       lldbBase
       lldbCore
       lldbHost
       lldbInitialization
       lldbInterpreter
+    lldbSymbol
       ${LLDB_PLUGINS}
       ${LLDB_SYSTEM_LIBS}
 
     LINK_COMPONENTS
       Support
 )
 
 target_link_libraries(lldb-server PRIVATE ${LLDB_SYSTEM_LIBS})
+

tools/lldb-server/SystemInitializerLLGS.cpp

 //===-- SystemInitializerLLGS.cpp -------------------------------*- C++ -*-===//
 //
 // 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 "SystemInitializerLLGS.h"
 
 #if defined(__APPLE__)
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 using HostObjectFile = ObjectFileMachO;
 #elif defined(_WIN32)
+#include "lldb/Host/windows/windows.h"
+#include <winsock2.h>
+
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 using HostObjectFile = ObjectFilePECOFF;
 #else
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 using HostObjectFile = ObjectFileELF;
 #endif
 
 using namespace lldb_private;
 
+static uint32_t g_ref_count = 0;
+
 llvm::Error SystemInitializerLLGS::Initialize() {
   if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
   HostObjectFile::Initialize();
 
+#if defined(_WIN32)
+  if (g_ref_count++ == 0) {
+    // Require Windows Sockets version 2.2.
+    auto wVersion = MAKEWORD(2, 2);
+    WSADATA wsaData;
+    auto err = WSAStartup(wVersion, &wsaData);
+    if (err == 0) {
+      // Check if the WinSock verison is what we expect.
+      if (wsaData.wVersion < wVersion) {
+        g_ref_count = 0;
+        WSACleanup();
+      }
+    } else
+      g_ref_count = 0;
+  }
+#endif
   return llvm::Error::success();
 }
 
 void SystemInitializerLLGS::Terminate() {
+#if defined(_WIN32)
+  if (g_ref_count && --g_ref_count == 0)
+    WSACleanup();
+#endif
   HostObjectFile::Terminate();
   SystemInitializerCommon::Terminate();
 }

tools/lldb-server/lldb-gdbserver.cpp

 #include "lldb/Utility/Status.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errno.h"
 
 #if defined(__linux__)
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #elif defined(__NetBSD__)
 #include "Plugins/Process/NetBSD/NativeProcessNetBSD.h"
+#elif defined(_WIN32)
+#include "Plugins/Process/Windows/Common/NativeProcessWindows.h"
 #endif
 
 #ifndef LLGS_PROGRAM_NAME
 #define LLGS_PROGRAM_NAME "lldb-server"
 #endif
 
 #ifndef LLGS_VERSION_STR
 #define LLGS_VERSION_STR "local_build"
 #endif
 
 using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::lldb_server;
 using namespace lldb_private::process_gdb_remote;
 
 namespace {
 #if defined(__linux__)
 typedef process_linux::NativeProcessLinux::Factory NativeProcessFactory;
 #elif defined(__NetBSD__)
 typedef process_netbsd::NativeProcessNetBSD::Factory NativeProcessFactory;
+#elif defined(_WIN32)
+typedef NativeProcessWindows::Factory NativeProcessFactory;
 #else
 // Dummy implementation to make sure the code compiles
 class NativeProcessFactory : public NativeProcessProtocol::Factory {
 public:
   llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
   Launch(ProcessLaunchInfo &launch_info,
          NativeProcessProtocol::NativeDelegate &delegate,
          MainLoop &mainloop) const override {
     llvm_unreachable("Not implemented");
   }
   llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
   Attach(lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &delegate,
          MainLoop &mainloop) const override {
     llvm_unreachable("Not implemented");
   }
 };
 #endif
-}
+} // namespace
 
 //----------------------------------------------------------------------
 // option descriptors for getopt_long_only()
 //----------------------------------------------------------------------
 
 static int g_debug = 0;
 static int g_verbose = 0;
 
#endif
   // unless
   // explicitly asked to attach with the --attach={pid|program_name} form.
   if (!attach_target.empty())
     handle_attach(gdb_server, attach_target);
   else if (argc > 0)
     handle_launch(gdb_server, argc, argv);
 
   // Print version info.
-  printf("%s-%s", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
+  printf("%s-%s\n", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
 
   ConnectToRemote(mainloop, gdb_server, reverse_connect, host_and_port,
-                  progname, subcommand, named_pipe_path.c_str(), 
-                  unnamed_pipe, connection_fd);
+                  progname, subcommand, named_pipe_path.c_str(), unnamed_pipe,
+                  connection_fd);
 
   if (!gdb_server.IsConnected()) {
     fprintf(stderr, "no connection information provided, unable to run\n");
     display_usage(progname, subcommand);
     return 1;
   }
 
   Status ret = mainloop.Run();

tools/lldb-server/lldb-platform.cpp

 #if defined(__APPLE__)
 #include <netinet/in.h>
 #endif
 #include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#if !defined(_WIN32)
 #include <sys/wait.h>
-
+#endif
 #include <fstream>
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 
 #include "Acceptor.h"
 #include "LLDBServerUtilities.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h"
static struct option g_long_options[] = {
     {"log-file", required_argument, NULL, 'l'},
     {"log-channels", required_argument, NULL, 'c'},
     {"listen", required_argument, NULL, 'L'},
     {"port-offset", required_argument, NULL, 'p'},
     {"gdbserver-port", required_argument, NULL, 'P'},
     {"min-gdbserver-port", required_argument, NULL, 'm'},
     {"max-gdbserver-port", required_argument, NULL, 'M'},
     {"socket-file", required_argument, NULL, 'f'},
-    {"server", no_argument, &g_server, 1},
+    {"server", no_argument, &g_server, 1}, // Not working on Windows.
     {NULL, 0, NULL, 0}};
 
 #if defined(__APPLE__)
 #define LOW_PORT (IPPORT_RESERVED)
 #define HIGH_PORT (IPPORT_HIFIRSTAUTO)
 #else
 #define LOW_PORT (1024u)
 #define HIGH_PORT (49151u)
 #endif
 
 //----------------------------------------------------------------------
 // Watch for signals
 //----------------------------------------------------------------------
 static void signal_handler(int signo) {
+#if !defined(_WIN32)
   switch (signo) {
   case SIGHUP:
     // Use SIGINT first, if that does not work, use SIGHUP as a last resort.
     // And we should not call exit() here because it results in the global
     // destructors
     // to be invoked and wreaking havoc on the threads still running.
     Host::SystemLog(Host::eSystemLogWarning,
                     "SIGHUP received, exiting lldb-server...\n");
     abort();
     break;
   }
+#endif
 }
 
 static void display_usage(const char *progname, const char *subcommand) {
   fprintf(stderr, "Usage:\n  %s %s [--log-file log-file-name] [--log-channels "
                   "log-channel-list] [--port-file port-file-path] --server "
                   "--listen port\n",
           progname, subcommand);
   exit(0);

 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int main_platform(int argc, char *argv[]) {
   const char *progname = argv[0];
   const char *subcommand = argv[1];
   argc--;
   argv++;
+#if !defined(_WIN32)
   signal(SIGPIPE, SIG_IGN);
   signal(SIGHUP, signal_handler);
+#endif
   int long_option_index = 0;
   Status error;
   std::string listen_host_port;
   int ch;
 
   std::string log_file;
   StringRef
       log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"

tools/lldb-server/lldb-server.cpp

fprintf(stderr, "Usage:\n"
                   "Invoke subcommand for additional help\n",
           progname, progname, progname);
   exit(0);
 }
 
 // Forward declarations of subcommand main methods.
 int main_gdbserver(int argc, char *argv[]);
 int main_platform(int argc, char *argv[]);
 
+namespace llgs {
 static void initialize() {
   if (auto e = g_debugger_lifetime->Initialize(
           llvm::make_unique<SystemInitializerLLGS>(), nullptr))
     llvm::consumeError(std::move(e));
 }
 
 static void terminate() { g_debugger_lifetime->Terminate(); }
+} // namespace llgs
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int main(int argc, char *argv[]) {
   llvm::StringRef ToolName = argv[0];
   llvm::sys::PrintStackTraceOnErrorSignal(ToolName);
   llvm::PrettyStackTraceProgram X(argc, argv);
 
   int option_error = 0;
   const char *progname = argv[0];
   if (argc < 2) {
     display_usage(progname);
     exit(option_error);
   }
 
   switch (argv[1][0]) {
   case 'g':
-    initialize();
+    llgs::initialize();
     main_gdbserver(argc, argv);
-    terminate();
+    llgs::terminate();
     break;
   case 'p':
-    initialize();
+    llgs::initialize();
     main_platform(argc, argv);
-    terminate();
+    llgs::terminate();
     break;
   case 'v':
     fprintf(stderr, "%s\n", lldb_private::GetVersion());
     break;
   default:
     display_usage(progname);
     exit(option_error);
   }
 }