Initial support for native debugging of x86/x64 Windows processes

[asmith]

Summary

Thanks to Hui Huang and the reviewers for all the help with this patch.

[clayborg]

I don't see much I would change here as long as this works and gets tested by the generic GDB remote protocol testing? Any others have comments?

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

350 ↗

(On Diff #204154)

Define STATUS_WX86_BREAKPOINT somewhere and don't use a magic number?

[compnerd]

source/Plugins/Process/Utility/RegisterContextWindows_i386.cpp

40 ↗

(On Diff #204154)

I believe that this bounds the range, and needs to be re-enabled. Why not permit clang-format to reflow DEFINE_GPR?

76 ↗

(On Diff #204154)

Could you use llvm_unreachable instead please? Same throughout.

84 ↗

(On Diff #204154)

Why not llvm::array_lengthof?

source/Plugins/Process/Utility/RegisterContextWindows_wow64.h

14 ↗

(On Diff #204154)

Could you spell this WoW64 to match the Microsoft naming scheme for the "proper" noun?

[amccarth]

Sorry for the stupid question, but ...

What exactly is meant here by "Native"? How is a NativeProcessWindows different from ProcessWindows?

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

16 ↗

(On Diff #204154)

Where is ProcessDebugger.h? Should that be part of this patch?

[labath]

I take it that D63166 is a prerequisite for this patch. Is that all, or is there something else that we ought to look at first?

Overall, this patch is slightly larger that would be ideal for a proper review, though I appreciate the difficulty in bootstrapping something like this. However, given that the register context gunk is actually a significant portion of this patch (though that's not your fault), maybe you could just restrict this patch to a single architecture, and do others as follow-ups? This would let the overall structure of the code stand out more prominently.

In D63165#1539118, @amccarth wrote:

Sorry for the stupid question, but ...

What exactly is meant here by "Native"? How is a NativeProcessWindows different from ProcessWindows?

The Native*** classes are meant to be used from lldb-server. They look somewhat similar to their non-native counterpart because they still do debugging, but they're a lot dumber, because they only deal with basic process control, and none of the fancy symbolic stuff that you'd need debug info for.

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

352 ↗

(On Diff #204154)

s/matin/main

529–530 ↗

(On Diff #204154)

Fetching the architecture this way looks like it could be racy if the pid is recycled before you get a chance to attach to the process (can that happen?). Is there a way to fetch the architecture *after* you perform the attach operation.

536 ↗

(On Diff #204154)

passing attach_info seems pretty redundant, as at this point the process should already be know the pid and the architecture (they were passed in the constructor). In fact, I think you should just delete DoAttachToProcessWithID, do that work in the constructor, and use the ErrorAsOutParameter pattern to return the error from there. (The Factory::Attach pattern was trying to avoid/discourage the use fallible constructors, but that's hard to avoid when you need to instantiate another object and set up callbacks. In that case, a fallible constructor is better over a separate function, as this way at least the initialization happens in a single step.)

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

16 ↗

(On Diff #204154)

I guess that's introduced in D63166

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

31 ↗

(On Diff #204154)

Is this overriding something? Can you please use override to indicate that (throughout this patch)?

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

13 ↗

(On Diff #204154)

The empty lines here look completely random. I'd just delete all of the empty lines and let clang-format sort/group the includes for you.

[Hui]

In D63165#1539118, @amccarth wrote:

Sorry for the stupid question, but ...

What exactly is meant here by "Native"? How is a NativeProcessWindows different from ProcessWindows?

The Native*** classes are meant to be used from lldb-server. They look somewhat similar to their non-native counterpart because they still do debugging, but they're a lot dumber, because they only deal with basic process control, and none of the fancy symbolic stuff that you'd need debug info for.

They differ in APIs but most of them have common implementations. The APIs from native process classes are more easy to apply process/thread control.
Hope the native and non-native ones can be merged. The similar thing to the RegisterContext and NativeRegisterContext classes.

The other thing is that using "native" classes can avoid linking a lot of unnecessary lldb libs (LLDB plugins or whatever comes with the plugins) to lldb-server.
The nativeprocesswindows could just be a pass-through to processwindows plugin, but the usage is a sort of strange since the
lldb-server needs to initialize the plugin, create a target, and create a instance just like what lldb does. This means literally
there will be two lldb debuggers, one on host and the other one on remote. It is doable, but not that applicable.

[Hui]

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

350 ↗

(On Diff #204154)

The definition is in ntstatus.h which has quite a few macros redefined in winnt.h that is implicitly included in both LLDB. and LLVM.
Could force to include ntstatus.h but need to make a handful of extra patches to replace EXCEPTION_BREAKPOINT macro etc with ntstatus's
in all concerned sources.

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

529–530 ↗

(On Diff #204154)

This factory attach will return a constructed native process which needs process architecture ahead to construct its native thread with a proper register context. So I think can't do it after the attach operation. At least need to do it before the factory routine returns. Do you mean to put these codes before line 540, i.e. return std::move(process_up)?

[clayborg]

In D63165#1540606, @Hui wrote:

In D63165#1539118, @amccarth wrote:

Sorry for the stupid question, but ...

What exactly is meant here by "Native"? How is a NativeProcessWindows different from ProcessWindows?

The Native*** classes are meant to be used from lldb-server. They look somewhat similar to their non-native counterpart because they still do debugging, but they're a lot dumber, because they only deal with basic process control, and none of the fancy symbolic stuff that you'd need debug info for.

They differ in APIs but most of them have common implementations. The APIs from native process classes are more easy to apply process/thread control.
Hope the native and non-native ones can be merged. The similar thing to the RegisterContext and NativeRegisterContext classes.

The other thing is that using "native" classes can avoid linking a lot of unnecessary lldb libs (LLDB plugins or whatever comes with the plugins) to lldb-server.
The nativeprocesswindows could just be a pass-through to processwindows plugin, but the usage is a sort of strange since the
lldb-server needs to initialize the plugin, create a target, and create a instance just like what lldb does. This means literally
there will be two lldb debuggers, one on host and the other one on remote. It is doable, but not that applicable.

So the idea is ProcessWindows will be deleted once lldb-server supports windows debugging. A bit of history here: when we first started we started making ProcessXXXX for each platform (mac, linux, windows). Then we thought about remote debugging and decided to have everyone just make a lldb-server for their platform and even when we are locally debugging, we launch a lldb-server. This is how linux, macOS, the BSDs and other targets do it. Why? Because if you do it the other way you have more code to support: one native plug-in and one remote plug-in. This means the remote debugging usually has more issues since it is the less tested debugging scenario. It also means that if you had a native process implementation only, like ProcessWindows is currently, you can't remotely debug to a windows machine.

So yes there is duplicated code for now, but ProcessWindows.cpp and ThreadWindows.cpp should go away in the near future once lldb-server takes over so the temporary code duplication is just to keep things working until lldb-server takes over.

[Hui]

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

31 ↗

(On Diff #204154)

No, it doesn't override anything. It has different signature from the pure virtual method with the same name.

NativeRegisterContext::virtual Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) = 0;

It would be better to change the name to be ReadAllRegisterValuesWithSize or something else.

[labath]

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

315 ↗

(On Diff #204154)

This doesn't look right. You're completely ignoring the file_name argument. The idea of this function is to return the load (base) address of the module specified by that argument. Here I guess you're always returning the load address of the main module.

529–530 ↗

(On Diff #204154)

I meant doing this *before* the factory returns, but *after* you perform the actual OS attach syscall is completed.

Combining this with the constructor suggestion below, I'd imagine doing something like

Error E = Error::success();
auto process_up = std::make_unique<NativeProcessWindows>(pid, -1, native_delegate, E);
if (E)
  return E;
return std::move(process_up);

Then in the process constructor, you'd do:

ErrorAsOutParameter EOut(E);
auto delegate_sp = std::make_shared<NativeDebugDelegate>(*this);
ProcessAttachInfo attach_info;
attach_info.SetPID(pid); // TODO: This is dumb, we are already passing the pid separately
E = AttachProcess(pid, attach_info, delegate).ToError();
if (E)
  return;
SetID(GetDebuggedProcessId());
ProcessInstanceInfo info;
if (!Host::GetProcessInfo(pid, info)) {
  E = createStringError(inconvertibleErrorCode(), "Cannot get process information")
  return;
}
m_arch = info.GetArchitecture();

Among other things, I'm trying to cut down on the number of layers one has to go through in order to launch/attach. This file already has a number of functions called "attach", D63166 has a bunch more, and then there even more in DebuggerThread. By the time one gets to the bottom of the stack and figures out what's actually happening, he's forgotten what was he actually trying to achieve.

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

31 ↗

(On Diff #204154)

I'm not sure this multiple inheritance is really helping anything here. While looking through the code i kept wondering "why doesn't this function just do the job itself instead of delegating to somebody else" only to have to remind myself that the function it is delegating to is actually a different object, which does not know anything about the bigger picture.

If using composition here wouldn't introduce additional complexities/code (which it doesn't look like it would), I think it might be better to do that instead.

133 ↗

(On Diff #204154)

It doesn't look like process should ever be null. So, I'd suggest replacing the pointer by a reference, and deleting all the null checks.

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

31 ↗

(On Diff #204154)

Hm.., interesting. I think I am starting to understand what's going on here. IIUC, the size of the register context is a constant for any given architecture, but it varies between architectures (i.e., NativeRegisterContextWindows_XXX instances). If that's the case, then it sounds like the data_size should be an argument to the NativeRegisterContextWindows constructor, instead it being passed down for every call. Would that work?

[asmith]

Address reviewers comments

[asmith]

Fix caps for WoW64

[Hui]

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

31 ↗

(On Diff #204154)

Do you mean to move what is in ProcessDebugger into nativeprocess instead?

[labath]

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

31 ↗

(On Diff #204154)

No, just instead of inheriting from a ProcessDebugger, making it a member variable instead. Unless there are reasons which make that hard/impossible...

[Hui]

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

31 ↗

(On Diff #204154)

Debug event callback in ProcessDebugger need to be overridden by both processwindows and nativeprocess. Not sure if the change is doable. Also same change is required to processwindows. That will make the patch a little bigger.

[labath]

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

46–50

I guess these shouldn't be public as these object should be constructed through the factory, right?

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

32–37

new doesn't fail. This is dead code.

53–58

This can't ever be true.

69–90

These look like they should be operating invariants (at most guarded by an assertion, but probably even that is not needed). Right now, they're just making it hard to figure out what this function actually does...

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_WoW64.cpp

83

How about a helper method like NativeThreadWindows &GetThread() to hide the static_cast everywhere. You could also change the constructor argument to NativeThreadWindows& to make it clear that the register context is only to be constructed with threads of this type.

a GetThreadHandle might be nice too since fetching the thread seems to be invariably followed by the GetHostThread().GetNativeThread().GetSystemHandle() blurb.

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

81–85

What's the purpose of this function? It seems to be only called immediately before deleting the thread, so nobody gets to read it's stop reason anyway...

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

31 ↗

(On Diff #204154)

Ok, let's leave it like that for now. However, I find it very weird that the ProcessDebugger class takes a "delegate" object *and* it requires you to inherit from it to override some of it's methods. Seems like one of these extension mechanisms ought to be enough.

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

31 ↗

(On Diff #204154)

I still think the register context size would be better handled as an constructor argument.

[asmith]

removed the "clang-format off" in a few places

[asmith]

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

32–37

The code is copied from/following the other targets. Maybe all the targets could be cleaned up in another PR. For example Arm64,

NativeRegisterContextLinux_arm64::ReadAllRegisterValues()

data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
if (!data_sp)

53–58

Copied from Arm64

[asmith]

Add a define for STATUS_WX86_BREAKPOINT.

[labath]

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

32–37

Done in r364744.

53–58

Done in r364754.

[asmith]

removed the redundant null checks
added GetThreadHandle to simplify code

[asmith]

I believe this address all the comments.

[labath]

I am sorry, but the code still seems a lot more verbose to me than it should be needed to implement the given functionality. I'd like to understand why/if it's that necessary..

lldb/source/Plugins/Process/Utility/RegisterContextWindows_WoW64.cpp

72–105 ↗

(On Diff #210480)

This is very verbose. You could just have GetRegisterInfo return g_register_infos_WoW64 directly (and similarly for other functions. Then all you'd be left with is putting an assert(target_arch.GetMachine() == llvm::Triple::x86) into the RegisterContextWindows_WoW64 constructor. Same goes for other register context classes.

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

Why is all of this complexity necessary? Couldn't you just switch on the target architecture in CreateRegisterInfoInterface in NativeRegisterContextWindows_x86_64.cpp and create either RegisterContextWindows_WoW64 or RegisterContextWindows_x86_64 ?

In fact, if RegisterContextWindows_WoW64 is identical to RegisterContextWindows_i386, then why do you even need the _WoW64 version of the class in the first place? FWIW, linux also does not have a RegisterContextLinux_32_bit_process_on_64_bit_kernel class...

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

286–287

I think it would be better to return an error here. llvm::errc::not_supported ?

312–338

This doesn't seem right. You only retrieve the module list the first time this function was called, but the list of loaded modules can change over time. You probably need to invalidate this cache every time the process is resumed...

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

46–50

This doesn't seem to be addressed.

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

105–110

Are these suspend/resume calls necessary? You should be able to assume that the process is stopped (due to breakpoint, exception or whatever). Nobody will be calling functions that get/set registers on a running process. (linux does not support that either, but we don't bother explicitly stopping the process before we attempt to do this).

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

140–200

IIUC, none of the current register contexts implement watchpoint support right now. Which means this code is dead/untested. Let's remove it for the time being...

lldb/unittests/tools/lldb-server/tests/TestClient.cpp

258–259

This doesn't sound right. If the inferior exits, lldb-server should exit too. It doesn't matter if that's implemented via SIGHUP, or whatever. If some of the tests don't pass because of this, maybe you can disable the tests for the time being..

[amccarth]

In D63165#1541944, @clayborg wrote:

In D63165#1540606, @Hui wrote:

In D63165#1539118, @amccarth wrote:

Sorry for the stupid question, but ...

What exactly is meant here by "Native"? How is a NativeProcessWindows different from ProcessWindows?

The Native*** classes are meant to be used from lldb-server. They look somewhat similar to their non-native counterpart because they still do debugging, but they're a lot dumber, because they only deal with basic process control, and none of the fancy symbolic stuff that you'd need debug info for.

They differ in APIs but most of them have common implementations. The APIs from native process classes are more easy to apply process/thread control.
Hope the native and non-native ones can be merged. The similar thing to the RegisterContext and NativeRegisterContext classes.

The other thing is that using "native" classes can avoid linking a lot of unnecessary lldb libs (LLDB plugins or whatever comes with the plugins) to lldb-server.
The nativeprocesswindows could just be a pass-through to processwindows plugin, but the usage is a sort of strange since the
lldb-server needs to initialize the plugin, create a target, and create a instance just like what lldb does. This means literally
there will be two lldb debuggers, one on host and the other one on remote. It is doable, but not that applicable.

So the idea is ProcessWindows will be deleted once lldb-server supports windows debugging. A bit of history here: when we first started we started making ProcessXXXX for each platform (mac, linux, windows). Then we thought about remote debugging and decided to have everyone just make a lldb-server for their platform and even when we are locally debugging, we launch a lldb-server. This is how linux, macOS, the BSDs and other targets do it. Why? Because if you do it the other way you have more code to support: one native plug-in and one remote plug-in. This means the remote debugging usually has more issues since it is the less tested debugging scenario. It also means that if you had a native process implementation only, like ProcessWindows is currently, you can't remotely debug to a windows machine.

So yes there is duplicated code for now, but ProcessWindows.cpp and ThreadWindows.cpp should go away in the near future once lldb-server takes over so the temporary code duplication is just to keep things working until lldb-server takes over.

Thanks for all the clarification. "Native" is an overloaded term in LLDB.

I'm trying to think through the implications of this always-use-an-lldb-server approach on cross-platform postmortem debugging. I'll have to do some studying, but I guess this patch doesn't change anything in that regard.

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

96

This code appears to be based on ProcessWindows::DoResume, which has a pending patch to fix a race condition by moving the checking of the exception record to later in the function. I assume this will need the same fix. See https://reviews.llvm.org/D62183 for details.

[labath]

In D63165#1591665, @amccarth wrote:

I'm trying to think through the implications of this always-use-an-lldb-server approach on cross-platform postmortem debugging. I'll have to do some studying, but I guess this patch doesn't change anything in that regard.

I think the implications of this are zero. In the post mortem case we would still create an (in-process) instance of ProcessMinidump, and it work the the same way as it does now. Just like we create a ProcessElfCore for opening linux core files even though we always use lldb-server (via ProcessGdbRemote) for live debugging.

Pretty much nothing of what lldb-server does is useful for debugging core files anyway. (Though I have had some ideas about creating a mock lldb-server operating on core files for the purposes of testing lldb.)

[Hui]

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

46–50

These constructors contain a call to function template make_unique that is not allowed to access private members of NativeProcessWindows.
Simply do the following could address this concern.

-  auto process_up =
-      std::make_unique<NativeProcessWindows>(launch_info, native_delegate, E);

+  auto process_up = std::unique_ptr<NativeProcessWindows>(
+      new NativeProcessWindows(launch_info, native_delegate, E));

[Hui]

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

105–110

Yes, agreed. But such codes are added to be consistent with what is now in upstream from https://reviews.llvm.org/rL364216. (CacheAllRegisterValues).

[Hui]

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

I think WoW64 is i686 that shall deserve a separate arch specific implementation?

[labath]

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

I am sorry, but I don't follow. Can you repeat the question?

(FWIW, I don't believe that the fact that two things are different from a certain point of view justifies copy-pasting (at least) 150 LOC. If you think it's confusing to use something called "i386" in things dealing with WoW64, you can always typedef the WOW64 context to it, or rename the i386 context to something more generic.)

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

46–50

The make_unique thing is unfortunate, but that is the nature of c++. Since you're concerned about consistency, I'll mention that other classes (e.g. NativeProcessLinux) also prioritize clarifying what is the public interface of a class over the niceness of being able to call make_unique.

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

105–110

Interesting. I don't think it's worth being consistent with that, as that code is hopefully going to go away soon, and lldb-server can offer much stronger guarantees about when these things can be called (due to everything being funneled through the gdb-remote protocol, which doesn't even support sending any packets while the process is running).

However, I am not familiar with windows APIs, so I'll leave this decision up to you...

[asmith]

• Undo the change to the test client
• Remove changes for threads
• Invalidate module cache on loading/unloading DLLs

[asmith]

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

96

Thanks for the heads up

[asmith]

I don't see anything else to address in this review. Comments?

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

I don't want this to block the review and have removed the code.

[labath]

lldb/source/Plugins/Process/Utility/RegisterContextWindows_i386.cpp

71–104

I think all of this could be bolied down to:

RegisterContextWindows_i386::RegisterContextWindows_i386(
    const ArchSpec &target_arch)
    : lldb_private::RegisterInfoInterface(target_arch),
      m_register_info_p(g_register_infos_i386),
      m_register_info_count(llvm::array_lengthof(g_register_infos_i386)),
      m_user_register_count(llvm::array_lengthof(g_register_infos_i386)) {
  assert(target_arch.GetMachine() == llvm::Triple::x86);
}

In fact, I'd probably not even bother with the member variables, but have the public RegisterContextWindows_i386 functions return the values directly (just like GetGPRSize does).

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

Thanks. FTR, I'm not opposed to splitting these classes again in the future, if we develop a need for them to diverge (though it would be nice to find a way to factor the common parts in that case).

However, there's one more thing that bothers me here. It's this business with constructing a RegisterContextWindows_i386 here, copying the entries out of it, and re-using them elsewhere while asserting that things were done in the right order. It seems very complex, and I'm not sure that complexity is needed. It seems to me like all of that could be removed if you just made the decision which set of registers to use one level up (i.e., in CreateRegisterInfoInterface in NativeRegisterContextWindows_x86_64.cpp. You could just have that function switch on the process byte size, and return RegisterContextWindows_i386 or RegisterContextWindows_x86_64. This is the same way things are done on x86 linux (see NativeRegisterContextLinux_x86_64.cpp).

[labath]

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

Unfortunately NativeRegisterContextLinux_x86_64 is not good example here. It turns I misread, and that class actually switches on the *host* architecture instead of *target*, and its implementation of RegisterContextLinux_x86_64 does indeed the i386 copying tricks that are very similar to what you do here. However, that class has the "excuse" of needing to fix up the register offsets in the i386-on-x86_64 case (for those following along: see UPDATE_REGISTER_INFOS_I386_STRUCT_WITH_X86_64_OFFSETS). You don't need to do anything like that here, so I would hope that we can do something simpler here.

And I'll try to figure out a way to do the linux thing in a saner fashion...

[asmith]

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

142

Are you accepting this review?

[labath]

Are you accepting this review?

No I would still like to see the two comments I made in <D63165#1607877> to be addressed. The last comment was just acknowledging the fact that you (or is it @Hui? I'm not sure who actually writes these patches...) were following the existing pattern in the linux register contexts. However, the pattern over there is for a reason, and that reason does not apply here. That doesn't make the linux code less ugly (probably the opposite), but it does mean we shouldn't try to emulate it if there are better options available...

[asmith]

I can make the one simplification but Im not sure what you are asking as far as the refactoring. Provide an example and I will try to accommodate your request. I'm not going to be able to spend much more time on lldb patches though.

[labath]

In D63165#1611924, @asmith wrote:

I can make the one simplification but Im not sure what you are asking as far as the refactoring. Provide an example and I will try to accommodate your request. I'm not going to be able to spend much more time on lldb patches though.

I think you should change the CreateRegisterInfoInterface in NativeRegisterContextWindows_x86_64.cpp to something like:

static RegisterInfoInterface *
CreateRegisterInfoInterface(const ArchSpec &target_arch) {
  assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
         "Register setting path assumes this is a 64-bit host");
  switch (target.arch.GetAddressByteSize()) {
  case 8:
    return new RegisterContextWindows_x86_64(target_arch);
  case 8:
    return new RegisterContextWindows_i386(target_arch);
  default:
    llvm_unreachable("Unsupported byte size!");
}

Then you should be able to remove all of the g_private_reg_interface business from RegisterContextWindows_x86_64.cpp, as the RegisterContextWindows_x86_64 will only ever be called with a 64-bit ArchSpec. In fact, since you already have NativeRegisterContextWindows_WoW64, I am not sure if even the 4 branch is needed, as in case of GetAddressByteSize() == 4, we should end up in CreateRegisterInfoInterface in NativeRegisterContextWindows_WoW64 (which already correctly constructs a RegisterContextWindows_i386).

[asmith]

Any last comments before this is committed?

[labath]

I am still waiting for the g_private_reg_interface thingy to be removed, or for an explanation of why it cannot be done...

[asmith]

This is done.

[labath]

This looks great to me. Thank you for your patience.

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

10

I think this include should no longer be needed.

[teemperor]

This commit seems to have broken the windows bot: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/7780

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

 #include <cstdint>
 
+int main() {
+#if defined(__x86_64__)
   struct alignas(16) xmm_t {
     uint64_t a, b;
   };
-
-int main() {
   uint64_t r8 = 0x0102030405060708;
   uint64_t r9 = 0x1112131415161718;
   uint64_t r10 = 0x2122232425262728;
   uint64_t r11 = 0x3132333435363738;
   uint64_t r12 = 0x4142434445464748;
   uint64_t r13 = 0x5152535455565758;
   uint64_t r14 = 0x6162636465666768;
   uint64_t r15 = 0x7172737475767778;
asm volatile("movq    %0, %%r8\n\t"
                "int3"
                :
                : "g"(r8), "g"(r9), "g"(r10), "g"(r11), "g"(r12), "g"(r13),
                  "g"(r14), "g"(r15), "m"(xmm8), "m"(xmm9), "m"(xmm10),
                  "m"(xmm11), "m"(xmm12), "m"(xmm13), "m"(xmm14), "m"(xmm15)
                : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
                  "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
                  "%xmm14", "%xmm15");
-
+#endif
   return 0;
 }

lldb/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_i386.cpp
+  RegisterContextWindows_x86_64.cpp
   RegisterInfoPOSIX_arm.cpp
   RegisterInfoPOSIX_arm64.cpp
   RegisterInfoPOSIX_ppc64le.cpp
   StopInfoMachException.cpp
   ThreadMemory.cpp
   UnwindLLDB.cpp
   UnwindMacOSXFrameBackchain.cpp
 

lldb/source/Plugins/Process/Utility/RegisterContextWindows_i386.h

+//===-- RegisterContextWindows_i386.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_i386_H_
+#define liblldb_RegisterContextWindows_i386_H_
+
+#include "RegisterInfoInterface.h"
+
+class RegisterContextWindows_i386 : public lldb_private::RegisterInfoInterface {
+public:
+  RegisterContextWindows_i386(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;
+};
+
+#endif

lldb/source/Plugins/Process/Utility/RegisterContextWindows_i386.cpp

+//===-- RegisterContextWindows_i386.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_i386.h"
+#include "RegisterContext_x86.h"
+#include "lldb-x86-register-enums.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+namespace {
+// Declare our g_register_infos structure.
+typedef struct _GPR {
+  uint32_t eax;
+  uint32_t ebx;
+  uint32_t ecx;
+  uint32_t edx;
+  uint32_t edi;
+  uint32_t esi;
+  uint32_t ebp;
+  uint32_t esp;
+  uint32_t eip;
+  uint32_t eflags;
+  uint32_t cs;
+  uint32_t fs;
+  uint32_t gs;
+  uint32_t ss;
+  uint32_t ds;
+  uint32_t es;
+} GPR;
+
+#define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
+
+#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##_i386 }, nullptr, nullptr,    \
+         nullptr, 0                                                            \
+  }
+
+// clang-format off
+static RegisterInfo g_register_infos_i386[] = {
+// General purpose registers     EH_Frame              DWARF                 Generic                     Process Plugin
+//  ===========================  ==================    ================      =========================   ====================
+    DEFINE_GPR(eax,   nullptr,   ehframe_eax_i386,     dwarf_eax_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ebx,   nullptr,   ehframe_ebx_i386,     dwarf_ebx_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ecx,   nullptr,   ehframe_ecx_i386,     dwarf_ecx_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(edx,   nullptr,   ehframe_edx_i386,     dwarf_edx_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(edi,   nullptr,   ehframe_edi_i386,     dwarf_edi_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(esi,   nullptr,   ehframe_esi_i386,     dwarf_esi_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ebp,   "fp",      ehframe_ebp_i386,     dwarf_ebp_i386,       LLDB_REGNUM_GENERIC_FP,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(esp,   "sp",      ehframe_esp_i386,     dwarf_esp_i386,       LLDB_REGNUM_GENERIC_SP,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(eip,   "pc",      ehframe_eip_i386,     dwarf_eip_i386,       LLDB_REGNUM_GENERIC_PC,     LLDB_INVALID_REGNUM),
+    DEFINE_GPR(eflags, "flags",  ehframe_eflags_i386,  dwarf_eflags_i386,    LLDB_REGNUM_GENERIC_FLAGS,  LLDB_INVALID_REGNUM),
+    DEFINE_GPR(cs,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_cs_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(fs,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_fs_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(gs,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_gs_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ss,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_ss_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(ds,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_ds_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+    DEFINE_GPR(es,     nullptr,  LLDB_INVALID_REGNUM,  dwarf_es_i386,        LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
+};
+// clang-format on
+} // namespace
+
+RegisterContextWindows_i386::RegisterContextWindows_i386(
+    const ArchSpec &target_arch)
+    : lldb_private::RegisterInfoInterface(target_arch) {
+  assert(target_arch.GetMachine() == llvm::Triple::x86);
+}
+
+const RegisterInfo *RegisterContextWindows_i386::GetRegisterInfo() const {
+  return g_register_infos_i386;
+}
+
+uint32_t RegisterContextWindows_i386::GetRegisterCount() const {
+  return llvm::array_lengthof(g_register_infos_i386);
+}
+
+uint32_t RegisterContextWindows_i386::GetUserRegisterCount() const {
+  return llvm::array_lengthof(g_register_infos_i386);
+}
+
+size_t RegisterContextWindows_i386::GetGPRSize() const { return sizeof(GPR); }

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.h

+//===-- RegisterContextWindows_x86_64.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_x86_64_H_
+#define liblldb_RegisterContextWindows_x86_64_H_
+
+#include "RegisterInfoInterface.h"
+
+class RegisterContextWindows_x86_64
+    : public lldb_private::RegisterInfoInterface {
+public:
+  RegisterContextWindows_x86_64(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;
+};
+
+#endif

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.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_x86_64.h"
+#include "RegisterContextWindows_i386.h"
+#include "RegisterContext_x86.h"
+#include "lldb-x86-register-enums.h"
+
+#include <vector>
+
+using namespace lldb_private;
+using namespace lldb;
+
+namespace {
+typedef struct _GPR {
+  uint64_t rax;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rbx;
+  uint64_t rsp;
+  uint64_t rbp;
+  uint64_t rsi;
+  uint64_t rdi;
+  uint64_t r8;
+  uint64_t r9;
+  uint64_t r10;
+  uint64_t r11;
+  uint64_t r12;
+  uint64_t r13;
+  uint64_t r14;
+  uint64_t r15;
+  uint64_t rip;
+  uint64_t rflags;
+  uint16_t cs;
+  uint16_t fs;
+  uint16_t gs;
+  uint16_t ss;
+  uint16_t ds;
+  uint16_t es;
+} GPR;
+
+#define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
+#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                                                            \
+  }
+
+typedef struct _FPReg {
+  XMMReg xmm0;
+  XMMReg xmm1;
+  XMMReg xmm2;
+  XMMReg xmm3;
+  XMMReg xmm4;
+  XMMReg xmm5;
+  XMMReg xmm6;
+  XMMReg xmm7;
+  XMMReg xmm8;
+  XMMReg xmm9;
+  XMMReg xmm10;
+  XMMReg xmm11;
+  XMMReg xmm12;
+  XMMReg xmm13;
+  XMMReg xmm14;
+  XMMReg xmm15;
+} FPReg;
+
+#define FPR_OFFSET(regname)                                                    \
+  (sizeof(GPR) + LLVM_EXTENSION offsetof(FPReg, regname))
+
+#define DEFINE_XMM(reg)                                                        \
+#reg, NULL, sizeof(((FPReg *)nullptr)->reg), FPR_OFFSET(reg), eEncodingUint, \
+      eFormatVectorOfUInt64,                                                   \
+      {dwarf_##reg##_x86_64, dwarf_##reg##_x86_64, LLDB_INVALID_REGNUM,        \
+       LLDB_INVALID_REGNUM, 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),
+    DEFINE_XMM(xmm0),
+    DEFINE_XMM(xmm1),
+    DEFINE_XMM(xmm2),
+    DEFINE_XMM(xmm3),
+    DEFINE_XMM(xmm4),
+    DEFINE_XMM(xmm5),
+    DEFINE_XMM(xmm6),
+    DEFINE_XMM(xmm7),
+    DEFINE_XMM(xmm8),
+    DEFINE_XMM(xmm9),
+    DEFINE_XMM(xmm10),
+    DEFINE_XMM(xmm11),
+    DEFINE_XMM(xmm12),
+    DEFINE_XMM(xmm13),
+    DEFINE_XMM(xmm14),
+    DEFINE_XMM(xmm15)
+};
+// clang-format on
+} // namespace
+
+RegisterContextWindows_x86_64::RegisterContextWindows_x86_64(
+    const ArchSpec &target_arch)
+    : lldb_private::RegisterInfoInterface(target_arch) {
+  assert(target_arch.GetMachine() == llvm::Triple::x86_64);
+}
+
+const RegisterInfo *RegisterContextWindows_x86_64::GetRegisterInfo() const {
+  return g_register_infos_x86_64;
+}
+
+uint32_t RegisterContextWindows_x86_64::GetRegisterCount() const {
+  return llvm::array_lengthof(g_register_infos_x86_64);
+}
+
+uint32_t RegisterContextWindows_x86_64::GetUserRegisterCount() const {
+  return llvm::array_lengthof(g_register_infos_x86_64);
+}
+
+size_t RegisterContextWindows_x86_64::GetGPRSize() const { return sizeof(GPR); }

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

 
 add_lldb_library(lldbPluginProcessWindowsCommon PLUGIN
   DebuggerThread.cpp
   LocalDebugDelegate.cpp
+  NativeProcessWindows.cpp
+  NativeRegisterContextWindows.cpp
+  NativeRegisterContextWindows_i386.cpp
+  NativeRegisterContextWindows_WoW64.cpp
+  NativeRegisterContextWindows_x86_64.cpp
+  NativeThreadWindows.cpp
   ProcessDebugger.cpp
   ProcessWindows.cpp
   ProcessWindowsLog.cpp
   RegisterContextWindows.cpp
   TargetThreadWindows.cpp
   x64/RegisterContextWindows_x64.cpp
   x86/RegisterContextWindows_x86.cpp
   # TODO add support for ARM (NT) and ARM64

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

 
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
+#ifndef STATUS_WX86_BREAKPOINT
+#define STATUS_WX86_BREAKPOINT 0x4000001FL // For WOW64 
+#endif
+
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 struct DebugLaunchContext {
   DebugLaunchContext(DebuggerThread *thread,
                      const ProcessLaunchInfo &launch_info)
       : m_thread(thread), m_launch_info(launch_info) {}
DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
   Log *log =
       ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION);
   if (m_is_shutting_down) {
     // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a magic
     // exception that
     // we use simply to wake up the DebuggerThread so that we can close out the
     // debug loop.
     if (m_pid_to_detach != 0 &&
-        info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT) {
+        (info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT ||
+         info.ExceptionRecord.ExceptionCode == STATUS_WX86_BREAKPOINT)) {
       LLDB_LOG(log, "Breakpoint exception is cue to detach from process {0:x}",
                m_pid_to_detach.load());
       ::DebugActiveProcessStop(m_pid_to_detach);
       m_detached = true;
     }
 
     // Don't perform any blocking operations while we're shutting down.  That
     // will cause TerminateProcess -> WaitForSingleObject to time out.

lldb/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 "IDebugDelegate.h"
+#include "ProcessDebugger.h"
+
+namespace lldb_private {
+
+class HostProcess;
+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 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;
+
+  // ProcessDebugger 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;
+  void OnLoadDll(const ModuleSpec &module_spec,
+                 lldb::addr_t module_addr) override;
+  void OnUnloadDll(lldb::addr_t module_addr) override;
+
+protected:
+  NativeThreadWindows *GetThreadByID(lldb::tid_t thread_id);
+
+  bool FindSoftwareBreakpoint(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 = "");
+
+private:
+  ArchSpec m_arch;
+
+  NativeProcessWindows(ProcessLaunchInfo &launch_info, NativeDelegate &delegate,
+                       llvm::Error &E);
+
+  NativeProcessWindows(lldb::pid_t pid, int terminal_fd,
+                       NativeDelegate &delegate, llvm::Error &E);
+
+  Status CacheLoadedModules();
+  std::map<lldb_private::FileSpec, lldb::addr_t> m_loaded_modules;
+};
+
+//------------------------------------------------------------------
+// NativeDebugDelegate
+//------------------------------------------------------------------
+class NativeDebugDelegate : public IDebugDelegate {
+public:
+  NativeDebugDelegate(NativeProcessWindows &process) : m_process(process) {}
+
+  void OnExitProcess(uint32_t exit_code) { m_process.OnExitProcess(exit_code); }
+
+  void OnDebuggerConnected(lldb::addr_t image_base) {
+    m_process.OnDebuggerConnected(image_base);
+  }
+
+  ExceptionResult OnDebugException(bool first_chance,
+                                   const ExceptionRecord &record) {
+    return m_process.OnDebugException(first_chance, record);
+  }
+
+  void OnCreateThread(const HostThread &thread) {
+    m_process.OnCreateThread(thread);
+  }
+
+  void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) {
+    m_process.OnExitThread(thread_id, exit_code);
+  }
+
+  void OnLoadDll(const lldb_private::ModuleSpec &module_spec,
+                 lldb::addr_t module_addr) {
+    m_process.OnLoadDll(module_spec, module_addr);
+  }
+
+  void OnUnloadDll(lldb::addr_t module_addr) {
+    m_process.OnUnloadDll(module_addr);
+  }
+
+  void OnDebugString(const std::string &string) {
+    m_process.OnDebugString(string);
+  }
+
+  void OnDebuggerError(const Status &error, uint32_t type) {
+    return m_process.OnDebuggerError(error, type);
+  }
+
+private:
+  NativeProcessWindows &m_process;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef liblldb_NativeProcessWindows_h_

lldb/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 "lldb/Utility/State.h"
+#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.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"
+
+#include <tlhelp32.h>
+
+#pragma warning(disable : 4005)
+#include "winternl.h"
+#include <ntstatus.h>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm;
+
+namespace lldb_private {
+
+NativeProcessWindows::NativeProcessWindows(ProcessLaunchInfo &launch_info,
+                                           NativeDelegate &delegate,
+                                           llvm::Error &E)
+    : NativeProcessProtocol(LLDB_INVALID_PROCESS_ID,
+                            launch_info.GetPTY().ReleaseMasterFileDescriptor(),
+                            delegate),
+      ProcessDebugger(), m_arch(launch_info.GetArchitecture()) {
+  ErrorAsOutParameter EOut(&E);
+  DebugDelegateSP delegate_sp(new NativeDebugDelegate(*this));
+  E = LaunchProcess(launch_info, delegate_sp).ToError();
+  if (E)
+    return;
+
+  SetID(GetDebuggedProcessId());
+}
+
+NativeProcessWindows::NativeProcessWindows(lldb::pid_t pid, int terminal_fd,
+                                           NativeDelegate &delegate,
+                                           llvm::Error &E)
+    : NativeProcessProtocol(pid, terminal_fd, delegate), ProcessDebugger() {
+  ErrorAsOutParameter EOut(&E);
+  DebugDelegateSP delegate_sp(new NativeDebugDelegate(*this));
+  ProcessAttachInfo attach_info;
+  attach_info.SetProcessID(pid);
+  E = AttachProcess(pid, attach_info, delegate_sp).ToError();
+  if (E)
+    return;
+
+  SetID(GetDebuggedProcessId());
+
+  ProcessInstanceInfo info;
+  if (!Host::GetProcessInfo(pid, info)) {
+    E = createStringError(inconvertibleErrorCode(),
+                          "Cannot get process information");
+    return;
+  }
+  m_arch = info.GetArchitecture();
+}
+
+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();
+  if (state == eStateStopped || state == eStateCrashed) {
+    LLDB_LOG(log, "process {0} is in state {1}.  Resuming...",
+             GetDebuggedProcessId(), state);
+    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)
+        continue;
+
+      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(
+            "NativeProcessWindows::%s (): unexpected state %s specified "
+            "for pid %" PRIu64 ", tid %" PRIu64,
+            __FUNCTION__, StateAsCString(action->state), GetID(),
+            thread->GetID());
+      }
+    }
+
+    if (failed) {
+      error.SetErrorString("NativeProcessWindows::DoResume failed");
+    } else {
+      SetState(eStateRunning);
+    }
+
+    // Resume the debug loop.
+    ExceptionRecordSP active_exception =
+        m_session_data->m_debugger->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.
+      m_session_data->m_debugger->ContinueAsyncException(
+          ExceptionResult::MaskException);
+    }
+  } else {
+    LLDB_LOG(log, "error: process {0} is in state {1}.  Returning...",
+             GetDebuggedProcessId(), 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
+      LLDB_LOG(log, "Detaching process error: {0}", error);
+  } else {
+    error.SetErrorStringWithFormat("error: process {0} in state = {1}, but "
+                                   "cannot detach it 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() {
+  StateType state = GetState();
+  return DestroyProcess(state);
+}
+
+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 {
+  // Not available on this target.
+  return llvm::errc::not_supported;
+}
+
+bool NativeProcessWindows::FindSoftwareBreakpoint(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::CacheLoadedModules() {
+  Status error;
+  if (!m_loaded_modules.empty())
+    return Status();
+
+  // Retrieve loaded modules by a Target/Module free implemenation.
+  AutoHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetID()));
+  if (snapshot.IsValid()) {
+    MODULEENTRY32W me;
+    me.dwSize = sizeof(MODULEENTRY32W);
+    if (Module32FirstW(snapshot.get(), &me)) {
+      do {
+        std::string path;
+        if (!llvm::convertWideToUTF8(me.szExePath, path))
+          continue;
+
+        FileSpec file_spec(path);
+        FileSystem::Instance().Resolve(file_spec);
+        m_loaded_modules[file_spec] = (addr_t)me.modBaseAddr;
+      } while (Module32Next(snapshot.get(), &me));
+    }
+
+    if (!m_loaded_modules.empty())
+      return Status();
+  }
+
+  error.SetError(::GetLastError(), lldb::ErrorType::eErrorTypeWin32);
+  return error;
+}
+
+Status NativeProcessWindows::GetLoadedModuleFileSpec(const char *module_path,
+                                                     FileSpec &file_spec) {
+  Status error = CacheLoadedModules();
+  if (error.Fail())
+    return error;
+
+  FileSpec module_file_spec(module_path);
+  FileSystem::Instance().Resolve(module_file_spec);
+  for (auto &it : m_loaded_modules) {
+    if (it.first == module_file_spec) {
+      file_spec = it.first;
+      return Status();
+    }
+  }
+  return Status("Module (%s) not found in process %" PRIu64 "!",
+                module_file_spec.GetCString(), GetID());
+}
+
+Status
+NativeProcessWindows::GetFileLoadAddress(const llvm::StringRef &file_name,
+                                         lldb::addr_t &load_addr) {
+  Status error = CacheLoadedModules();
+  if (error.Fail())
+    return error;
+
+  load_addr = LLDB_INVALID_ADDRESS;
+  FileSpec file_spec(file_name);
+  FileSystem::Instance().Resolve(file_spec);
+  for (auto &it : m_loaded_modules) {
+    if (it.first == file_spec) {
+      load_addr = it.second;
+      return Status();
+    }
+  }
+  return Status("Can't get loaded address of file (%s) in process %" PRIu64 "!",
+                file_spec.GetCString(), GetID());
+}
+
+void NativeProcessWindows::OnExitProcess(uint32_t exit_code) {
+  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, true);
+}
+
+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}",
+           GetDebuggedProcessId(), image_base);
+
+  // This is the earliest chance we can resolve the process ID and
+  // architecutre if we don't know them yet.
+  if (GetID() == LLDB_INVALID_PROCESS_ID)
+    SetID(GetDebuggedProcessId());
+
+  if (GetArchitecture().GetMachine() == llvm::Triple::UnknownArch) {
+    ProcessInstanceInfo process_info;
+    if (!Host::GetProcessInfo(GetDebuggedProcessId(), 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 main thread.
+  assert(m_threads.empty());
+  m_threads.push_back(llvm::make_unique<NativeThreadWindows>(
+      *this, m_session_data->m_debugger->GetMainThread()));
+}
+
+ExceptionResult
+NativeProcessWindows::OnDebugException(bool first_chance,
+                                       const ExceptionRecord &record) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EXCEPTION);
+  llvm::sys::ScopedLock lock(m_mutex);
+
+  // Let the debugger establish the internal status.
+  ProcessDebugger::OnDebugException(first_chance, record);
+
+  static bool initial_stop = false;
+  if (!first_chance) {
+    SetState(eStateStopped, false);
+  }
+
+  ExceptionResult result = ExceptionResult::SendToApplication;
+  switch (record.GetExceptionCode()) {
+  case STATUS_SINGLE_STEP:
+  case STATUS_WX86_SINGLE_STEP:
+    StopThread(record.GetThreadID(), StopReason::eStopReasonTrace);
+    SetState(eStateStopped, true);
+
+    // Continue the debugger.
+    return ExceptionResult::MaskException;
+
+  case STATUS_BREAKPOINT:
+  case STATUS_WX86_BREAKPOINT:
+    if (FindSoftwareBreakpoint(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 '0xCC'
+        uint64_t pc = register_context.GetPC() - 1;
+        register_context.SetPC(pc);
+      }
+
+      SetState(eStateStopped, true);
+      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);
+
+      // Hit the initial stop. Continue the application.
+      return ExceptionResult::BreakInDebugger;
+    }
+
+    // Fall through
+  default:
+    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);
+    }
+
+    // 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();) {
+    if ((*t)->GetID() == thread_id) {
+      t = m_threads.erase(t);
+    } else {
+      ++t;
+    }
+  }
+}
+
+void NativeProcessWindows::OnLoadDll(const ModuleSpec &module_spec,
+                                     lldb::addr_t module_addr) {
+  // Simply invalidate the cached loaded modules.
+  if (!m_loaded_modules.empty())
+    m_loaded_modules.clear();
+}
+
+void NativeProcessWindows::OnUnloadDll(lldb::addr_t module_addr) {
+  if (!m_loaded_modules.empty())
+    m_loaded_modules.clear();
+}
+
+llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
+NativeProcessWindows::Factory::Launch(
+    ProcessLaunchInfo &launch_info,
+    NativeProcessProtocol::NativeDelegate &native_delegate,
+    MainLoop &mainloop) const {
+  Error E = Error::success();
+  auto process_up = std::unique_ptr<NativeProcessWindows>(
+      new NativeProcessWindows(launch_info, native_delegate, E));
+  if (E)
+    return std::move(E);
+  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 {
+  Error E = Error::success();
+  // Set pty master fd invalid since it is not available.
+  auto process_up = std::unique_ptr<NativeProcessWindows>(
+      new NativeProcessWindows(pid, -1, native_delegate, E));
+  if (E)
+    return std::move(E);
+  return std::move(process_up);
+}
+} // namespace lldb_private

lldb/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"
+#include "lldb/Utility/DataBufferHeap.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:
+  lldb::thread_t GetThreadHandle() const;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_h_

lldb/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"
+#include "ProcessWindowsLog.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+NativeRegisterContextWindows::NativeRegisterContextWindows(
+    NativeThreadProtocol &thread, RegisterInfoInterface *reg_info_interface_p)
+    : NativeRegisterContextRegisterInfo(thread, reg_info_interface_p) {}
+
+lldb::thread_t NativeRegisterContextWindows::GetThreadHandle() const {
+  auto wthread = static_cast<NativeThreadWindows *>(&m_thread);
+  return wthread->GetHostThread().GetNativeThread().GetSystemHandle();
+}

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_WoW64.h

+//===-- NativeRegisterContextWindows_WoW64.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_WoW64_h_
+#define liblldb_NativeRegisterContextWindows_WoW64_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_WoW64 : public NativeRegisterContextWindows {
+public:
+  NativeRegisterContextWindows_WoW64(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:
+  Status GPRRead(const uint32_t reg, RegisterValue &reg_value);
+  Status GPRWrite(const uint32_t reg, const RegisterValue &reg_value);
+
+private:
+  bool IsGPR(uint32_t reg_index) const;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_WoW64_h_
+#endif // defined(_WIN64)

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_WoW64.cpp

+//===-- NativeRegisterContextWindows_WoW64.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_WoW64.h"
+
+#include "NativeThreadWindows.h"
+#include "Plugins/Process/Utility/RegisterContextWindows_i386.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/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#define REG_CONTEXT_SIZE sizeof(::WOW64_CONTEXT)
+
+namespace {
+static const uint32_t g_gpr_regnums_WoW64[] = {
+    lldb_eax_i386,      lldb_ebx_i386,    lldb_ecx_i386, lldb_edx_i386,
+    lldb_edi_i386,      lldb_esi_i386,    lldb_ebp_i386, lldb_esp_i386,
+    lldb_eip_i386,      lldb_eflags_i386, lldb_cs_i386,  lldb_fs_i386,
+    lldb_gs_i386,       lldb_ss_i386,     lldb_ds_i386,  lldb_es_i386,
+    LLDB_INVALID_REGNUM // Register set must be terminated with this flag.
+};
+
+static const RegisterSet g_reg_sets_WoW64[] = {
+    {"General Purpose Registers", "gpr",
+     llvm::array_lengthof(g_gpr_regnums_WoW64) - 1, g_gpr_regnums_WoW64},
+};
+enum { k_num_register_sets = 1 };
+
+static const DWORD kWoW64ContextFlags =
+    WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER | WOW64_CONTEXT_SEGMENTS;
+
+} // namespace
+
+static RegisterInfoInterface *
+CreateRegisterInfoInterface(const ArchSpec &target_arch) {
+  // i686 32bit instruction set.
+  assert((target_arch.GetAddressByteSize() == 4 &&
+          HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
+         "Register setting path assumes this is a 64-bit host");
+  return new RegisterContextWindows_i386(target_arch);
+}
+
+static Status GetWoW64ThreadContextHelper(lldb::thread_t thread_handle,
+                                          PWOW64_CONTEXT context_ptr) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+  memset(context_ptr, 0, sizeof(::WOW64_CONTEXT));
+  context_ptr->ContextFlags = kWoW64ContextFlags;
+  if (!::Wow64GetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} Wow64GetThreadContext failed with error {1}",
+             __FUNCTION__, error);
+    return error;
+  }
+  return Status();
+}
+
+static Status SetWoW64ThreadContextHelper(lldb::thread_t thread_handle,
+                                          PWOW64_CONTEXT context_ptr) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+  if (!::Wow64SetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} Wow64SetThreadContext failed with error {1}",
+             __FUNCTION__, error);
+    return error;
+  }
+  return Status();
+}
+
+NativeRegisterContextWindows_WoW64::NativeRegisterContextWindows_WoW64(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextWindows(native_thread,
+                                   CreateRegisterInfoInterface(target_arch)) {}
+
+bool NativeRegisterContextWindows_WoW64::IsGPR(uint32_t reg_index) const {
+  return (reg_index >= k_first_gpr_i386 && reg_index < k_first_alias_i386);
+}
+
+uint32_t NativeRegisterContextWindows_WoW64::GetRegisterSetCount() const {
+  return k_num_register_sets;
+}
+
+const RegisterSet *
+NativeRegisterContextWindows_WoW64::GetRegisterSet(uint32_t set_index) const {
+  if (set_index >= k_num_register_sets)
+    return nullptr;
+  return &g_reg_sets_WoW64[set_index];
+}
+
+Status NativeRegisterContextWindows_WoW64::GPRRead(const uint32_t reg,
+                                                   RegisterValue &reg_value) {
+  ::WOW64_CONTEXT tls_context;
+  Status error = GetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_eax_i386:
+    reg_value.SetUInt32(tls_context.Eax);
+    break;
+  case lldb_ebx_i386:
+    reg_value.SetUInt32(tls_context.Ebx);
+    break;
+  case lldb_ecx_i386:
+    reg_value.SetUInt32(tls_context.Ecx);
+    break;
+  case lldb_edx_i386:
+    reg_value.SetUInt32(tls_context.Edx);
+    break;
+  case lldb_edi_i386:
+    reg_value.SetUInt32(tls_context.Edi);
+    break;
+  case lldb_esi_i386:
+    reg_value.SetUInt32(tls_context.Esi);
+    break;
+  case lldb_ebp_i386:
+    reg_value.SetUInt32(tls_context.Ebp);
+    break;
+  case lldb_esp_i386:
+    reg_value.SetUInt32(tls_context.Esp);
+    break;
+  case lldb_eip_i386:
+    reg_value.SetUInt32(tls_context.Eip);
+    break;
+  case lldb_eflags_i386:
+    reg_value.SetUInt32(tls_context.EFlags);
+    break;
+  case lldb_cs_i386:
+    reg_value.SetUInt32(tls_context.SegCs);
+    break;
+  case lldb_fs_i386:
+    reg_value.SetUInt32(tls_context.SegFs);
+    break;
+  case lldb_gs_i386:
+    reg_value.SetUInt32(tls_context.SegGs);
+    break;
+  case lldb_ss_i386:
+    reg_value.SetUInt32(tls_context.SegSs);
+    break;
+  case lldb_ds_i386:
+    reg_value.SetUInt32(tls_context.SegDs);
+    break;
+  case lldb_es_i386:
+    reg_value.SetUInt32(tls_context.SegEs);
+    break;
+  }
+
+  return error;
+}
+
+Status
+NativeRegisterContextWindows_WoW64::GPRWrite(const uint32_t reg,
+                                             const RegisterValue &reg_value) {
+  ::WOW64_CONTEXT tls_context;
+  auto thread_handle = GetThreadHandle();
+  Status error = GetWoW64ThreadContextHelper(thread_handle, &tls_context);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_eax_i386:
+    tls_context.Eax = reg_value.GetAsUInt32();
+    break;
+  case lldb_ebx_i386:
+    tls_context.Ebx = reg_value.GetAsUInt32();
+    break;
+  case lldb_ecx_i386:
+    tls_context.Ecx = reg_value.GetAsUInt32();
+    break;
+  case lldb_edx_i386:
+    tls_context.Edx = reg_value.GetAsUInt32();
+    break;
+  case lldb_edi_i386:
+    tls_context.Edi = reg_value.GetAsUInt32();
+    break;
+  case lldb_esi_i386:
+    tls_context.Esi = reg_value.GetAsUInt32();
+    break;
+  case lldb_ebp_i386:
+    tls_context.Ebp = reg_value.GetAsUInt32();
+    break;
+  case lldb_esp_i386:
+    tls_context.Esp = reg_value.GetAsUInt32();
+    break;
+  case lldb_eip_i386:
+    tls_context.Eip = reg_value.GetAsUInt32();
+    break;
+  case lldb_eflags_i386:
+    tls_context.EFlags = reg_value.GetAsUInt32();
+    break;
+  case lldb_cs_i386:
+    tls_context.SegCs = reg_value.GetAsUInt32();
+    break;
+  case lldb_fs_i386:
+    tls_context.SegFs = reg_value.GetAsUInt32();
+    break;
+  case lldb_gs_i386:
+    tls_context.SegGs = reg_value.GetAsUInt32();
+    break;
+  case lldb_ss_i386:
+    tls_context.SegSs = reg_value.GetAsUInt32();
+    break;
+  case lldb_ds_i386:
+    tls_context.SegDs = reg_value.GetAsUInt32();
+    break;
+  case lldb_es_i386:
+    tls_context.SegEs = reg_value.GetAsUInt32();
+    break;
+  }
+
+  return SetWoW64ThreadContextHelper(thread_handle, &tls_context);
+}
+
+Status
+NativeRegisterContextWindows_WoW64::ReadRegister(const RegisterInfo *reg_info,
+                                                 RegisterValue &reg_value) {
+  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 GPRRead(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_WoW64::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  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 GPRWrite(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_WoW64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  const size_t data_size = REG_CONTEXT_SIZE;
+  data_sp = std::make_shared<DataBufferHeap>(data_size, 0);
+  ::WOW64_CONTEXT tls_context;
+  Status error = GetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
+  if (error.Fail())
+    return error;
+
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, &tls_context, data_size);
+  return error;
+}
+
+Status NativeRegisterContextWindows_WoW64::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+  const size_t data_size = REG_CONTEXT_SIZE;
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextWindows_WoW64::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != data_size) {
+    error.SetErrorStringWithFormatv(
+        "data_sp contained mismatched data size, expected {0}, actual {1}",
+        data_size, data_sp->GetByteSize());
+    return error;
+  }
+
+  ::WOW64_CONTEXT tls_context;
+  memcpy(&tls_context, data_sp->GetBytes(), data_size);
+  return SetWoW64ThreadContextHelper(GetThreadHandle(), &tls_context);
+}
+
+Status NativeRegisterContextWindows_WoW64::IsWatchpointHit(uint32_t wp_index,
+                                                           bool &is_hit) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_WoW64::GetWatchpointHitIndex(
+    uint32_t &wp_index, lldb::addr_t trap_addr) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_WoW64::IsWatchpointVacant(uint32_t wp_index,
+                                                              bool &is_vacant) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_WoW64::SetHardwareWatchpointWithIndex(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
+  return Status("unimplemented");
+}
+
+bool NativeRegisterContextWindows_WoW64::ClearHardwareWatchpoint(
+    uint32_t wp_index) {
+  return false;
+}
+
+Status NativeRegisterContextWindows_WoW64::ClearAllHardwareWatchpoints() {
+  return Status("unimplemented");
+}
+
+uint32_t NativeRegisterContextWindows_WoW64::SetHardwareWatchpoint(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags) {
+  return LLDB_INVALID_INDEX32;
+}
+
+lldb::addr_t
+NativeRegisterContextWindows_WoW64::GetWatchpointAddress(uint32_t wp_index) {
+  return LLDB_INVALID_ADDRESS;
+}
+
+uint32_t NativeRegisterContextWindows_WoW64::NumSupportedHardwareWatchpoints() {
+  // Not implemented
+  return 0;
+}
+
+#endif // defined(_WIN64)

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.h

+//===-- NativeRegisterContextWindows_i386.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_i386_h_
+#define liblldb_NativeRegisterContextWindows_i386_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_i386 : public NativeRegisterContextWindows {
+public:
+  NativeRegisterContextWindows_i386(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:
+  Status GPRRead(const uint32_t reg, RegisterValue &reg_value);
+  Status GPRWrite(const uint32_t reg, const RegisterValue &reg_value);
+
+private:
+  bool IsGPR(uint32_t reg_index) const;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_i386_h_
+#endif // defined(_WIN64)

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp

+//===-- NativeRegisterContextWindows_i386.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(_WIN32) && !defined(_WIN64)
+
+#include "NativeRegisterContextWindows_i386.h"
+
+#include "NativeThreadWindows.h"
+#include "Plugins/Process/Utility/RegisterContextWindows_i386.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/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#define REG_CONTEXT_SIZE sizeof(::CONTEXT)
+
+namespace {
+static const uint32_t g_gpr_regnums_i386[] = {
+    lldb_eax_i386,      lldb_ebx_i386,    lldb_ecx_i386, lldb_edx_i386,
+    lldb_edi_i386,      lldb_esi_i386,    lldb_ebp_i386, lldb_esp_i386,
+    lldb_eip_i386,      lldb_eflags_i386, lldb_cs_i386,  lldb_fs_i386,
+    lldb_gs_i386,       lldb_ss_i386,     lldb_ds_i386,  lldb_es_i386,
+    LLDB_INVALID_REGNUM // Register sets must be terminated with this flag.
+};
+
+static const RegisterSet g_reg_sets_i386[] = {
+    {"General Purpose Registers", "gpr",
+     llvm::array_lengthof(g_gpr_regnums_i386) - 1, g_gpr_regnums_i386},
+};
+
+enum { k_num_register_sets = 1 };
+
+} // namespace
+
+static RegisterInfoInterface *
+CreateRegisterInfoInterface(const ArchSpec &target_arch) {
+  assert((HostInfo::GetArchitecture().GetAddressByteSize() == 4) &&
+         "Register setting path assumes this is a 32-bit host");
+  return new RegisterContextWindows_i386(target_arch);
+}
+
+static Status GetThreadContextHelper(lldb::thread_t thread_handle,
+                                     PCONTEXT context_ptr,
+                                     const DWORD control_flag) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  memset(context_ptr, 0, sizeof(::CONTEXT));
+  context_ptr->ContextFlags = control_flag;
+  if (!::GetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} GetThreadContext failed with error {1}", __FUNCTION__,
+             error);
+    return error;
+  }
+  return Status();
+}
+
+static Status SetThreadContextHelper(lldb::thread_t thread_handle,
+                                     PCONTEXT context_ptr) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  if (!::SetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} SetThreadContext failed with error {1}", __FUNCTION__,
+             error);
+    return error;
+  }
+  return Status();
+}
+
+std::unique_ptr<NativeRegisterContextWindows>
+NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return llvm::make_unique<NativeRegisterContextWindows_i386>(target_arch,
+                                                              native_thread);
+}
+
+NativeRegisterContextWindows_i386::NativeRegisterContextWindows_i386(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextWindows(native_thread,
+                                   CreateRegisterInfoInterface(target_arch)) {}
+
+bool NativeRegisterContextWindows_i386::IsGPR(uint32_t reg_index) const {
+  return (reg_index < k_first_alias_i386);
+}
+
+uint32_t NativeRegisterContextWindows_i386::GetRegisterSetCount() const {
+  return k_num_register_sets;
+}
+
+const RegisterSet *
+NativeRegisterContextWindows_i386::GetRegisterSet(uint32_t set_index) const {
+  if (set_index >= k_num_register_sets)
+    return nullptr;
+  return &g_reg_sets_i386[set_index];
+}
+
+Status NativeRegisterContextWindows_i386::GPRRead(const uint32_t reg,
+                                                  RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
+  Status error =
+      GetThreadContextHelper(GetThreadHandle(), &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_eax_i386:
+    reg_value.SetUInt32(tls_context.Eax);
+    break;
+  case lldb_ebx_i386:
+    reg_value.SetUInt32(tls_context.Ebx);
+    break;
+  case lldb_ecx_i386:
+    reg_value.SetUInt32(tls_context.Ecx);
+    break;
+  case lldb_edx_i386:
+    reg_value.SetUInt32(tls_context.Edx);
+    break;
+  case lldb_edi_i386:
+    reg_value.SetUInt32(tls_context.Edi);
+    break;
+  case lldb_esi_i386:
+    reg_value.SetUInt32(tls_context.Esi);
+    break;
+  case lldb_ebp_i386:
+    reg_value.SetUInt32(tls_context.Ebp);
+    break;
+  case lldb_esp_i386:
+    reg_value.SetUInt32(tls_context.Esp);
+    break;
+  case lldb_eip_i386:
+    reg_value.SetUInt32(tls_context.Eip);
+    break;
+  case lldb_eflags_i386:
+    reg_value.SetUInt32(tls_context.EFlags);
+    break;
+  case lldb_cs_i386:
+    reg_value.SetUInt32(tls_context.SegCs);
+    break;
+  case lldb_fs_i386:
+    reg_value.SetUInt32(tls_context.SegFs);
+    break;
+  case lldb_gs_i386:
+    reg_value.SetUInt32(tls_context.SegGs);
+    break;
+  case lldb_ss_i386:
+    reg_value.SetUInt32(tls_context.SegSs);
+    break;
+  case lldb_ds_i386:
+    reg_value.SetUInt32(tls_context.SegDs);
+    break;
+  case lldb_es_i386:
+    reg_value.SetUInt32(tls_context.SegEs);
+    break;
+  }
+
+  return error;
+}
+
+Status
+NativeRegisterContextWindows_i386::GPRWrite(const uint32_t reg,
+                                            const RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
+  auto thread_handle = GetThreadHandle();
+  Status error =
+      GetThreadContextHelper(thread_handle, &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_eax_i386:
+    tls_context.Eax = reg_value.GetAsUInt32();
+    break;
+  case lldb_ebx_i386:
+    tls_context.Ebx = reg_value.GetAsUInt32();
+    break;
+  case lldb_ecx_i386:
+    tls_context.Ecx = reg_value.GetAsUInt32();
+    break;
+  case lldb_edx_i386:
+    tls_context.Edx = reg_value.GetAsUInt32();
+    break;
+  case lldb_edi_i386:
+    tls_context.Edi = reg_value.GetAsUInt32();
+    break;
+  case lldb_esi_i386:
+    tls_context.Esi = reg_value.GetAsUInt32();
+    break;
+  case lldb_ebp_i386:
+    tls_context.Ebp = reg_value.GetAsUInt32();
+    break;
+  case lldb_esp_i386:
+    tls_context.Esp = reg_value.GetAsUInt32();
+    break;
+  case lldb_eip_i386:
+    tls_context.Eip = reg_value.GetAsUInt32();
+    break;
+  case lldb_eflags_i386:
+    tls_context.EFlags = reg_value.GetAsUInt32();
+    break;
+  case lldb_cs_i386:
+    tls_context.SegCs = reg_value.GetAsUInt32();
+    break;
+  case lldb_fs_i386:
+    tls_context.SegFs = reg_value.GetAsUInt32();
+    break;
+  case lldb_gs_i386:
+    tls_context.SegGs = reg_value.GetAsUInt32();
+    break;
+  case lldb_ss_i386:
+    tls_context.SegSs = reg_value.GetAsUInt32();
+    break;
+  case lldb_ds_i386:
+    tls_context.SegDs = reg_value.GetAsUInt32();
+    break;
+  case lldb_es_i386:
+    tls_context.SegEs = reg_value.GetAsUInt32();
+    break;
+  }
+
+  return SetThreadContextHelper(thread_handle, &tls_context);
+}
+
+Status
+NativeRegisterContextWindows_i386::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 GPRRead(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_i386::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 GPRRead(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x86_64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  const size_t data_size = REG_CONTEXT_SIZE;
+  data_sp = std::make_shared<DataBufferHeap>(data_size, 0);
+  ::CONTEXT tls_context;
+  Status error =
+      GetThreadContextHelper(GetThreadHandle(), &tls_context, CONTEXT_ALL);
+  if (error.Fail())
+    return error;
+
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, &tls_context, data_size);
+  return error;
+}
+
+Status NativeRegisterContextWindows_i386::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+  const size_t data_size = REG_CONTEXT_SIZE;
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextWindows_i386::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != data_size) {
+    error.SetErrorStringWithFormatv(
+        "data_sp contained mismatched data size, expected {0}, actual {1}",
+        data_size, data_sp->GetByteSize());
+    return error;
+  }
+
+  ::CONTEXT tls_context;
+  memcpy(&tls_context, data_sp->GetBytes(), data_size);
+  return SetThreadContextHelper(GetThreadHandle(), &tls_context);
+}
+
+Status NativeRegisterContextWindows_i386::IsWatchpointHit(uint32_t wp_index,
+                                                          bool &is_hit) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_i386::GetWatchpointHitIndex(
+    uint32_t &wp_index, lldb::addr_t trap_addr) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_i386::IsWatchpointVacant(uint32_t wp_index,
+                                                             bool &is_vacant) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_i386::SetHardwareWatchpointWithIndex(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
+  return Status("unimplemented");
+}
+
+bool NativeRegisterContextWindows_i386::ClearHardwareWatchpoint(
+    uint32_t wp_index) {
+  return false;
+}
+
+Status NativeRegisterContextWindows_i386::ClearAllHardwareWatchpoints() {
+  return Status("unimplemented");
+}
+
+uint32_t NativeRegisterContextWindows_i386::SetHardwareWatchpoint(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags) {
+  return LLDB_INVALID_INDEX32;
+}
+
+lldb::addr_t
+NativeRegisterContextWindows_i386::GetWatchpointAddress(uint32_t wp_index) {
+  return LLDB_INVALID_ADDRESS;
+}
+
+uint32_t NativeRegisterContextWindows_i386::NumSupportedHardwareWatchpoints() {
+  // Not implemented
+  return 0;
+}
+
+#endif

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.h

+//===-- NativeRegisterContextWindows_x86_64.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_x86_64_h_
+#define liblldb_NativeRegisterContextWindows_x86_64_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_x86_64
+    : public NativeRegisterContextWindows {
+public:
+  NativeRegisterContextWindows_x86_64(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:
+  Status GPRRead(const uint32_t reg, RegisterValue &reg_value);
+
+  Status GPRWrite(const uint32_t reg, const RegisterValue &reg_value);
+
+  Status FPRRead(const uint32_t reg, RegisterValue &reg_value);
+
+  Status FPRWrite(const uint32_t reg, const RegisterValue &reg_value);
+
+private:
+  bool IsGPR(uint32_t reg_index) const;
+
+  bool IsFPR(uint32_t reg_index) const;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_NativeRegisterContextWindows_x86_64_h_
+#endif // defined(_WIN64)

lldb/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

+//===-- NativeRegisterContextWindows_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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_WIN64)
+
+#include "NativeRegisterContextWindows_x86_64.h"
+#include "NativeRegisterContextWindows_WoW64.h"
+#include "NativeThreadWindows.h"
+#include "Plugins/Process/Utility/RegisterContextWindows_i386.h"
+#include "Plugins/Process/Utility/RegisterContextWindows_x86_64.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/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#define REG_CONTEXT_SIZE sizeof(::CONTEXT)
+
+namespace {
+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 set must be terminated with this flag
+};
+
+static const uint32_t g_fpr_regnums_x86_64[] = {
+    lldb_xmm0_x86_64,   lldb_xmm1_x86_64,  lldb_xmm2_x86_64,  lldb_xmm3_x86_64,
+    lldb_xmm4_x86_64,   lldb_xmm5_x86_64,  lldb_xmm6_x86_64,  lldb_xmm7_x86_64,
+    lldb_xmm8_x86_64,   lldb_xmm9_x86_64,  lldb_xmm10_x86_64, lldb_xmm11_x86_64,
+    lldb_xmm12_x86_64,  lldb_xmm13_x86_64, lldb_xmm14_x86_64, lldb_xmm15_x86_64,
+    LLDB_INVALID_REGNUM // Register set must be terminated with this flag
+};
+
+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},
+    {"Floating Point Registers", "fpr",
+     llvm::array_lengthof(g_fpr_regnums_x86_64) - 1, g_fpr_regnums_x86_64}};
+
+enum { k_num_register_sets = 2 };
+
+} // namespace
+
+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_x86_64(target_arch);
+}
+
+static Status GetThreadContextHelper(lldb::thread_t thread_handle,
+                                     PCONTEXT context_ptr,
+                                     const DWORD control_flag) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+
+  memset(context_ptr, 0, sizeof(::CONTEXT));
+  context_ptr->ContextFlags = control_flag;
+  if (!::GetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} GetThreadContext failed with error {1}", __FUNCTION__,
+             error);
+    return error;
+  }
+  return Status();
+}
+
+static Status SetThreadContextHelper(lldb::thread_t thread_handle,
+                                     PCONTEXT context_ptr) {
+  Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_REGISTERS);
+  Status error;
+  // It's assumed that the thread has stopped.
+  if (!::SetThreadContext(thread_handle, context_ptr)) {
+    error.SetError(GetLastError(), eErrorTypeWin32);
+    LLDB_LOG(log, "{0} SetThreadContext failed with error {1}", __FUNCTION__,
+             error);
+    return error;
+  }
+  return Status();
+}
+
+std::unique_ptr<NativeRegisterContextWindows>
+NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  // Register context for a WoW64 application.
+  if (target_arch.GetAddressByteSize() == 4)
+    return llvm::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
+                                                                 native_thread);
+
+  // Register context for a native 64-bit application.
+  return llvm::make_unique<NativeRegisterContextWindows_x86_64>(target_arch,
+                                                                native_thread);
+}
+
+NativeRegisterContextWindows_x86_64::NativeRegisterContextWindows_x86_64(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextWindows(native_thread,
+                                   CreateRegisterInfoInterface(target_arch)) {}
+
+bool NativeRegisterContextWindows_x86_64::IsGPR(uint32_t reg_index) const {
+  return (reg_index >= k_first_gpr_x86_64 && reg_index < k_first_alias_x86_64);
+}
+
+bool NativeRegisterContextWindows_x86_64::IsFPR(uint32_t reg_index) const {
+  return (reg_index >= lldb_xmm0_x86_64 && reg_index <= k_last_fpr_x86_64);
+}
+
+uint32_t NativeRegisterContextWindows_x86_64::GetRegisterSetCount() const {
+  return k_num_register_sets;
+}
+
+const RegisterSet *
+NativeRegisterContextWindows_x86_64::GetRegisterSet(uint32_t set_index) const {
+  if (set_index >= k_num_register_sets)
+    return nullptr;
+  return &g_reg_sets_x86_64[set_index];
+}
+
+Status NativeRegisterContextWindows_x86_64::GPRRead(const uint32_t reg,
+                                                    RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
+  Status error =
+      GetThreadContextHelper(GetThreadHandle(), &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_rax_x86_64:
+    reg_value.SetUInt64(tls_context.Rax);
+    break;
+  case lldb_rbx_x86_64:
+    reg_value.SetUInt64(tls_context.Rbx);
+    break;
+  case lldb_rcx_x86_64:
+    reg_value.SetUInt64(tls_context.Rcx);
+    break;
+  case lldb_rdx_x86_64:
+    reg_value.SetUInt64(tls_context.Rdx);
+    break;
+  case lldb_rdi_x86_64:
+    reg_value.SetUInt64(tls_context.Rdi);
+    break;
+  case lldb_rsi_x86_64:
+    reg_value.SetUInt64(tls_context.Rsi);
+    break;
+  case lldb_rbp_x86_64:
+    reg_value.SetUInt64(tls_context.Rbp);
+    break;
+  case lldb_rsp_x86_64:
+    reg_value.SetUInt64(tls_context.Rsp);
+    break;
+  case lldb_r8_x86_64:
+    reg_value.SetUInt64(tls_context.R8);
+    break;
+  case lldb_r9_x86_64:
+    reg_value.SetUInt64(tls_context.R9);
+    break;
+  case lldb_r10_x86_64:
+    reg_value.SetUInt64(tls_context.R10);
+    break;
+  case lldb_r11_x86_64:
+    reg_value.SetUInt64(tls_context.R11);
+    break;
+  case lldb_r12_x86_64:
+    reg_value.SetUInt64(tls_context.R12);
+    break;
+  case lldb_r13_x86_64:
+    reg_value.SetUInt64(tls_context.R13);
+    break;
+  case lldb_r14_x86_64:
+    reg_value.SetUInt64(tls_context.R14);
+    break;
+  case lldb_r15_x86_64:
+    reg_value.SetUInt64(tls_context.R15);
+    break;
+  case lldb_rip_x86_64:
+    reg_value.SetUInt64(tls_context.Rip);
+    break;
+  case lldb_rflags_x86_64:
+    reg_value.SetUInt64(tls_context.EFlags | 0x2); // Bit #1 always 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_x86_64::GPRWrite(const uint32_t reg,
+                                              const RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
+  auto thread_handle = GetThreadHandle();
+  Status error =
+      GetThreadContextHelper(thread_handle, &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  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.GetAsUInt64();
+    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;
+  }
+
+  return SetThreadContextHelper(thread_handle, &tls_context);
+}
+
+Status NativeRegisterContextWindows_x86_64::FPRRead(const uint32_t reg,
+                                                    RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_FLOATING_POINT;
+  Status error =
+      GetThreadContextHelper(GetThreadHandle(), &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_xmm0_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm0, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm1_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm1, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm2_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm2, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm3_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm3, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm4_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm4, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm5_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm5, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm6_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm6, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm7_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm7, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm8_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm8, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm9_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm9, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm10_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm10, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm11_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm11, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm12_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm12, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm13_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm13, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm14_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm14, 16, endian::InlHostByteOrder());
+    break;
+  case lldb_xmm15_x86_64:
+    reg_value.SetBytes(&tls_context.Xmm15, 16, endian::InlHostByteOrder());
+    break;
+  }
+
+  return error;
+}
+
+Status
+NativeRegisterContextWindows_x86_64::FPRWrite(const uint32_t reg,
+                                              const RegisterValue &reg_value) {
+  ::CONTEXT tls_context;
+  DWORD context_flag = CONTEXT_CONTROL | CONTEXT_FLOATING_POINT;
+  auto thread_handle = GetThreadHandle();
+  Status error =
+      GetThreadContextHelper(thread_handle, &tls_context, context_flag);
+  if (error.Fail())
+    return error;
+
+  switch (reg) {
+  case lldb_xmm0_x86_64:
+    memcpy(&tls_context.Xmm0, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm1_x86_64:
+    memcpy(&tls_context.Xmm1, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm2_x86_64:
+    memcpy(&tls_context.Xmm2, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm3_x86_64:
+    memcpy(&tls_context.Xmm3, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm4_x86_64:
+    memcpy(&tls_context.Xmm4, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm5_x86_64:
+    memcpy(&tls_context.Xmm5, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm6_x86_64:
+    memcpy(&tls_context.Xmm6, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm7_x86_64:
+    memcpy(&tls_context.Xmm7, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm8_x86_64:
+    memcpy(&tls_context.Xmm8, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm9_x86_64:
+    memcpy(&tls_context.Xmm9, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm10_x86_64:
+    memcpy(&tls_context.Xmm10, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm11_x86_64:
+    memcpy(&tls_context.Xmm11, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm12_x86_64:
+    memcpy(&tls_context.Xmm12, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm13_x86_64:
+    memcpy(&tls_context.Xmm13, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm14_x86_64:
+    memcpy(&tls_context.Xmm14, reg_value.GetBytes(), 16);
+    break;
+  case lldb_xmm15_x86_64:
+    memcpy(&tls_context.Xmm15, reg_value.GetBytes(), 16);
+    break;
+  }
+
+  return SetThreadContextHelper(thread_handle, &tls_context);
+}
+
+Status
+NativeRegisterContextWindows_x86_64::ReadRegister(const RegisterInfo *reg_info,
+                                                  RegisterValue &reg_value) {
+  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 GPRRead(reg, reg_value);
+
+  if (IsFPR(reg))
+    return FPRRead(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x86_64::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  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 GPRWrite(reg, reg_value);
+
+  if (IsFPR(reg))
+    return FPRWrite(reg, reg_value);
+
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x86_64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  const size_t data_size = REG_CONTEXT_SIZE;
+  data_sp = std::make_shared<DataBufferHeap>(data_size, 0);
+  ::CONTEXT tls_context;
+  Status error =
+      GetThreadContextHelper(GetThreadHandle(), &tls_context, CONTEXT_ALL);
+  if (error.Fail())
+    return error;
+
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, &tls_context, data_size);
+  return error;
+}
+
+Status NativeRegisterContextWindows_x86_64::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+  const size_t data_size = REG_CONTEXT_SIZE;
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextWindows_x86_64::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != data_size) {
+    error.SetErrorStringWithFormatv(
+        "data_sp contained mismatched data size, expected {0}, actual {1}",
+        data_size, data_sp->GetByteSize());
+    return error;
+  }
+
+  ::CONTEXT tls_context;
+  memcpy(&tls_context, data_sp->GetBytes(), data_size);
+  return SetThreadContextHelper(GetThreadHandle(), &tls_context);
+}
+
+Status NativeRegisterContextWindows_x86_64::IsWatchpointHit(uint32_t wp_index,
+                                                            bool &is_hit) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x86_64::GetWatchpointHitIndex(
+    uint32_t &wp_index, lldb::addr_t trap_addr) {
+  return Status("unimplemented");
+}
+
+Status
+NativeRegisterContextWindows_x86_64::IsWatchpointVacant(uint32_t wp_index,
+                                                        bool &is_vacant) {
+  return Status("unimplemented");
+}
+
+Status NativeRegisterContextWindows_x86_64::SetHardwareWatchpointWithIndex(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
+  return Status("unimplemented");
+}
+
+bool NativeRegisterContextWindows_x86_64::ClearHardwareWatchpoint(
+    uint32_t wp_index) {
+  return false;
+}
+
+Status NativeRegisterContextWindows_x86_64::ClearAllHardwareWatchpoints() {
+  return Status("unimplemented");
+}
+
+uint32_t NativeRegisterContextWindows_x86_64::SetHardwareWatchpoint(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags) {
+  return LLDB_INVALID_INDEX32;
+}
+
+lldb::addr_t
+NativeRegisterContextWindows_x86_64::GetWatchpointAddress(uint32_t wp_index) {
+  return LLDB_INVALID_ADDRESS;
+}
+
+uint32_t
+NativeRegisterContextWindows_x86_64::NumSupportedHardwareWatchpoints() {
+  // Not implemented
+  return 0;
+}
+
+#endif // defined(_WIN64)

lldb/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);
+
+  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_

lldb/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();
+}
+
+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) {
+  return Status("unimplemented.");
+}
+
+Status NativeThreadWindows::RemoveWatchpoint(lldb::addr_t addr) {
+  return Status("unimplemented");
+}
+
+Status NativeThreadWindows::SetHardwareBreakpoint(lldb::addr_t addr,
+                                                  size_t size) {
+  return Status("unimplemented.");
+}
+
+Status NativeThreadWindows::RemoveHardwareBreakpoint(lldb::addr_t addr) {
+  return Status("unimplemented.");
+}

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

bool RegisterContextWindows::CacheAllRegisterValues() {
   memset(buffer, 0, sizeof(buffer));
   PCONTEXT tmpContext = NULL;
   DWORD contextLength = (DWORD)sizeof(buffer);
   if (!::InitializeContext(buffer, kWinContextFlags, &tmpContext,
                            &contextLength)) {
     return false;
   }
   memcpy(&m_context, tmpContext, sizeof(m_context));
-  if (!::SuspendThread(wthread.GetHostThread().GetNativeThread().GetSystemHandle())) {
+  if (::SuspendThread(
+          wthread.GetHostThread().GetNativeThread().GetSystemHandle()) ==
+      (DWORD)-1) {
     return false;
   }
   if (!::GetThreadContext(
           wthread.GetHostThread().GetNativeThread().GetSystemHandle(),
           &m_context)) {
     LLDB_LOG(
         log,
         "GetThreadContext failed with error {0} while caching register values.",
         ::GetLastError());
     return false;
   }
-  if (!::ResumeThread(wthread.GetHostThread().GetNativeThread().GetSystemHandle())) {
+  if (::ResumeThread(
+          wthread.GetHostThread().GetNativeThread().GetSystemHandle()) ==
+      (DWORD)-1) {
     return false;
   }
   LLDB_LOG(log, "successfully updated the register values.");
   m_context_stale = false;
   return true;
 }

lldb/third_party/Python/module/unittest2/unittest2/case.py

def assertSequenceEqual(self, seq1, seq2,
             seq2_repr = repr(seq2)
             if len(seq1_repr) > 30:
                 seq1_repr = seq1_repr[:30] + '...'
             if len(seq2_repr) > 30:
                 seq2_repr = seq2_repr[:30] + '...'
             elements = (seq_type_name.capitalize(), seq1_repr, seq2_repr)
             differing = '%ss differ: %s != %s\n' % elements
 
-            for i in xrange(min(len1, len2)):
+            for i in range(min(len1, len2)):
                 try:
                     item1 = seq1[i]
                 except (TypeError, IndexError, NotImplementedError):
                     differing += ('\nUnable to index element %d of first %s\n' %
                                   (i, seq_type_name))
                     break
 
                 try:

lldb/unittests/tools/lldb-server/tests/LLGSTest.cpp

 //===-- LLGSTest.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 "TestBase.h"
 #include "lldb/Host/Host.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace llgs_tests;
 using namespace lldb_private;
 using namespace llvm;
 
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
 TEST_F(TestBase, LaunchModePreservesEnvironment) {
   putenv(const_cast<char *>("LLDB_TEST_MAGIC_VARIABLE=LLDB_TEST_MAGIC_VALUE"));
 
   auto ClientOr = TestClient::launch(getLogFileName(),
                                      {getInferiorPath("environment_check")});
   ASSERT_THAT_EXPECTED(ClientOr, Succeeded());
   auto &Client = **ClientOr;
 

lldb/unittests/tools/lldb-server/tests/TestBase.h

 //===-- TestBase.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 LLDB_SERVER_TESTS_TESTBASE_H
 #define LLDB_SERVER_TESTS_TESTBASE_H
 
 #include "TestClient.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/Socket.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 namespace llgs_tests {
 
 class TestBase: public ::testing::Test {
 public:
   static void SetUpTestCase() {
     lldb_private::FileSystem::Initialize();
     lldb_private::HostInfo::Initialize();
+    ASSERT_THAT_ERROR(lldb_private::Socket::Initialize(), llvm::Succeeded());
   }
 
   static void TearDownTestCase() {
+    lldb_private::Socket::Terminate();
     lldb_private::HostInfo::Terminate();
     lldb_private::FileSystem::Terminate();
   }
 
   static std::string getInferiorPath(llvm::StringRef Name) {
     llvm::SmallString<64> Path(LLDB_TEST_INFERIOR_PATH);
     llvm::sys::path::append(Path, Name + LLDB_TEST_INFERIOR_SUFFIX);
     return Path.str();

lldb/unittests/tools/lldb-server/tests/TestClient.cpp

 #include <sstream>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 using namespace llgs_tests;
 
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
 TestClient::TestClient(std::unique_ptr<Connection> Conn) {
   SetConnection(Conn.release());
   SetPacketTimeout(std::chrono::seconds(10));
 }
 
 TestClient::~TestClient() {
   if (!IsConnected())
     return;
Error TestClient::Continue(StringRef message) {
   auto StopReplyOr = SendMessage<StopReply>(
       message, m_process_info->GetEndian(), m_register_infos);
   if (!StopReplyOr)
     return StopReplyOr.takeError();
 
   m_stop_reply = std::move(*StopReplyOr);
   if (!isa<StopReplyStop>(m_stop_reply)) {
     StringExtractorGDBRemote R;
     PacketResult result = ReadPacket(R, GetPacketTimeout(), false);
     if (result != PacketResult::ErrorDisconnected) {
       return make_error<StringError>(
           formatv("Expected connection close after sending {0}. Got {1}/{2} "
                   "instead.",
                   message, result, R.GetStringRef())
               .str(),
           inconvertibleErrorCode());
     }
   }
   return Error::success();
 }