[ABI] Implement Windows ABI for x86_64

[kusmour]

Summary

Implement the ABI for WIndows-x86_64 including register info and calling convention.
Handled nested struct returned in register (SysV doesn't have it supported)

[compnerd]

lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

1094

This really isn't correct. There is no reason to assume that everything on x86_64 uses the SysV ABI. Can you convert this to a switch over the OS type and return it from the known OSes (Linux, BSD, and Darwin do conform to SysV, the others can return ABISP().

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

1078

Ugh, this really feels like copy and paste. Perhaps we should have a .inc file that we can use to replicate the reigster names across the targets.

1104

Nit: the indentation seems off.

1203

Mind using CHAR_BIT instead of 8?

1359

FP80 is not supported on Windows, this should be a hard error.

1466

long double is the same as double on Windows.

1492

lmao, is this a copy paste thing? I think that xmm_reg is better than altivec_reg as ALTIVEC is PPC specific.

1573

Mind using CHAR_BIT instead of 8 please?

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

55

This comment doesn't make sense on Windows - signal handlers don't really apply to Windows.

59

This should be made strict as per the Windows ABI.

63

Can we add an additional test please? In particular, leaf frames are permitted to have unaligned stacks.

[xiaobai]

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

1257–1259

I don't see any references to clang in the below code. Is this still accurate?

1388

Why is this commented out? If it's unneeded, please remove it

1811

nit: Windows-x86_64 doesn't use rbp

[kusmour]

update a new version based on comment.
cleaned some useless comment
change to use CHAR_BIT for readability

[kusmour]

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

1257–1259

not relevant, deleted

1359

I changed it to provide a correct error message. Is it better to put an assertion or return here?

1466

got it thanks

1811

thanks

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

59

windows is 16-byte aligned, updated.

63

can you provide more information about this? On windows a leaf function doesn't require a stack frame. But a frame function that doesn't call other function is not required to align the stack

[jasonmolenda]

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

63

I'm not sure if the Phabracator comments are pointing to the correct bits of sourcecode - you're talking about CallFrameAddressIsValid right? This is checking the stack frame's Canonical Frame Address -- it is a check that the caller's $rsp was 16-byte aligned before it CALLed a (possibly leaf). It isn't a check of the $rsp value in the callee. The unwinder uses this as a sanity check to detect when the backtrace has bogus values as it walks up the stack.

Also, not sure where this comment thread is :) but re. CodeAddressIsValid - return true because this is the x86 ISA where there is no instruction alignment restrictions. This method is for architectures with fixed width instructions (okay, where"fixed width" is greater than 1 :) to help detect backtrace mistakes (again). e.g. aarch64/arm64 instructions are always 4-byte aligned.

[compnerd]

lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

1094

Nit: a switch is clearer and easier to extend.

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

1097

Nit: I think that arch.GetTriple().isOSWindows() is nicer than the explicit check of Win32.

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

48

The comment seems wrong

[kusmour]

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

1097

got it

[kusmour]

update nit

[kusmour]

update the CreateDefaultUnwindPlan.
return false or give empty Unwind Plan may cause lldb to crash and break tests on windows.
So for now, copy the SysV-x86_64

[kusmour]

Update the GetReturnValueObjectImpl using function CanPassInRegisters to explicitly check

NOTE: There's NO register context info about registers beyond general purpose registers So floating point return type is not supported since it uses XMM0 to return need to update register context for windows x64

[kusmour]

Added support for XMM registers.
Now the step out on a function returns floating point number should have the right value.
To play with it, define a function

float getFloat(float value) {
    return value;
}

set a break point and step out
LLDB will print out the right value if debugging on Windows-x86_64

[kusmour]

complete the code for floating point registers and cleaned up
the support for floating point registers fixed TestRegistersIterator update the testcased

[kusmour]

the OS check in SysV x64 ABI broke the test SymbolFile/DWARF/debug_loc.s
added a restriction lld to #REQUIRES

[labath]

In D62213#1548788, @kusmour wrote:

the OS check in SysV x64 ABI broke the test SymbolFile/DWARF/debug_loc.s

Can you elaborate on that? How exactly did it break this test?

added a restriction lld to #REQUIRES

That definitely is not the right solution here. If you add lld to your checkout on windows, then "REQUIRES: lld" will be satisfied, but the test will (I guess) still fail. "XFAIL: system-windows" is probably what you want here, but it would be good to understand why this starts to fail now. Is it because we fail to detect that the file in question there is a linux file, and so the triple comes out like "x86_64--" or something? Maybe we should make the SysV abi plugin match unknown oss too... The only format where we have trouble determining the OS is ELF, and it's a pretty good bet that any elf file will be using the "SysV" ABI...

[kusmour]

@labath Hi, you're right about the lld, it didn't make the test pass, instead it became unsupported.

In D62213#1548835, @labath wrote:

Can you elaborate on that? How exactly did it break this test?

So the problem here is that, llvm-mc constructs the Triple correctly, but lldb does not preserve all the information from it, at least it does not know about the OS type.

Maybe we should make the SysV abi plugin match unknown oss too...

I'm not sure this is the right thing to do, but this should fix the problem.

The only format where we have trouble determining the OS is ELF, and it's a pretty good bet that any elf file will be using the "SysV" ABI...

Can you provide more information about this? It sounds like a bug

[labath]

In D62213#1549190, @kusmour wrote:

Maybe we should make the SysV abi plugin match unknown oss too...

I'm not sure this is the right thing to do, but this should fix the problem.

It would at least preserve status quo. Not much, but it is something...

The only format where we have trouble determining the OS is ELF, and it's a pretty good bet that any elf file will be using the "SysV" ABI...

Can you provide more information about this? It sounds like a bug

Well.. you could consider it a bug, but it's quite hard to say where that bug is (it's definitely not a bug in lldb or llvm-mc). A sad fact of life is that the ELF files don't usually carry enough information to properly identify the os/environment they were intended to run on. If you run readelf -e on the file generated in the test, you'll get something like

ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              REL (Relocatable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x0
  Start of program headers:          0 (bytes into file)
  Start of section headers:          648 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           0 (bytes)
  Number of program headers:         0
  Size of section headers:           64 (bytes)
  Number of section headers:         9
  Section header string table index: 1

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .strtab           STRTAB           0000000000000000  00000238
       000000000000004e  0000000000000000           0     0     1
  [ 2] .text             PROGBITS         0000000000000000  00000040
       0000000000000003  0000000000000000  AX       0     0     4
  [ 3] .debug_str        PROGBITS         0000000000000000  00000043
       000000000000001b  0000000000000001  MS       0     0     1
  [ 4] .debug_loc        PROGBITS         0000000000000000  0000005e
       0000000000000036  0000000000000000           0     0     1
  [ 5] .debug_abbrev     PROGBITS         0000000000000000  00000094
       000000000000002d  0000000000000000           0     0     1
  [ 6] .debug_info       PROGBITS         0000000000000000  000000c1
       000000000000003d  0000000000000000           0     0     1
  [ 7] .rela.debug_info  RELA             0000000000000000  00000190
       00000000000000a8  0000000000000018           8     6     8
  [ 8] .symtab           SYMTAB           0000000000000000  00000100
       0000000000000090  0000000000000018           1     6     8
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  l (large), p (processor specific)

There are no program headers in this file.

The elf header has this OS/ABI field which could be used to specify linux, but here it's just set to the generic "none" value (which gets printed as "unix sysv"). There is a value for ELFOSABI_LINUX/ELFOSABI_GNU, which could be used to say "linux", but it seems nobody uses it (I'm not sure what's the background there). I guess that usually wasn't a problem, because tools would just assume they are dealing with binaries for the host platform, but lldb has a strong desire to know what platform is a binary intended for without assuming anything about the environment it's being run it. That desire is understandable, but it kind of collides with reality. Over time, lldb has developed a bunch of heuristics to determine the right OS for a file, but these are just heuristics, and they fail on extremely simple files like the ones used in this test, because they have nothing to go on.

[kusmour]

allow SysV_x86_64 ABI to handle unknown OS type
this should fix the test SymbolFile/DWARF/debug_loc.s

[mgorny]

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

231 ↗

(On Diff #206270)

There's NetBSD missing here. This broke our buildbots. I'll fix it but please be more careful in the future.

[asmith]

I think this change has introduced a dependence on x64.

I tried building with the 32b Visual Studio compiler and there are a number of undefined registers in registercontextwindows_x64.cpp.
This is because the version of _CONTEXT included by winnt.h is for x32 and not x64.

i.e., llvm-project\lldb\source\plugins\process\windows\common\x64\registercontextwindows_x64.cpp(297): error C2039: 'Rax': is not a member of '_CONTEXT'

Thoughts? Maybe this doesn't need to be included when building x32 LLDB?

[xiaobai]

In D62213#1605521, @asmith wrote:

I think this change has introduced a dependence on x64.

I tried building with the 32b Visual Studio compiler and there are a number of undefined registers in registercontextwindows_x64.cpp.
This is because the version of _CONTEXT included by winnt.h is for x32 and not x64.

i.e., llvm-project\lldb\source\plugins\process\windows\common\x64\registercontextwindows_x64.cpp(297): error C2039: 'Rax': is not a member of '_CONTEXT'

This seems kind of strange to me. I didn't think you could actually build RegisterContextWindows_x64.cpp on an x86 machine. From the CMake logic, it looks like it's guarded by CMAKE_SYSTEM_PROCESSOR matching either "x86_64" or "AMD64". Do you have any local changes or a specific CMake setup that caused you to run into this?

Thoughts? Maybe this doesn't need to be included when building x32 LLDB?

I would rather be able to build this all on x86 if possible, but I don't think it's the end of the world if there's no nice way to do this. There is plenty of code in LLDB guarded by what platform you're building on/for, this would just be another instance of it.

[asmith]

I can confirm this is reproducible with the master branch of llvm-project cloned from GitHub.

You can reproduce the build failure from an x64 command prompt with this cmake command line:

cmake path-to-llvm-project/llvm -Thost=x64 -DLLVM_ENABLE_PROJECTS="clang;lld;lldb" -DCLANG_DEFAULT_LINKER=lld -DLLVM_ENABLE_ASSERTIONS=ON

And building with:

msbuild ALL_BUILD.vcxproj /m

In this configuration CMAKE_SYSTEM_PROCESSOR is going to report AMD64 and this is going to use the x64 hosted Visual Studio compiler targeting 32 bit Windows. Probably some of these files need to be wrapped in #if defined(_M_X64).

lldb/trunk/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

1 ↗

(On Diff #206270)

Nit; number of dashes '----' is wrong in the headers of the files added

[labath]

You might want to have a look at https://reviews.llvm.org/D65409 which might fix (some of?) the issues mentioned here.

I don't know if this is relevant or not, but I thought I'd say that on linux we also effectively aren't able to debug a 64-bit process with a 32-bit lldb(-server). (effectively = that's not entirely true, and the situation is a bit more subtle, but the overall effect is the same).

[asmith]

Do you need some help fixing the build?

lldb/source/API/SystemInitializerFull.cpp

 #include "Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h"
 #include "Plugins/ABI/SysV-s390x/ABISysV_s390x.h"
 #include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
+#include "Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h"
 #include "Plugins/Architecture/Arm/ArchitectureArm.h"
 #include "Plugins/Architecture/Mips/ArchitectureMips.h"
 #include "Plugins/Architecture/PPC64/ArchitecturePPC64.h"

   ABISysV_mips::Initialize();
   ABISysV_mips64::Initialize();
   ABISysV_s390x::Initialize();
+  ABIWindows_x86_64::Initialize();
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();

   ABISysV_mips::Terminate();
   ABISysV_mips64::Terminate();
   ABISysV_s390x::Terminate();
+  ABIWindows_x86_64::Terminate();
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();

lldb/source/Plugins/ABI/CMakeLists.txt

 add_subdirectory(MacOSX-i386)
 add_subdirectory(MacOSX-arm)
 add_subdirectory(MacOSX-arm64)
+add_subdirectory(Windows-x86_64)

lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

 
 ABISP
 ABISysV_x86_64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
-  if (arch.GetTriple().getArch() == llvm::Triple::x86_64) {
+  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
+  const llvm::Triple::OSType os_type = arch.GetTriple().getOS();
+  if (arch_type == llvm::Triple::x86_64 &&
+      os_type != llvm::Triple::OSType::Win32) {
     return ABISP(new ABISysV_x86_64(process_sp));
   }
   return ABISP();

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

+//===-- ABIWindows_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_ABIWindows_x86_64_h_
+#define liblldb_ABIWindows_x86_64_h_
+
+#include "lldb/Target/ABI.h"
+#include "lldb/lldb-private.h"
+
+class ABIWindows_x86_64 : public lldb_private::ABI {
+public:
+  ~ABIWindows_x86_64() override = default;
+
+  size_t GetRedZoneSize() const override;
+
+  bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
+                          lldb::addr_t functionAddress,
+                          lldb::addr_t returnAddress,
+                          llvm::ArrayRef<lldb::addr_t> args) const override;
+
+  bool GetArgumentValues(lldb_private::Thread &thread,
+                         lldb_private::ValueList &values) const override;
+
+  lldb_private::Status
+  SetReturnValueObject(lldb::StackFrameSP &frame_sp,
+                       lldb::ValueObjectSP &new_value) override;
+
+  lldb::ValueObjectSP
+  GetReturnValueObjectImpl(lldb_private::Thread &thread,
+                           lldb_private::CompilerType &type) const override;
+
+  bool
+  CreateFunctionEntryUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override;
+
+  bool CreateDefaultUnwindPlan(lldb_private::UnwindPlan &unwind_plan) override;
+
+  bool RegisterIsVolatile(const lldb_private::RegisterInfo *reg_info) override;
+
+  // In Windows_x86_64 ABI, stack will always be maintained 16-byte aligned.
+  // Below is from Sys_V_x86_64:
+  // When there is a trap handler on the stack, e.g. _sigtramp in userland
+  // code, we've seen that the stack pointer is often not aligned properly
+  // before the handler is invoked.  This means that lldb will stop the unwind
+  // early -- before the function which caused the trap.
+  //
+  // To work around this, we relax that alignment to be just word-size
+  // (8-bytes).
+  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // in other environments there can be a large number of different functions
+  // involved in async traps.
+  bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
+    // Make sure the stack call frame addresses are 8 byte aligned
+
+    if (cfa & (8ull - 1ull))
+      return false; // Not 8 byte aligned
+    if (cfa == 0)
+      return false; // Zero is not a valid stack address
+    return true;
+  }
+
+  bool CodeAddressIsValid(lldb::addr_t pc) override {
+    // We have a 64 bit address space, so anything is valid as opcodes
+    // aren't fixed width...
+    return true;
+  }
+
+  const lldb_private::RegisterInfo *
+  GetRegisterInfoArray(uint32_t &count) override;
+
+  bool GetPointerReturnRegister(const char *&name) override;
+
+  //------------------------------------------------------------------
+  // Static Functions
+  //------------------------------------------------------------------
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  //------------------------------------------------------------------
+  // PluginInterface protocol
+  //------------------------------------------------------------------
+
+  lldb_private::ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+protected:
+  void CreateRegisterMapIfNeeded();
+
+  lldb::ValueObjectSP
+  GetReturnValueObjectSimple(lldb_private::Thread &thread,
+                             lldb_private::CompilerType &ast_type) const;
+
+  bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
+
+private:
+  ABIWindows_x86_64(lldb::ProcessSP process_sp) : lldb_private::ABI(process_sp) {
+    // Call CreateInstance instead.
+  }
+};
+
+#endif // liblldb_ABISysV_x86_64_h_

lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

+//===-- ABIWindows_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 "ABIWindows_x86_64.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/Triple.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Core/ValueObjectMemory.h"
+#include "lldb/Core/ValueObjectRegister.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+enum dwarf_regnums {
+  dwarf_rax = 0,
+  dwarf_rdx,
+  dwarf_rcx,
+  dwarf_rbx,
+  dwarf_rsi,
+  dwarf_rdi,
+  dwarf_rbp,
+  dwarf_rsp,
+  dwarf_r8,
+  dwarf_r9,
+  dwarf_r10,
+  dwarf_r11,
+  dwarf_r12,
+  dwarf_r13,
+  dwarf_r14,
+  dwarf_r15,
+  dwarf_rip,
+  dwarf_xmm0,
+  dwarf_xmm1,
+  dwarf_xmm2,
+  dwarf_xmm3,
+  dwarf_xmm4,
+  dwarf_xmm5,
+  dwarf_xmm6,
+  dwarf_xmm7,
+  dwarf_xmm8,
+  dwarf_xmm9,
+  dwarf_xmm10,
+  dwarf_xmm11,
+  dwarf_xmm12,
+  dwarf_xmm13,
+  dwarf_xmm14,
+  dwarf_xmm15,
+  dwarf_stmm0,
+  dwarf_stmm1,
+  dwarf_stmm2,
+  dwarf_stmm3,
+  dwarf_stmm4,
+  dwarf_stmm5,
+  dwarf_stmm6,
+  dwarf_stmm7,
+  dwarf_ymm0,
+  dwarf_ymm1,
+  dwarf_ymm2,
+  dwarf_ymm3,
+  dwarf_ymm4,
+  dwarf_ymm5,
+  dwarf_ymm6,
+  dwarf_ymm7,
+  dwarf_ymm8,
+  dwarf_ymm9,
+  dwarf_ymm10,
+  dwarf_ymm11,
+  dwarf_ymm12,
+  dwarf_ymm13,
+  dwarf_ymm14,
+  dwarf_ymm15,
+  dwarf_bnd0 = 126,
+  dwarf_bnd1,
+  dwarf_bnd2,
+  dwarf_bnd3
+};
+
+static RegisterInfo g_register_infos[] = {
+    //  NAME      ALT      SZ OFF ENCODING         FORMAT              EH_FRAME
+    //  DWARF                 GENERIC                     PROCESS PLUGIN
+    //  LLDB NATIVE
+    //  ========  =======  == === =============    ===================
+    //  ======================= =====================
+    //  =========================== ===================== ======================
+    {"rax",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rax, dwarf_rax, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rbx",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rbx, dwarf_rbx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rcx",
+     "arg1",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rcx, dwarf_rcx, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rdx",
+     "arg2",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rdx, dwarf_rdx, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rsi",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rsi, dwarf_rsi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rdi",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rdi, dwarf_rdi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rbp",
+     "fp",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rbp, dwarf_rbp, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rsp",
+     "sp",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rsp, dwarf_rsp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r8",
+     "arg3",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r8, dwarf_r8, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r9",
+     "arg4",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r9, dwarf_r9, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r10",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r11",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r12",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r13",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r13, dwarf_r13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r14",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r14, dwarf_r14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"r15",
+     nullptr,
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_r15, dwarf_r15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rip",
+     "pc",
+     8,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {dwarf_rip, dwarf_rip, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"rflags",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"cs",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ss",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ds",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"es",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fs",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"gs",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm0",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm0, dwarf_stmm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm1",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm1, dwarf_stmm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm2",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm2, dwarf_stmm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm3",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm3, dwarf_stmm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm4",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm4, dwarf_stmm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm5",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm5, dwarf_stmm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm6",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm6, dwarf_stmm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"stmm7",
+     nullptr,
+     10,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_stmm7, dwarf_stmm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fctrl",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fstat",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ftag",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fiseg",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fioff",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"foseg",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fooff",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"fop",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm0",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm0, dwarf_xmm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm1",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm1, dwarf_xmm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm2",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm2, dwarf_xmm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm3",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm3, dwarf_xmm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm4",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm4, dwarf_xmm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm5",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm5, dwarf_xmm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm6",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm6, dwarf_xmm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm7",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm7, dwarf_xmm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm8",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm8, dwarf_xmm8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm9",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm9, dwarf_xmm9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm10",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm10, dwarf_xmm10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm11",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm11, dwarf_xmm11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm12",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm12, dwarf_xmm12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm13",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm13, dwarf_xmm13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm14",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm14, dwarf_xmm14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"xmm15",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_xmm15, dwarf_xmm15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"mxcsr",
+     nullptr,
+     4,
+     0,
+     eEncodingUint,
+     eFormatHex,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm0",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm0, dwarf_ymm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm1",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm1, dwarf_ymm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm2",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm2, dwarf_ymm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm3",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm3, dwarf_ymm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm4",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm4, dwarf_ymm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm5",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm5, dwarf_ymm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm6",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm6, dwarf_ymm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm7",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm7, dwarf_ymm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm8",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm8, dwarf_ymm8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm9",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm9, dwarf_ymm9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm10",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm10, dwarf_ymm10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm11",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm11, dwarf_ymm11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm12",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm12, dwarf_ymm12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm13",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm13, dwarf_ymm13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm14",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm14, dwarf_ymm14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"ymm15",
+     nullptr,
+     32,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {dwarf_ymm15, dwarf_ymm15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bnd0",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt64,
+     {dwarf_bnd0, dwarf_bnd0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bnd1",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt64,
+     {dwarf_bnd1, dwarf_bnd1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bnd2",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt64,
+     {dwarf_bnd2, dwarf_bnd2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bnd3",
+     nullptr,
+     16,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt64,
+     {dwarf_bnd3, dwarf_bnd3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bndcfgu",
+     nullptr,
+     8,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0},
+    {"bndstatus",
+     nullptr,
+     8,
+     0,
+     eEncodingVector,
+     eFormatVectorOfUInt8,
+     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
+     nullptr,
+     nullptr,
+     nullptr,
+     0}};
+
+static const uint32_t k_num_register_infos =
+    llvm::array_lengthof(g_register_infos);
+static bool g_register_info_names_constified = false;
+
+const lldb_private::RegisterInfo *
+ABIWindows_x86_64::GetRegisterInfoArray(uint32_t &count) {
+  // Make the C-string names and alt_names for the register infos into const
+  // C-string values by having the ConstString unique the names in the global
+  // constant C-string pool.
+  if (!g_register_info_names_constified) {
+    g_register_info_names_constified = true;
+    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
+      if (g_register_infos[i].name)
+        g_register_infos[i].name =
+            ConstString(g_register_infos[i].name).GetCString();
+      if (g_register_infos[i].alt_name)
+        g_register_infos[i].alt_name =
+            ConstString(g_register_infos[i].alt_name).GetCString();
+    }
+  }
+  count = k_num_register_infos;
+  return g_register_infos;
+}
+
+bool ABIWindows_x86_64::GetPointerReturnRegister(const char *&name) {
+  name = "rax";
+  return true;
+}
+
+size_t ABIWindows_x86_64::GetRedZoneSize() const { return 0; }
+
+//------------------------------------------------------------------
+// Static Functions
+//------------------------------------------------------------------
+
+ABISP
+ABIWindows_x86_64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
+  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
+  const llvm::Triple::OSType os_type = arch.GetTriple().getOS();
+  if (arch_type == llvm::Triple::x86_64
+    && os_type == llvm::Triple::OSType::Win32) {
+    return ABISP(new ABIWindows_x86_64(process_sp));
+  }
+  return ABISP();
+}
+
+bool ABIWindows_x86_64::PrepareTrivialCall(Thread &thread, addr_t sp,
+                                        addr_t func_addr, addr_t return_addr,
+                                        llvm::ArrayRef<addr_t> args) const {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  if (log) {
+    StreamString s;
+    s.Printf("ABIWindows_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
+             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
+             ", return_addr = 0x%" PRIx64,
+             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
+             (uint64_t)return_addr);
+
+    for (size_t i = 0; i < args.size(); ++i)
+      s.Printf(", arg%" PRIu64 " = 0x%" PRIx64, static_cast<uint64_t>(i + 1),
+               args[i]);
+    s.PutCString(")");
+    log->PutString(s.GetString());
+  }
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return false;
+
+  const RegisterInfo *reg_info = nullptr;
+
+  if (args.size() > 4) // Windows x64 only put first 4 arguments into registers
+    return false;
+
+  for (size_t i = 0; i < args.size(); ++i) {
+    reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                        LLDB_REGNUM_GENERIC_ARG1 + i);
+    if (log)
+      log->Printf("About to write arg%" PRIu64 " (0x%" PRIx64 ") into %s",
+                  static_cast<uint64_t>(i + 1), args[i], reg_info->name);
+    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
+      return false;
+  }
+
+  // First, align the SP
+
+  if (log)
+    log->Printf("16-byte aligning SP: 0x%" PRIx64 " to 0x%" PRIx64,
+                (uint64_t)sp, (uint64_t)(sp & ~0xfull));
+
+  sp &= ~(0xfull); // 16-byte alignment
+
+  sp -= 8; // return address
+
+  Status error;
+  const RegisterInfo *pc_reg_info =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+  const RegisterInfo *sp_reg_info =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
+  ProcessSP process_sp(thread.GetProcess());
+
+  RegisterValue reg_value;
+  if (log)
+    log->Printf("Pushing the return address onto the stack: 0x%" PRIx64
+                ": 0x%" PRIx64,
+                (uint64_t)sp, (uint64_t)return_addr);
+
+  // Save return address onto the stack
+  if (!process_sp->WritePointerToMemory(sp, return_addr, error))
+    return false;
+
+  // %rsp is set to the actual stack value.
+
+  if (log)
+    log->Printf("Writing SP: 0x%" PRIx64, (uint64_t)sp);
+
+  if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_info, sp))
+    return false;
+
+  // %rip is set to the address of the called function.
+
+  if (log)
+    log->Printf("Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
+
+  if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_info, func_addr))
+    return false;
+
+  return true;
+}
+
+static bool ReadIntegerArgument(Scalar &scalar, unsigned int bit_width,
+                                bool is_signed, Thread &thread,
+                                uint32_t *argument_register_ids,
+                                unsigned int &current_argument_register,
+                                addr_t &current_stack_argument) {
+  if (bit_width > 64)
+    return false; // Scalar can't hold large integer arguments
+
+  if (current_argument_register < 4) { // Windows pass first 4 arguments to register
+    scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
+        argument_register_ids[current_argument_register], 0);
+    current_argument_register++;
+    if (is_signed)
+      scalar.SignExtend(bit_width);
+    return true;
+  }
+  uint32_t byte_size = (bit_width + (8 - 1)) / 8;
+  Status error;
+  if (thread.GetProcess()->ReadScalarIntegerFromMemory(
+          current_stack_argument, byte_size, is_signed, scalar, error)) {
+    current_stack_argument += byte_size;
+    return true;
+  }
+  return false;
+}
+
+bool ABIWindows_x86_64::GetArgumentValues(Thread &thread,
+                                       ValueList &values) const {
+  unsigned int num_values = values.GetSize();
+  unsigned int value_index;
+
+  // Extract the register context so we can read arguments from registers
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+
+  if (!reg_ctx)
+    return false;
+
+  // Get the pointer to the first stack argument so we have a place to start
+  // when reading data
+
+  addr_t sp = reg_ctx->GetSP(0);
+
+  if (!sp)
+    return false;
+
+  addr_t current_stack_argument = sp + 8; // jump over return address
+
+  uint32_t argument_register_ids[4];
+
+  argument_register_ids[0] =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1)
+          ->kinds[eRegisterKindLLDB];
+  argument_register_ids[1] =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2)
+          ->kinds[eRegisterKindLLDB];
+  argument_register_ids[2] =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG3)
+          ->kinds[eRegisterKindLLDB];
+  argument_register_ids[3] =
+      reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG4)
+          ->kinds[eRegisterKindLLDB];
+
+  unsigned int current_argument_register = 0;
+
+  for (value_index = 0; value_index < num_values; ++value_index) {
+    Value *value = values.GetValueAtIndex(value_index);
+
+    if (!value)
+      return false;
+
+    // We currently only support extracting values with Clang QualTypes. Do we
+    // care about others?
+    CompilerType compiler_type = value->GetCompilerType();
+    llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
+    if (!bit_size)
+      return false;
+    bool is_signed;
+
+    if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
+      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
+    } else if (compiler_type.IsPointerType()) {
+      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
+    }
+  }
+
+  return true;
+}
+
+Status ABIWindows_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
+                                            lldb::ValueObjectSP &new_value_sp) {
+  Status error;
+  if (!new_value_sp) {
+    error.SetErrorString("Empty value object for return value.");
+    return error;
+  }
+
+  CompilerType compiler_type = new_value_sp->GetCompilerType();
+  if (!compiler_type) {
+    error.SetErrorString("Null clang type for return value.");
+    return error;
+  }
+
+  Thread *thread = frame_sp->GetThread().get();
+
+  bool is_signed;
+  uint32_t count;
+  bool is_complex;
+
+  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
+
+  bool set_it_simple = false;
+  if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
+      compiler_type.IsPointerType()) {
+    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("rax", 0);
+
+    DataExtractor data;
+    Status data_error;
+    size_t num_bytes = new_value_sp->GetData(data, data_error);
+    if (data_error.Fail()) {
+      error.SetErrorStringWithFormat(
+          "Couldn't convert return value to raw data: %s",
+          data_error.AsCString());
+      return error;
+    }
+    lldb::offset_t offset = 0;
+    if (num_bytes <= 8) {
+      uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);
+
+      if (reg_ctx->WriteRegisterFromUnsigned(reg_info, raw_value))
+        set_it_simple = true;
+    } else {
+      error.SetErrorString("We don't support returning longer than 64 bit "
+                           "integer values at present.");
+    }
+  } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
+    if (is_complex)
+      error.SetErrorString(
+          "We don't support returning complex values at present");
+    else {
+      llvm::Optional<uint64_t> bit_width =
+          compiler_type.GetBitSize(frame_sp.get());
+      if (!bit_width) {
+        error.SetErrorString("can't get type size");
+        return error;
+      }
+      if (*bit_width <= 64) {
+        const RegisterInfo *xmm0_info =
+            reg_ctx->GetRegisterInfoByName("xmm0", 0);
+        RegisterValue xmm0_value;
+        DataExtractor data;
+        Status data_error;
+        size_t num_bytes = new_value_sp->GetData(data, data_error);
+        if (data_error.Fail()) {
+          error.SetErrorStringWithFormat(
+              "Couldn't convert return value to raw data: %s",
+              data_error.AsCString());
+          return error;
+        }
+
+        unsigned char buffer[16];
+        ByteOrder byte_order = data.GetByteOrder();
+
+        data.CopyByteOrderedData(0, num_bytes, buffer, 16, byte_order);
+        xmm0_value.SetBytes(buffer, 16, byte_order);
+        reg_ctx->WriteRegister(xmm0_info, xmm0_value);
+        set_it_simple = true;
+      } else {
+        // FIXME - don't know how to do 80 bit long doubles yet.
+        error.SetErrorString(
+            "We don't support returning float values > 64 bits at present");
+      }
+    }
+  }
+
+  if (!set_it_simple) {
+    // Okay we've got a structure or something that doesn't fit in a simple
+    // register.
+    // TODO(wanyi): On Windows, if the return type is a struct:
+    // 1) smaller that 64 bits and return by value -> RAX
+    // 2) bigger than 64 bits, the caller will allocate memory for that struct
+    // and pass the struct pointer in RCX then return the pointer in RAX
+    error.SetErrorString("We only support setting simple integer and float "
+                         "return types at present.");
+  }
+
+  return error;
+}
+
+ValueObjectSP ABIWindows_x86_64::GetReturnValueObjectSimple(
+    Thread &thread, CompilerType &return_compiler_type) const {
+  ValueObjectSP return_valobj_sp;
+  Value value;
+
+  if (!return_compiler_type)
+    return return_valobj_sp;
+
+  // value.SetContext (Value::eContextTypeClangType, return_value_type);
+  value.SetCompilerType(return_compiler_type);
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return return_valobj_sp;
+
+  const uint32_t type_flags = return_compiler_type.GetTypeInfo();
+  if (type_flags & eTypeIsScalar) {
+    value.SetValueType(Value::eValueTypeScalar);
+
+    bool success = false;
+    if (type_flags & eTypeIsInteger) {
+      // Extract the register context so we can read arguments from registers
+      llvm::Optional<uint64_t> byte_size =
+          return_compiler_type.GetByteSize(nullptr);
+      if (!byte_size)
+        return return_valobj_sp;
+      uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
+          reg_ctx->GetRegisterInfoByName("rax", 0), 0);
+      const bool is_signed = (type_flags & eTypeIsSigned) != 0;
+      switch (*byte_size) {
+      default:
+        break;
+
+      case sizeof(uint64_t):
+        if (is_signed)
+          value.GetScalar() = (int64_t)(raw_value);
+        else
+          value.GetScalar() = (uint64_t)(raw_value);
+        success = true;
+        break;
+
+      case sizeof(uint32_t):
+        if (is_signed)
+          value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
+        else
+          value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
+        success = true;
+        break;
+
+      case sizeof(uint16_t):
+        if (is_signed)
+          value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
+        else
+          value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
+        success = true;
+        break;
+
+      case sizeof(uint8_t):
+        if (is_signed)
+          value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
+        else
+          value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
+        success = true;
+        break;
+      }
+    } else if (type_flags & eTypeIsFloat) {
+      if (type_flags & eTypeIsComplex) {
+        // Don't handle complex yet.
+      } else {
+        llvm::Optional<uint64_t> byte_size =
+            return_compiler_type.GetByteSize(nullptr);
+        if (byte_size && *byte_size <= sizeof(long double)) {
+          const RegisterInfo *xmm0_info =
+              reg_ctx->GetRegisterInfoByName("xmm0", 0);
+          RegisterValue xmm0_value;
+          if (reg_ctx->ReadRegister(xmm0_info, xmm0_value)) {
+            DataExtractor data;
+            if (xmm0_value.GetData(data)) {
+              lldb::offset_t offset = 0;
+              if (*byte_size == sizeof(float)) {
+                value.GetScalar() = (float)data.GetFloat(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(double)) {
+                value.GetScalar() = (double)data.GetDouble(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(long double)) {
+                // Don't handle long double since that can be encoded as 80 bit
+                // floats...
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (success)
+      return_valobj_sp = ValueObjectConstResult::Create(
+          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
+  } else if ((type_flags & eTypeIsPointer) ||
+             (type_flags & eTypeInstanceIsPointer)) {
+    unsigned rax_id =
+        reg_ctx->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
+    value.GetScalar() =
+        (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
+                                                                      0);
+    value.SetValueType(Value::eValueTypeScalar);
+    return_valobj_sp = ValueObjectConstResult::Create(
+        thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
+  } else if (type_flags & eTypeIsVector) {
+    llvm::Optional<uint64_t> byte_size =
+        return_compiler_type.GetByteSize(nullptr);
+    if (byte_size && *byte_size > 0) {
+      const RegisterInfo *altivec_reg =
+          reg_ctx->GetRegisterInfoByName("xmm0", 0);
+      if (altivec_reg == nullptr)
+        altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
+
+      if (altivec_reg) {
+        if (*byte_size <= altivec_reg->byte_size) {
+          ProcessSP process_sp(thread.GetProcess());
+          if (process_sp) {
+            std::unique_ptr<DataBufferHeap> heap_data_up(
+                new DataBufferHeap(*byte_size, 0));
+            const ByteOrder byte_order = process_sp->GetByteOrder();
+            RegisterValue reg_value;
+            if (reg_ctx->ReadRegister(altivec_reg, reg_value)) {
+              Status error;
+              if (reg_value.GetAsMemoryData(
+                      altivec_reg, heap_data_up->GetBytes(),
+                      heap_data_up->GetByteSize(), byte_order, error)) {
+                DataExtractor data(DataBufferSP(heap_data_up.release()),
+                                   byte_order,
+                                   process_sp->GetTarget()
+                                       .GetArchitecture()
+                                       .GetAddressByteSize());
+                return_valobj_sp = ValueObjectConstResult::Create(
+                    &thread, return_compiler_type, ConstString(""), data);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return return_valobj_sp;
+}
+
+bool ExtractAggregateTypeHelper(ExecutionContext &exe_ctx,
+                                CompilerType &return_compiler_type,
+                                const DataExtractor &rax_data,
+                                const ByteOrder byte_order,
+                                DataBufferSP &data_sp,
+                                uint32_t data_byte_offset,
+                                uint32_t&used_bytes, bool is_memory) {
+  const uint32_t num_children = return_compiler_type.GetNumFields();
+  for (uint32_t idx = 0; idx < num_children; idx++) {
+    std::string name;
+    bool already_copied = false; // in case of copying using helper function
+
+    const bool transparent_ptr = false;
+    const bool omit_empty_base_classes = true;
+    const bool ignore_array_bounds = false;
+    uint32_t child_byte_size = 0;
+    int32_t child_byte_offset = 0;
+    uint32_t child_bitfield_bit_size = 0;
+    uint32_t child_bitfield_bit_offset = 0;
+    bool child_is_base_class = false;
+    bool child_is_deref_of_parent = false;
+    uint64_t language_flags;
+    CompilerType field_compiler_type =
+      return_compiler_type.GetChildCompilerTypeAtIndex(
+        &exe_ctx, idx, transparent_ptr, omit_empty_base_classes,
+        ignore_array_bounds, name, child_byte_size, child_byte_offset,
+        child_bitfield_bit_size, child_bitfield_bit_offset,
+        child_is_base_class, child_is_deref_of_parent, nullptr, language_flags);
+
+    const uint64_t field_bit_offset = child_byte_offset * 8;
+    const size_t field_bit_width = child_byte_size * 8 +
+                                   child_bitfield_bit_size;
+
+    // if we don't know the size of the field (e.g. invalid type), just
+    // bail out
+    if (field_bit_width == 0) {
+      break;
+    }
+    // If there are any unaligned fields, this is stored in memory.
+    if (field_bit_offset % field_bit_width != 0) {
+      is_memory = true;
+      break;
+    }
+
+    uint32_t field_byte_width = field_bit_width / 8;
+    uint32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
+
+    // this is unlikely w/o the overall size being greater than 8 bytes
+    // For now, return a nullptr return value object.
+    if (used_bytes >= 8 || used_bytes + field_byte_width > 8) {
+      return false;
+    }
+
+    const DataExtractor *copy_from_extractor = NULL;
+    uint32_t copy_from_offset = 0;
+    const uint32_t field_byte_flags = field_compiler_type.GetTypeInfo();
+
+    if (field_byte_flags & eTypeIsInteger ||
+        field_byte_flags & eTypeIsPointer ||
+        field_byte_flags & eTypeIsReference ||
+        field_byte_flags & eTypeIsFloat) {
+      copy_from_extractor = &rax_data;
+      copy_from_offset = used_bytes;
+      used_bytes += field_byte_width;
+    } else if (field_byte_flags & eTypeHasChildren) {
+      if (!ExtractAggregateTypeHelper(exe_ctx, field_compiler_type, rax_data,
+                                     byte_order, data_sp, field_byte_offset,
+                                     used_bytes, is_memory)) {
+        return false;
+      } else {
+        already_copied  = true;
+      }
+    }
+
+    if (!already_copied) {
+      // These two tests are just sanity checks.  If I somehow get the type
+      // calculation wrong above it is better to just return nothing than to
+      // assert or crash.
+      if (!copy_from_extractor) {
+        return false;
+      }
+      if (copy_from_offset + field_byte_width >
+          copy_from_extractor->GetByteSize()) {
+        return false;
+      }
+      copy_from_extractor->CopyByteOrderedData(copy_from_offset,
+          field_byte_width, data_sp->GetBytes() + field_byte_offset,
+          field_byte_width, byte_order);
+    }
+  }
+  return true;
+}
+
+ValueObjectSP ABIWindows_x86_64::GetReturnValueObjectImpl(
+    Thread &thread, CompilerType &return_compiler_type) const {
+  ValueObjectSP return_valobj_sp;
+
+  if (!return_compiler_type) {
+    return return_valobj_sp;
+  }
+
+  // try extract value as if it's a simple type
+  return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
+  if (return_valobj_sp) {
+    return return_valobj_sp;
+  }
+
+  RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
+  if (!reg_ctx_sp) {
+    return return_valobj_sp;
+  }
+
+  llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
+  if (!bit_width) {
+    return return_valobj_sp;
+  }
+
+  // if it's not simple or aggregate type, then we don't know how to handle it
+  if (!return_compiler_type.IsAggregateType()) {
+    return return_valobj_sp;
+  }
+
+  // The scenario here is to have a struct/class which is POD
+  // if the return struct/class size is larger than 64 bits,
+  // the caller will allocate memory for it and pass the return addr in RCX
+  // then return the address in RAX
+  // if the struct/class can fit into a single register (64 bit)
+  // then return the value in RAX
+
+  ExecutionContext exe_ctx(thread.shared_from_this());
+  Target *target = exe_ctx.GetTargetPtr();
+  bool is_memory = true;
+
+  // Windows only support one register for return at this time
+  // which is RAX
+  // and if the struct is returned by value on register
+  // its size has to be: 1, 2, 4, 8, 16, 32, or 64 bits (aligned)
+  // for floating point, the return value will be copied over to RAX
+  uint32_t max_register_value_bit_width = 64;
+  if (*bit_width <= max_register_value_bit_width
+      && !(*bit_width & (*bit_width - 1))) {
+    ByteOrder byte_order = target->GetArchitecture().GetByteOrder();
+    DataBufferSP data_sp(
+        new DataBufferHeap(max_register_value_bit_width / 8, 0));
+    DataExtractor return_ext(data_sp, byte_order,
+        target->GetArchitecture().GetAddressByteSize());
+
+    // The only register used to return struct/class by value
+    const RegisterInfo *rax_info =
+        reg_ctx_sp->GetRegisterInfoByName("rax", 0);
+    RegisterValue rax_value;
+    reg_ctx_sp->ReadRegister(rax_info, rax_value);
+    DataExtractor rax_data;
+    rax_value.GetData(rax_data);
+
+    uint32_t used_bytes =
+        0; // Tracks how much of the rax registers we've consumed so far
+    const uint32_t num_children = return_compiler_type.GetNumFields();
+
+    // Since we are in the small struct regime, assume we are not in memory.
+    is_memory = false;
+
+    for (uint32_t idx = 0; idx < num_children; idx++) {
+      std::string name;
+      uint64_t field_bit_offset = 0;
+      bool is_signed;
+      bool is_complex;
+      uint32_t count;
+      bool already_copied = false; // in case of copying using helper function
+
+      CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
+          idx, name, &field_bit_offset, nullptr, nullptr);
+      llvm::Optional<uint64_t> field_bit_width =
+          field_compiler_type.GetBitSize(&thread);
+
+      // if we don't know the size of the field (e.g. invalid type), just
+      // bail out
+      if (!field_bit_width || *field_bit_width == 0) {
+        break;
+      }
+      // If there are any unaligned fields, this is stored in memory.
+      if (field_bit_offset % *field_bit_width != 0) {
+        is_memory = true;
+        break;
+      }
+
+      uint32_t field_byte_width = *field_bit_width / 8;
+      uint32_t field_byte_offset = field_bit_offset / 8;
+
+      // this is unlikely w/o the overall size being greater than 8 bytes
+      // For now, return a nullptr return value object.
+      if (used_bytes >= 8 || used_bytes + field_byte_width > 8) {
+        return return_valobj_sp;
+      }
+
+      DataExtractor *copy_from_extractor = nullptr;
+      uint32_t copy_from_offset = 0;
+      const uint32_t field_byte_flags = field_compiler_type.GetTypeInfo();
+
+      if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
+          field_compiler_type.IsPointerType() ||
+          field_compiler_type.IsFloatingPointType(count, is_complex)) {
+        copy_from_extractor = &rax_data;
+        copy_from_offset = used_bytes;
+        used_bytes += field_byte_width;
+      } else if (field_byte_flags & eTypeHasChildren) {
+        // nested struct, use helper to extract recursively
+        if (!ExtractAggregateTypeHelper(exe_ctx, field_compiler_type, rax_data,
+                                        byte_order, data_sp, field_byte_offset,
+                                        used_bytes, is_memory)) {
+          return return_valobj_sp;
+        } else {
+          copy_from_extractor = &return_ext;
+        }
+        already_copied  = true;
+      }
+
+      // These two tests are just sanity checks.  If I somehow get the type
+      // calculation wrong above it is better to just return nothing than to
+      // assert or crash.
+      if (!already_copied) {
+        if (!copy_from_extractor) {
+          return return_valobj_sp;
+        }
+        if (copy_from_offset + field_byte_width >
+            copy_from_extractor->GetByteSize()) {
+          return return_valobj_sp;
+        }
+        copy_from_extractor->CopyByteOrderedData(copy_from_offset,
+            field_byte_width, data_sp->GetBytes() + field_byte_offset,
+            field_byte_width, byte_order);
+      }
+    }
+    if (!is_memory) {
+      // The result is in our data buffer.  Let's make a variable object out
+      // of it:
+      return_valobj_sp = ValueObjectConstResult::Create(
+          &thread, return_compiler_type, ConstString(""), return_ext);
+    }
+  }
+
+  // The Windows x86_64 ABI specifies that the return address for MEMORY
+  // objects be placed in rax on exit from the function.
+
+  // FIXME: This is just taking a guess, rax may very well no longer hold the
+  // return storage location.
+  // If we are going to do this right, when we make a new frame we should
+  // check to see if it uses a memory return, and if we are at the first
+  // instruction and if so stash away the return location.  Then we would
+  // only return the memory return value if we know it is valid.
+  if (is_memory) {
+    unsigned rax_id =
+        reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
+    lldb::addr_t storage_addr =
+        (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
+                                                                      0);
+    return_valobj_sp = ValueObjectMemory::Create(
+        &thread, "", Address(storage_addr, nullptr), return_compiler_type);
+  }
+  return return_valobj_sp;
+}
+
+// This defines the CFA as rsp+8
+// the saved pc is at CFA-8 (i.e. rsp+0)
+// The saved rsp is CFA+0
+
+bool ABIWindows_x86_64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
+
+  uint32_t sp_reg_num = dwarf_rsp;
+  uint32_t pc_reg_num = dwarf_rip;
+
+  UnwindPlan::RowSP row(new UnwindPlan::Row);
+  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 8);
+  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
+  row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
+  unwind_plan.AppendRow(row);
+  unwind_plan.SetSourceName("x86_64 at-func-entry default");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
+  return true;
+}
+
+// Windows doesn't use rbp
+// Let this return false
+bool ABIWindows_x86_64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
+  return false;
+}
+
+bool ABIWindows_x86_64::RegisterIsVolatile(const RegisterInfo *reg_info) {
+  return !RegisterIsCalleeSaved(reg_info);
+}
+
+bool ABIWindows_x86_64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
+  if (!reg_info)
+    return false;
+  assert(reg_info->name != nullptr && "unnamed register?");
+  std::string Name = std::string(reg_info->name);
+  bool IsCalleeSaved =
+      llvm::StringSwitch<bool>(Name)
+          .Cases("rbx", "ebx", "rbp", "ebp", "rdi", "edi", "rsi", "esi", true)
+          .Cases("rsp", "esp", "r12", "r13", "r14", "r15", "sp", "fp", true)
+          .Cases("xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12",
+                 "xmm13", "xmm14", "xmm15", true)
+          .Default(false);
+  return IsCalleeSaved;
+}
+
+void ABIWindows_x86_64::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "Windows ABI for x86_64 targets", CreateInstance);
+}
+
+void ABIWindows_x86_64::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString ABIWindows_x86_64::GetPluginNameStatic() {
+  static ConstString g_name("windows-x86_64");
+  return g_name;
+}
+
+//------------------------------------------------------------------
+// PluginInterface protocol
+//------------------------------------------------------------------
+
+lldb_private::ConstString ABIWindows_x86_64::GetPluginName() {
+  return GetPluginNameStatic();
+}
+
+uint32_t ABIWindows_x86_64::GetPluginVersion() { return 1; }

lldb/source/Plugins/ABI/Windows-x86_64/CMakeLists.txt

+add_lldb_library(lldbPluginABIWindows_x86_64 PLUGIN
+  ABIWindows_x86_64.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbSymbol
+    lldbTarget
+  LINK_COMPONENTS
+    Support
+  )

lldb/source/Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.cpp

      nullptr,
      nullptr},
     {DEFINE_GPR(r10, nullptr),
-     {dwarf_r10_x86_64, dwarf_r10_x86_64, LLDB_REGNUM_GENERIC_ARG5,
+     {dwarf_r10_x86_64, dwarf_r10_x86_64, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_r10_x86_64},
      nullptr,
      nullptr},
     {DEFINE_GPR(r11, nullptr),
-     {dwarf_r11_x86_64, dwarf_r11_x86_64, LLDB_REGNUM_GENERIC_ARG6,
+     {dwarf_r11_x86_64, dwarf_r11_x86_64, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_r11_x86_64},
      nullptr,
      nullptr},