This is an archive of the discontinued LLVM Phabricator instance.

Differential D118750

[LLDB] add sub register enums on x64 Windows
ClosedPublic

Authored by zequanwu on Feb 1 2022, 5:22 PM.

Details

Reviewers
labath
compnerd
kusmour
stella.stamenova
Commits
rGf3e1ba1d0392: [LLDB] add sub regigter enums on x64 Windows
Summary

This adds 32bit, 16bit, 8bit register enumerations to x64 Windows.

Diff Detail

Event Timeline

zequanwu requested review of this revision.Feb 1 2022, 5:22 PM
zequanwu created this revision.
Harbormaster completed remote builds in B147049: Diff 405130.Feb 1 2022, 5:25 PM
labath accepted this revision.Feb 2 2022, 2:07 AM

This would be a good example of why switching to the lldb-server based implementation would be beneficial. We now have code which will automatically create these subregisters there, and so I may soon start removing these registers from other targets.

This revision is now accepted and ready to land.Feb 2 2022, 2:07 AM
Closed by commit rGf3e1ba1d0392: [LLDB] add sub regigter enums on x64 Windows (authored by zequanwu). · Explain WhyFeb 2 2022, 2:21 PM
This revision was automatically updated to reflect the committed changes.
zequanwu added a commit: rGf3e1ba1d0392: [LLDB] add sub regigter enums on x64 Windows.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 2 2022, 2:21 PM
Herald added a subscriber: lldb-commits. · View Herald Transcript
stella.stamenova added a comment.Feb 2 2022, 4:03 PM

This broke the windows bot in the best way possible - by making some tests pass now that didn't use to. Could you un-xfail those too?

https://lab.llvm.org/buildbot/#/builders/83/builds/14736

Herald added a subscriber: JDevlieghere. · View Herald TranscriptFeb 2 2022, 4:03 PM
zequanwu mentioned this in D118866: [LLDB] Fix window bot failure.Feb 2 2022, 5:17 PM
zequanwu mentioned this in rG607ffa5515b9: [LLDB] Fix window bot failure.Feb 3 2022, 11:27 AM

Revision Contents

PathSize
lldb/
source/
Plugins/
Process/
Windows/
Common/
x64/
430 lines
test/
Shell/
Register/
1 line

Diff 405130

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

Show All 18 Lines
#include "TargetThreadWindows.h" #include "TargetThreadWindows.h"
#include "Plugins/Process/Utility/lldb-x86-register-enums.h" #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
#define DEFINE_GPR(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase #define DEFINE_GPR(reg, alt, generic) \
{ \
#reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase, \
{dwarf_##reg##_x86_64, dwarf_##reg##_x86_64, generic, \
LLDB_INVALID_REGNUM, lldb_##reg##_x86_64 }, \
nullptr, nullptr, \
}
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary #define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary
#define DEFINE_FPU_XMM(reg) \ #define DEFINE_FPU_XMM(reg) \
#reg, NULL, 16, 0, eEncodingUint, eFormatVectorOfUInt64, \ #reg, NULL, 16, 0, eEncodingUint, eFormatVectorOfUInt64, \
{dwarf_##reg##_x86_64, dwarf_##reg##_x86_64, LLDB_INVALID_REGNUM, \ {dwarf_##reg##_x86_64, dwarf_##reg##_x86_64, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, lldb_##reg##_x86_64}, \ LLDB_INVALID_REGNUM, lldb_##reg##_x86_64}, \
nullptr, nullptr nullptr, nullptr
#define DEFINE_GPR_PSEUDO_32(reg) \
{ \
#reg, nullptr, 4, 0, eEncodingUint, eFormatHexUppercase, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, lldb_##reg##_x86_64 }, \
nullptr, nullptr \
}
#define DEFINE_GPR_PSEUDO_16(reg) \
{ \
#reg, nullptr, 2, 0, eEncodingUint, eFormatHexUppercase, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, lldb_##reg##_x86_64 }, \
nullptr, nullptr \
}
#define DEFINE_GPR_PSEUDO_8(reg) \
{ \
#reg, nullptr, 1, 0, eEncodingUint, eFormatHexUppercase, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, lldb_##reg##_x86_64 }, \
nullptr, nullptr \
}
namespace { namespace {
// This enum defines the layout of the global RegisterInfo array. This is // This enum defines the layout of the global RegisterInfo array. This is
// necessary because lldb register sets are defined in terms of indices into // necessary because lldb register sets are defined in terms of indices into
// the register array. As such, the order of RegisterInfos defined in global // the register array. As such, the order of RegisterInfos defined in global
// registers array must match the order defined here. When defining the // registers array must match the order defined here. When defining the
// register set layouts, these values can appear in an arbitrary order, and // register set layouts, these values can appear in an arbitrary order, and
// that determines the order that register values are displayed in a dump. // that determines the order that register values are displayed in a dump.
Show All 11 Linesenum RegisterIndex {
eRegisterIndexR10, eRegisterIndexR10,
eRegisterIndexR11, eRegisterIndexR11,
eRegisterIndexR12, eRegisterIndexR12,
eRegisterIndexR13, eRegisterIndexR13,
eRegisterIndexR14, eRegisterIndexR14,
eRegisterIndexR15, eRegisterIndexR15,
eRegisterIndexRip, eRegisterIndexRip,
eRegisterIndexRflags, eRegisterIndexRflags,
eRegisterIndexEax,
eRegisterIndexEbx,
eRegisterIndexEcx,
eRegisterIndexEdx,
eRegisterIndexEdi,
eRegisterIndexEsi,
eRegisterIndexEbp,
eRegisterIndexEsp,
eRegisterIndexR8d,
eRegisterIndexR9d,
eRegisterIndexR10d,
eRegisterIndexR11d,
eRegisterIndexR12d,
eRegisterIndexR13d,
eRegisterIndexR14d,
eRegisterIndexR15d,
eRegisterIndexAx,
eRegisterIndexBx,
eRegisterIndexCx,
eRegisterIndexDx,
eRegisterIndexDi,
eRegisterIndexSi,
eRegisterIndexBp,
eRegisterIndexSp,
eRegisterIndexR8w,
eRegisterIndexR9w,
eRegisterIndexR10w,
eRegisterIndexR11w,
eRegisterIndexR12w,
eRegisterIndexR13w,
eRegisterIndexR14w,
eRegisterIndexR15w,
eRegisterIndexAh,
eRegisterIndexBh,
eRegisterIndexCh,
eRegisterIndexDh,
eRegisterIndexAl,
eRegisterIndexBl,
eRegisterIndexCl,
eRegisterIndexDl,
eRegisterIndexDil,
eRegisterIndexSil,
eRegisterIndexBpl,
eRegisterIndexSpl,
eRegisterIndexR8l,
eRegisterIndexR9l,
eRegisterIndexR10l,
eRegisterIndexR11l,
eRegisterIndexR12l,
eRegisterIndexR13l,
eRegisterIndexR14l,
eRegisterIndexR15l,
eRegisterIndexR16l,
eRegisterIndexXmm0, eRegisterIndexXmm0,
eRegisterIndexXmm1, eRegisterIndexXmm1,
eRegisterIndexXmm2, eRegisterIndexXmm2,
eRegisterIndexXmm3, eRegisterIndexXmm3,
eRegisterIndexXmm4, eRegisterIndexXmm4,
eRegisterIndexXmm5, eRegisterIndexXmm5,
eRegisterIndexXmm6, eRegisterIndexXmm6,
Show All 11 Lines
// Array of all register information supported by Windows x86 // Array of all register information supported by Windows x86
RegisterInfo g_register_infos[] = { RegisterInfo g_register_infos[] = {
// Macro auto defines most stuff eh_frame DWARF // Macro auto defines most stuff eh_frame DWARF
// GENERIC // GENERIC
// GDB LLDB VALUE REGS INVALIDATE REGS // GDB LLDB VALUE REGS INVALIDATE REGS
// ================================ ========================= // ================================ =========================
// ====================== ========================= // ====================== =========================
// =================== ================= ========== =============== // =================== ================= ========== ===============
{DEFINE_GPR(rax, nullptr), DEFINE_GPR(rax, nullptr, LLDB_INVALID_REGNUM),
{dwarf_rax_x86_64, dwarf_rax_x86_64, LLDB_INVALID_REGNUM, DEFINE_GPR(rbx, nullptr, LLDB_INVALID_REGNUM),
LLDB_INVALID_REGNUM, lldb_rax_x86_64}, DEFINE_GPR(rcx, nullptr, LLDB_REGNUM_GENERIC_ARG1),
nullptr, DEFINE_GPR(rdx, nullptr, LLDB_REGNUM_GENERIC_ARG2),
nullptr, DEFINE_GPR(rdi, nullptr, LLDB_INVALID_REGNUM),
}, DEFINE_GPR(rsi, nullptr, LLDB_INVALID_REGNUM),
{DEFINE_GPR(rbx, nullptr), DEFINE_GPR(rbp, "fp", LLDB_REGNUM_GENERIC_FP),
{dwarf_rbx_x86_64, dwarf_rbx_x86_64, LLDB_INVALID_REGNUM, DEFINE_GPR(rsp, "sp", LLDB_REGNUM_GENERIC_SP),
LLDB_INVALID_REGNUM, lldb_rbx_x86_64}, DEFINE_GPR(r8, nullptr, LLDB_REGNUM_GENERIC_ARG3),
nullptr, DEFINE_GPR(r9, nullptr, LLDB_REGNUM_GENERIC_ARG4),
nullptr, DEFINE_GPR(r10, nullptr, LLDB_INVALID_REGNUM),
}, DEFINE_GPR(r11, nullptr, LLDB_INVALID_REGNUM),
{DEFINE_GPR(rcx, nullptr), DEFINE_GPR(r12, nullptr, LLDB_INVALID_REGNUM),
{dwarf_rcx_x86_64, dwarf_rcx_x86_64, LLDB_REGNUM_GENERIC_ARG1, DEFINE_GPR(r13, nullptr, LLDB_INVALID_REGNUM),
LLDB_INVALID_REGNUM, lldb_rcx_x86_64}, DEFINE_GPR(r14, nullptr, LLDB_INVALID_REGNUM),
nullptr, DEFINE_GPR(r15, nullptr, LLDB_INVALID_REGNUM),
nullptr, DEFINE_GPR(rip, "pc", LLDB_REGNUM_GENERIC_PC),
}, {
{DEFINE_GPR(rdx, nullptr), DEFINE_GPR_BIN(eflags, "flags"),
{dwarf_rdx_x86_64, dwarf_rdx_x86_64, LLDB_REGNUM_GENERIC_ARG2,
LLDB_INVALID_REGNUM, lldb_rdx_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(rdi, nullptr),
{dwarf_rdi_x86_64, dwarf_rdi_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_rdi_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(rsi, nullptr),
{dwarf_rsi_x86_64, dwarf_rsi_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_rsi_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(rbp, "fp"),
{dwarf_rbp_x86_64, dwarf_rbp_x86_64, LLDB_REGNUM_GENERIC_FP,
LLDB_INVALID_REGNUM, lldb_rbp_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(rsp, "sp"),
{dwarf_rsp_x86_64, dwarf_rsp_x86_64, LLDB_REGNUM_GENERIC_SP,
LLDB_INVALID_REGNUM, lldb_rsp_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r8, nullptr),
{dwarf_r8_x86_64, dwarf_r8_x86_64, LLDB_REGNUM_GENERIC_ARG3,
LLDB_INVALID_REGNUM, lldb_r8_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r9, nullptr),
{dwarf_r9_x86_64, dwarf_r9_x86_64, LLDB_REGNUM_GENERIC_ARG4,
LLDB_INVALID_REGNUM, lldb_r9_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r10, nullptr),
{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_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_r11_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r12, nullptr),
{dwarf_r12_x86_64, dwarf_r12_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_r12_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r13, nullptr),
{dwarf_r13_x86_64, dwarf_r13_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_r13_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r14, nullptr),
{dwarf_r14_x86_64, dwarf_r14_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_r14_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(r15, nullptr),
{dwarf_r15_x86_64, dwarf_r15_x86_64, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, lldb_r15_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR(rip, "pc"),
{dwarf_rip_x86_64, dwarf_rip_x86_64, LLDB_REGNUM_GENERIC_PC,
LLDB_INVALID_REGNUM, lldb_rip_x86_64},
nullptr,
nullptr,
},
{DEFINE_GPR_BIN(eflags, "flags"),
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,
LLDB_INVALID_REGNUM, lldb_rflags_x86_64}, LLDB_INVALID_REGNUM, lldb_rflags_x86_64},
nullptr, nullptr,
nullptr, nullptr,
}, },
DEFINE_GPR_PSEUDO_32(eax),
DEFINE_GPR_PSEUDO_32(ebx),
DEFINE_GPR_PSEUDO_32(ecx),
DEFINE_GPR_PSEUDO_32(edx),
DEFINE_GPR_PSEUDO_32(edi),
DEFINE_GPR_PSEUDO_32(esi),
DEFINE_GPR_PSEUDO_32(ebp),
DEFINE_GPR_PSEUDO_32(esp),
DEFINE_GPR_PSEUDO_32(r8d),
DEFINE_GPR_PSEUDO_32(r9d),
DEFINE_GPR_PSEUDO_32(r10d),
DEFINE_GPR_PSEUDO_32(r11d),
DEFINE_GPR_PSEUDO_32(r12d),
DEFINE_GPR_PSEUDO_32(r13d),
DEFINE_GPR_PSEUDO_32(r14d),
DEFINE_GPR_PSEUDO_32(r15d),
DEFINE_GPR_PSEUDO_16(ax),
DEFINE_GPR_PSEUDO_16(bx),
DEFINE_GPR_PSEUDO_16(cx),
DEFINE_GPR_PSEUDO_16(dx),
DEFINE_GPR_PSEUDO_16(di),
DEFINE_GPR_PSEUDO_16(si),
DEFINE_GPR_PSEUDO_16(bp),
DEFINE_GPR_PSEUDO_16(sp),
DEFINE_GPR_PSEUDO_16(r8w),
DEFINE_GPR_PSEUDO_16(r9w),
DEFINE_GPR_PSEUDO_16(r10w),
DEFINE_GPR_PSEUDO_16(r11w),
DEFINE_GPR_PSEUDO_16(r12w),
DEFINE_GPR_PSEUDO_16(r13w),
DEFINE_GPR_PSEUDO_16(r14w),
DEFINE_GPR_PSEUDO_16(r15w),
DEFINE_GPR_PSEUDO_8(ah),
DEFINE_GPR_PSEUDO_8(bh),
DEFINE_GPR_PSEUDO_8(ch),
DEFINE_GPR_PSEUDO_8(dh),
DEFINE_GPR_PSEUDO_8(al),
DEFINE_GPR_PSEUDO_8(bl),
DEFINE_GPR_PSEUDO_8(cl),
DEFINE_GPR_PSEUDO_8(dl),
DEFINE_GPR_PSEUDO_8(dil),
DEFINE_GPR_PSEUDO_8(sil),
DEFINE_GPR_PSEUDO_8(bpl),
DEFINE_GPR_PSEUDO_8(spl),
DEFINE_GPR_PSEUDO_8(r8l),
DEFINE_GPR_PSEUDO_8(r9l),
DEFINE_GPR_PSEUDO_8(r10l),
DEFINE_GPR_PSEUDO_8(r11l),
DEFINE_GPR_PSEUDO_8(r12l),
DEFINE_GPR_PSEUDO_8(r13l),
DEFINE_GPR_PSEUDO_8(r14l),
DEFINE_GPR_PSEUDO_8(r15l),
{DEFINE_FPU_XMM(xmm0)}, {DEFINE_FPU_XMM(xmm0)},
{DEFINE_FPU_XMM(xmm1)}, {DEFINE_FPU_XMM(xmm1)},
{DEFINE_FPU_XMM(xmm2)}, {DEFINE_FPU_XMM(xmm2)},
{DEFINE_FPU_XMM(xmm3)}, {DEFINE_FPU_XMM(xmm3)},
{DEFINE_FPU_XMM(xmm4)}, {DEFINE_FPU_XMM(xmm4)},
{DEFINE_FPU_XMM(xmm5)}, {DEFINE_FPU_XMM(xmm5)},
{DEFINE_FPU_XMM(xmm6)}, {DEFINE_FPU_XMM(xmm6)},
{DEFINE_FPU_XMM(xmm7)}, {DEFINE_FPU_XMM(xmm7)},
{DEFINE_FPU_XMM(xmm8)}, {DEFINE_FPU_XMM(xmm8)},
{DEFINE_FPU_XMM(xmm9)}, {DEFINE_FPU_XMM(xmm9)},
{DEFINE_FPU_XMM(xmm10)}, {DEFINE_FPU_XMM(xmm10)},
{DEFINE_FPU_XMM(xmm11)}, {DEFINE_FPU_XMM(xmm11)},
{DEFINE_FPU_XMM(xmm12)}, {DEFINE_FPU_XMM(xmm12)},
{DEFINE_FPU_XMM(xmm13)}, {DEFINE_FPU_XMM(xmm13)},
{DEFINE_FPU_XMM(xmm14)}, {DEFINE_FPU_XMM(xmm14)},
{DEFINE_FPU_XMM(xmm15)} {DEFINE_FPU_XMM(xmm15)}};
};
static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos); static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
// Array of lldb register numbers used to define the set of all General Purpose // Array of lldb register numbers used to define the set of all General Purpose
// Registers // Registers
uint32_t g_gpr_reg_indices[] = { uint32_t g_gpr_reg_indices[] = {
eRegisterIndexRax, eRegisterIndexRbx, eRegisterIndexRcx, eRegisterIndexRax, eRegisterIndexRbx, eRegisterIndexRcx,
eRegisterIndexRdx, eRegisterIndexRdi, eRegisterIndexRsi, eRegisterIndexRdx, eRegisterIndexRdi, eRegisterIndexRsi,
eRegisterIndexRbp, eRegisterIndexRsp, eRegisterIndexR8, eRegisterIndexRbp, eRegisterIndexRsp, eRegisterIndexR8,
eRegisterIndexR9, eRegisterIndexR10, eRegisterIndexR11, eRegisterIndexR9, eRegisterIndexR10, eRegisterIndexR11,
eRegisterIndexR12, eRegisterIndexR13, eRegisterIndexR14, eRegisterIndexR12, eRegisterIndexR13, eRegisterIndexR14,
eRegisterIndexR15, eRegisterIndexRip, eRegisterIndexRflags}; eRegisterIndexR15, eRegisterIndexRip, eRegisterIndexRflags,
eRegisterIndexEax, eRegisterIndexEbx, eRegisterIndexEcx,
eRegisterIndexEdx, eRegisterIndexEdi, eRegisterIndexEsi,
eRegisterIndexEbp, eRegisterIndexEsp, eRegisterIndexR8d,
eRegisterIndexR9d, eRegisterIndexR10d, eRegisterIndexR11d,
eRegisterIndexR12d, eRegisterIndexR13d, eRegisterIndexR14d,
eRegisterIndexR15d, eRegisterIndexAx, eRegisterIndexBx,
eRegisterIndexCx, eRegisterIndexDx, eRegisterIndexDi,
eRegisterIndexSi, eRegisterIndexBp, eRegisterIndexSp,
eRegisterIndexR8w, eRegisterIndexR9w, eRegisterIndexR10w,
eRegisterIndexR11w, eRegisterIndexR12w, eRegisterIndexR13w,
eRegisterIndexR14w, eRegisterIndexR15w, eRegisterIndexAh,
eRegisterIndexBh, eRegisterIndexCh, eRegisterIndexDh,
eRegisterIndexAl, eRegisterIndexBl, eRegisterIndexCl,
eRegisterIndexDl, eRegisterIndexDil, eRegisterIndexSil,
eRegisterIndexBpl, eRegisterIndexSpl, eRegisterIndexR8l,
eRegisterIndexR9l, eRegisterIndexR10l, eRegisterIndexR11l,
eRegisterIndexR12l, eRegisterIndexR13l, eRegisterIndexR14l,
eRegisterIndexR15l, eRegisterIndexR16l,
};
uint32_t g_fpu_reg_indices[] = { uint32_t g_fpu_reg_indices[] = {
eRegisterIndexXmm0, eRegisterIndexXmm1, eRegisterIndexXmm2, eRegisterIndexXmm0, eRegisterIndexXmm1, eRegisterIndexXmm2,
eRegisterIndexXmm3, eRegisterIndexXmm4, eRegisterIndexXmm5, eRegisterIndexXmm3, eRegisterIndexXmm4, eRegisterIndexXmm5,
eRegisterIndexXmm6, eRegisterIndexXmm7, eRegisterIndexXmm8, eRegisterIndexXmm6, eRegisterIndexXmm7, eRegisterIndexXmm8,
eRegisterIndexXmm9, eRegisterIndexXmm10, eRegisterIndexXmm11, eRegisterIndexXmm9, eRegisterIndexXmm10, eRegisterIndexXmm11,
eRegisterIndexXmm12, eRegisterIndexXmm13, eRegisterIndexXmm14, eRegisterIndexXmm12, eRegisterIndexXmm13, eRegisterIndexXmm14,
eRegisterIndexXmm15 eRegisterIndexXmm15
Show All 38 Lines if (!CacheAllRegisterValues())
return false; return false;
if (reg_info == nullptr) if (reg_info == nullptr)
return false; return false;
const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
switch (reg) { switch (reg) {
case lldb_rax_x86_64: #define GPR_CASE(size, reg_case, reg_val) \
reg_value.SetUInt64(m_context.Rax); case reg_case: \
break; reg_value.SetUInt##size(reg_val); \
case lldb_rbx_x86_64: break;
reg_value.SetUInt64(m_context.Rbx);
break; GPR_CASE(64, lldb_rax_x86_64, m_context.Rax);
case lldb_rcx_x86_64: GPR_CASE(64, lldb_rbx_x86_64, m_context.Rbx);
reg_value.SetUInt64(m_context.Rcx); GPR_CASE(64, lldb_rcx_x86_64, m_context.Rcx);
break; GPR_CASE(64, lldb_rdx_x86_64, m_context.Rdx);
case lldb_rdx_x86_64: GPR_CASE(64, lldb_rdi_x86_64, m_context.Rdi);
reg_value.SetUInt64(m_context.Rdx); GPR_CASE(64, lldb_rsi_x86_64, m_context.Rsi);
break; GPR_CASE(64, lldb_r8_x86_64, m_context.R8);
case lldb_rdi_x86_64: GPR_CASE(64, lldb_r9_x86_64, m_context.R9);
reg_value.SetUInt64(m_context.Rdi); GPR_CASE(64, lldb_r10_x86_64, m_context.R10);
break; GPR_CASE(64, lldb_r11_x86_64, m_context.R11);
case lldb_rsi_x86_64: GPR_CASE(64, lldb_r12_x86_64, m_context.R12);
reg_value.SetUInt64(m_context.Rsi); GPR_CASE(64, lldb_r13_x86_64, m_context.R13);
break; GPR_CASE(64, lldb_r14_x86_64, m_context.R14);
case lldb_r8_x86_64: GPR_CASE(64, lldb_r15_x86_64, m_context.R15);
reg_value.SetUInt64(m_context.R8); GPR_CASE(64, lldb_rbp_x86_64, m_context.Rbp);
break; GPR_CASE(64, lldb_rsp_x86_64, m_context.Rsp);
case lldb_r9_x86_64: GPR_CASE(64, lldb_rip_x86_64, m_context.Rip);
reg_value.SetUInt64(m_context.R9); GPR_CASE(64, lldb_rflags_x86_64, m_context.EFlags);
break; GPR_CASE(32, lldb_eax_x86_64, static_cast<uint32_t>(m_context.Rax));
case lldb_r10_x86_64: GPR_CASE(32, lldb_ebx_x86_64, static_cast<uint32_t>(m_context.Rbx));
reg_value.SetUInt64(m_context.R10); GPR_CASE(32, lldb_ecx_x86_64, static_cast<uint32_t>(m_context.Rcx));
break; GPR_CASE(32, lldb_edx_x86_64, static_cast<uint32_t>(m_context.Rdx));
case lldb_r11_x86_64: GPR_CASE(32, lldb_edi_x86_64, static_cast<uint32_t>(m_context.Rdi));
reg_value.SetUInt64(m_context.R11); GPR_CASE(32, lldb_esi_x86_64, static_cast<uint32_t>(m_context.Rsi));
break; GPR_CASE(32, lldb_ebp_x86_64, static_cast<uint32_t>(m_context.Rbp));
case lldb_r12_x86_64: GPR_CASE(32, lldb_esp_x86_64, static_cast<uint32_t>(m_context.Rsp));
reg_value.SetUInt64(m_context.R12); GPR_CASE(32, lldb_r8d_x86_64, static_cast<uint32_t>(m_context.R8));
break; GPR_CASE(32, lldb_r9d_x86_64, static_cast<uint32_t>(m_context.R9));
case lldb_r13_x86_64: GPR_CASE(32, lldb_r10d_x86_64, static_cast<uint32_t>(m_context.R10));
reg_value.SetUInt64(m_context.R13); GPR_CASE(32, lldb_r11d_x86_64, static_cast<uint32_t>(m_context.R11));
break; GPR_CASE(32, lldb_r12d_x86_64, static_cast<uint32_t>(m_context.R12));
case lldb_r14_x86_64: GPR_CASE(32, lldb_r13d_x86_64, static_cast<uint32_t>(m_context.R13));
reg_value.SetUInt64(m_context.R14); GPR_CASE(32, lldb_r14d_x86_64, static_cast<uint32_t>(m_context.R14));
break; GPR_CASE(32, lldb_r15d_x86_64, static_cast<uint32_t>(m_context.R15));
case lldb_r15_x86_64: GPR_CASE(16, lldb_ax_x86_64, static_cast<uint16_t>(m_context.Rax));
reg_value.SetUInt64(m_context.R15); GPR_CASE(16, lldb_bx_x86_64, static_cast<uint16_t>(m_context.Rbx));
break; GPR_CASE(16, lldb_cx_x86_64, static_cast<uint16_t>(m_context.Rcx));
case lldb_rbp_x86_64: GPR_CASE(16, lldb_dx_x86_64, static_cast<uint16_t>(m_context.Rdx));
reg_value.SetUInt64(m_context.Rbp); GPR_CASE(16, lldb_di_x86_64, static_cast<uint16_t>(m_context.Rdi));
break; GPR_CASE(16, lldb_si_x86_64, static_cast<uint16_t>(m_context.Rsi));
case lldb_rsp_x86_64: GPR_CASE(16, lldb_bp_x86_64, static_cast<uint16_t>(m_context.Rbp));
reg_value.SetUInt64(m_context.Rsp); GPR_CASE(16, lldb_sp_x86_64, static_cast<uint16_t>(m_context.Rsp));
break; GPR_CASE(16, lldb_r8w_x86_64, static_cast<uint16_t>(m_context.R8));
case lldb_rip_x86_64: GPR_CASE(16, lldb_r9w_x86_64, static_cast<uint16_t>(m_context.R9));
reg_value.SetUInt64(m_context.Rip); GPR_CASE(16, lldb_r10w_x86_64, static_cast<uint16_t>(m_context.R10));
break; GPR_CASE(16, lldb_r11w_x86_64, static_cast<uint16_t>(m_context.R11));
case lldb_rflags_x86_64: GPR_CASE(16, lldb_r12w_x86_64, static_cast<uint16_t>(m_context.R12));
reg_value.SetUInt64(m_context.EFlags); GPR_CASE(16, lldb_r13w_x86_64, static_cast<uint16_t>(m_context.R13));
break; GPR_CASE(16, lldb_r14w_x86_64, static_cast<uint16_t>(m_context.R14));
GPR_CASE(16, lldb_r15w_x86_64, static_cast<uint16_t>(m_context.R15));
GPR_CASE(8, lldb_ah_x86_64, static_cast<uint16_t>(m_context.Rax) >> 8);
GPR_CASE(8, lldb_bh_x86_64, static_cast<uint16_t>(m_context.Rbx) >> 8);
GPR_CASE(8, lldb_ch_x86_64, static_cast<uint16_t>(m_context.Rcx) >> 8);
GPR_CASE(8, lldb_dh_x86_64, static_cast<uint16_t>(m_context.Rdx) >> 8);
GPR_CASE(8, lldb_al_x86_64, static_cast<uint8_t>(m_context.Rax));
GPR_CASE(8, lldb_bl_x86_64, static_cast<uint8_t>(m_context.Rbx));
GPR_CASE(8, lldb_cl_x86_64, static_cast<uint8_t>(m_context.Rcx));
GPR_CASE(8, lldb_dl_x86_64, static_cast<uint8_t>(m_context.Rdx));
GPR_CASE(8, lldb_dil_x86_64, static_cast<uint8_t>(m_context.Rdi));
GPR_CASE(8, lldb_sil_x86_64, static_cast<uint8_t>(m_context.Rsi));
GPR_CASE(8, lldb_bpl_x86_64, static_cast<uint8_t>(m_context.Rbp));
GPR_CASE(8, lldb_spl_x86_64, static_cast<uint8_t>(m_context.Rsp));
GPR_CASE(8, lldb_r8l_x86_64, static_cast<uint8_t>(m_context.R8));
GPR_CASE(8, lldb_r9l_x86_64, static_cast<uint8_t>(m_context.R9));
GPR_CASE(8, lldb_r10l_x86_64, static_cast<uint8_t>(m_context.R10));
GPR_CASE(8, lldb_r11l_x86_64, static_cast<uint8_t>(m_context.R11));
GPR_CASE(8, lldb_r12l_x86_64, static_cast<uint8_t>(m_context.R12));
GPR_CASE(8, lldb_r13l_x86_64, static_cast<uint8_t>(m_context.R13));
GPR_CASE(8, lldb_r14l_x86_64, static_cast<uint8_t>(m_context.R14));
GPR_CASE(8, lldb_r15l_x86_64, static_cast<uint8_t>(m_context.R15));
case lldb_xmm0_x86_64: case lldb_xmm0_x86_64:
reg_value.SetBytes(&m_context.Xmm0, reg_value.SetBytes(&m_context.Xmm0,
reg_info->byte_size, endian::InlHostByteOrder()); reg_info->byte_size, endian::InlHostByteOrder());
break; break;
case lldb_xmm1_x86_64: case lldb_xmm1_x86_64:
reg_value.SetBytes(&m_context.Xmm1, reg_value.SetBytes(&m_context.Xmm1,
reg_info->byte_size, endian::InlHostByteOrder()); reg_info->byte_size, endian::InlHostByteOrder());
break; break;
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

lldb/test/Shell/Register/x86-64-gp-read.test

# XFAIL: system-windows
# REQUIRES: native && target-x86_64 # REQUIRES: native && target-x86_64
# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-64-gp-read.cpp -o %t # RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-64-gp-read.cpp -o %t
# RUN: %lldb -b -s %s %t | FileCheck %s # RUN: %lldb -b -s %s %t | FileCheck %s
process launch process launch
register read --all register read --all
# CHECK-DAG: rax = 0x0102030405060708 # CHECK-DAG: rax = 0x0102030405060708
# CHECK-DAG: rbx = 0x1112131415161718 # CHECK-DAG: rbx = 0x1112131415161718
Show All 33 Lines