This is an archive of the discontinued LLVM Phabricator instance.

Differential D30287

Introduce support for Debug Registers in RegisterContextNetBSD_x86_64
ClosedPublic

Authored by krytarowski on Feb 23 2017, 12:38 AM.

Details

Reviewers
emaste
joerg
clayborg
labath
Commits
rG7a8ac3a63925: Introduce support for Debug Registers in RegisterContextNetBSD_x86_64
rLLDB296071: Introduce support for Debug Registers in RegisterContextNetBSD_x86_64
rL296071: Introduce support for Debug Registers in RegisterContextNetBSD_x86_64
Summary

NetBSD 7.99.62 introduced Debug Registers interface similar to the FreeBSD one.
This interface will land NetBSD-8.0.

Introduce support for this interface in Register Context NetBSD x86_64 unconditionally as older versions of NetBSD will not be supported.

This change allows to reduce diff with other ports and remove local copy of the RegisterInfos_x86_64.h content.

NetBSD Register Context for 32-bit x86 support will be added later.

Sponsored by <The NetBSD Foundation>

Diff Detail

Repository
rL LLVM

Event Timeline

krytarowski created this revision.Feb 23 2017, 12:38 AM
krytarowski retitled this revision from Introduce support for Debug Registers RegisterContextNetBSD_x86_64 to Introduce support for Debug Registers in RegisterContextNetBSD_x86_64.Feb 23 2017, 12:55 AM
labath accepted this revision.Feb 23 2017, 2:10 AM

Good stuff, just remove the unused function.

source/Plugins/Process/Utility/RegisterContextNetBSD_x86_64.cpp
89

It looks like you copied this from freebsd code, but it does not appear to be used. Can this function be removed?

This revision is now accepted and ready to land.Feb 23 2017, 2:10 AM
clayborg added inline comments.Feb 23 2017, 11:50 AM
source/Plugins/Process/Utility/RegisterContextNetBSD_x86_64.cpp
51–56

Would it be nicer to have a union in here? Something like:

struct DebugRegs
{
  uint64_t debug_addr1;
  uint64_t debug_addr2;
  uint64_t debug_addr3;
  uint64_t reserved1;
  uint64_t reserved2;
  uint64_t debug_status;
  uint64_t debug_control;
};
struct DBG {
  union {
    uint64_t dr[16];
    DebugRegs regs;
  };
};
krytarowski added inline comments.Feb 23 2017, 2:00 PM
source/Plugins/Process/Utility/RegisterContextNetBSD_x86_64.cpp
51–56

I prefer to Follow Linux and FreeBSD here. I don't see similar union in other ports.

79–80

I checked Linux code and perhaps this define should look this way:

#define DR_OFFSET(reg_index)                                                   \
  (LLVM_EXTENSION offsetof(UserArea, dbg) +                                    \
LLVM_EXTENSION offsetof(DBG, dr[reg_index]))
clayborg accepted this revision.Feb 23 2017, 2:08 PM

That is fine, just wanted to check.

krytarowski updated this revision to Diff 89589.Feb 23 2017, 4:47 PM
  • remove unused function GetSharedRegisterInfoVector
  • fix DR_OFFSET
krytarowski closed this revision.Feb 23 2017, 6:05 PM

Revision Contents

PathSize
source/
Plugins/
Process/
Utility/
285 lines

Diff 89589

source/Plugins/Process/Utility/RegisterContextNetBSD_x86_64.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linestypedef struct _GPR {
uint64_t err; /* 20 */ uint64_t err; /* 20 */
uint64_t rip; /* 21 */ uint64_t rip; /* 21 */
uint64_t cs; /* 22 */ uint64_t cs; /* 22 */
uint64_t rflags; /* 23 */ uint64_t rflags; /* 23 */
uint64_t rsp; /* 24 */ uint64_t rsp; /* 24 */
uint64_t ss; /* 25 */ uint64_t ss; /* 25 */
} GPR; } GPR;
/* struct DBG {
* As of NetBSD-7.99.25 there is no support for debug registers uint64_t dr[16]; /* debug registers */
* https://en.wikipedia.org/wiki/X86_debug_register /* Index 0-3: debug address registers */
*/ /* Index 4-5: reserved */
/* Index 6: debug status */
/* Index 7: debug control */
/* Index 8-15: reserved */
clayborgUnsubmitted
Not Done
ReplyInline Actions

Would it be nicer to have a union in here? Something like:

struct DebugRegs
{
  uint64_t debug_addr1;
  uint64_t debug_addr2;
  uint64_t debug_addr3;
  uint64_t reserved1;
  uint64_t reserved2;
  uint64_t debug_status;
  uint64_t debug_control;
};
struct DBG {
  union {
    uint64_t dr[16];
    DebugRegs regs;
  };
};
clayborg: Would it be nicer to have a union in here? Something like: ``` struct DebugRegs { uint64_t…
krytarowskiAuthorUnsubmitted
Not Done
ReplyInline Actions

I prefer to Follow Linux and FreeBSD here. I don't see similar union in other ports.

krytarowski: I prefer to Follow Linux and FreeBSD here. I don't see similar union in other ports.
};
/* /*
* src/sys/arch/amd64/include/mcontext.h * src/sys/arch/amd64/include/mcontext.h
* *
* typedef struct { * typedef struct {
* __gregset_t __gregs; * __gregset_t __gregs;
* __greg_t _mc_tlsbase; * __greg_t _mc_tlsbase;
* __fpregset_t __fpregs; * __fpregset_t __fpregs;
* } mcontext_t; * } mcontext_t;
*/ */
struct UserArea { struct UserArea {
GPR gpr; GPR gpr;
uint64_t mc_tlsbase; uint64_t mc_tlsbase;
FPR fpr; FPR fpr;
DBG dbg;
}; };
//--------------------------------------------------------------------------- #define DR_OFFSET(reg_index) \
// Cherry-pick parts of RegisterInfos_x86_64.h, without debug registers (LLVM_EXTENSION offsetof(UserArea, dbg) + \
//--------------------------------------------------------------------------- LLVM_EXTENSION offsetof(DBG, dr[reg_index]))
// Computes the offset of the given GPR in the user data area.
#define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
// Computes the offset of the given FPR in the extended data area.
#define FPR_OFFSET(regname) \
(LLVM_EXTENSION offsetof(UserArea, fpr) + \
LLVM_EXTENSION offsetof(FPR, xstate) + \
LLVM_EXTENSION offsetof(FXSAVE, regname))
// Computes the offset of the YMM register assembled from register halves.
// Based on DNBArchImplX86_64.cpp from debugserver
#define YMM_OFFSET(reg_index) \
(LLVM_EXTENSION offsetof(UserArea, fpr) + \
LLVM_EXTENSION offsetof(FPR, xstate) + \
LLVM_EXTENSION offsetof(XSAVE, ymmh[0]) + (32 * reg_index))
// Number of bytes needed to represent a FPR.
#define FPR_SIZE(reg) sizeof(((FXSAVE *)nullptr)->reg)
// Number of bytes needed to represent the i'th FP register.
#define FP_SIZE sizeof(((MMSReg *)nullptr)->bytes)
// Number of bytes needed to represent an XMM register.
#define XMM_SIZE sizeof(XMMReg)
// Number of bytes needed to represent a YMM register.
#define YMM_SIZE sizeof(YMMReg)
// RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
// Note that the size and offset will be updated by platform-specific classes.
#define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \
{ \
#reg, alt, sizeof(((GPR *)nullptr)->reg), \
GPR_OFFSET(reg), eEncodingUint, eFormatHex, \
{kind1, kind2, kind3, kind4, \
lldb_##reg##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4) \
{ \
#name, nullptr, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, eFormatHex, \
{kind1, kind2, kind3, kind4, \
lldb_##name##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_FP_ST(reg, i) \
{ \
#reg #i, nullptr, FP_SIZE, \
LLVM_EXTENSION FPR_OFFSET( \
stmm[i]), eEncodingVector, eFormatVectorOfUInt8, \
{dwarf_st##i##_x86_64, dwarf_st##i##_x86_64, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, lldb_st##i##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_FP_MM(reg, i) \
{ \
#reg #i, nullptr, sizeof(uint64_t), \
LLVM_EXTENSION FPR_OFFSET( \
stmm[i]), eEncodingUint, eFormatHex, \
{dwarf_mm##i##_x86_64, dwarf_mm##i##_x86_64, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_mm##i##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_XMM(reg, i) \
{ \
#reg #i, nullptr, XMM_SIZE, \
LLVM_EXTENSION FPR_OFFSET( \
reg[i]), eEncodingVector, eFormatVectorOfUInt8, \
{dwarf_##reg##i##_x86_64, dwarf_##reg##i##_x86_64, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg##i##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_YMM(reg, i) \
{ \
#reg #i, nullptr, YMM_SIZE, \
LLVM_EXTENSION YMM_OFFSET(i), eEncodingVector, eFormatVectorOfUInt8, \
{dwarf_##reg##i##h_x86_64, \
dwarf_##reg##i##h_x86_64, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg##i##_x86_64 }, \
nullptr, nullptr, nullptr, 0 \
}
#define DEFINE_GPR_PSEUDO_32(reg32, reg64) \
{ \
#reg32, nullptr, 4, \
GPR_OFFSET(reg64), eEncodingUint, eFormatHex, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg32##_x86_64 }, \
RegisterContextPOSIX_x86::g_contained_##reg64, \
RegisterContextPOSIX_x86::g_invalidate_##reg64, nullptr, 0 \
}
#define DEFINE_GPR_PSEUDO_16(reg16, reg64) \
{ \
#reg16, nullptr, 2, \
GPR_OFFSET(reg64), eEncodingUint, eFormatHex, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg16##_x86_64 }, \
RegisterContextPOSIX_x86::g_contained_##reg64, \
RegisterContextPOSIX_x86::g_invalidate_##reg64, nullptr, 0 \
}
#define DEFINE_GPR_PSEUDO_8H(reg8, reg64) \
{ \
#reg8, nullptr, 1, GPR_OFFSET(reg64) + 1, eEncodingUint, eFormatHex, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg8##_x86_64 }, \
RegisterContextPOSIX_x86::g_contained_##reg64, \
RegisterContextPOSIX_x86::g_invalidate_##reg64,\
nullptr, 0 \
}
#define DEFINE_GPR_PSEUDO_8L(reg8, reg64) \
{ \
#reg8, nullptr, 1, GPR_OFFSET(reg64), eEncodingUint, eFormatHex, \
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \
lldb_##reg8##_x86_64 }, \
RegisterContextPOSIX_x86::g_contained_##reg64, \
RegisterContextPOSIX_x86::g_invalidate_##reg64,\
nullptr, 0 \
}
static RegisterInfo g_register_infos_x86_64[] = {
// General purpose registers. EH_Frame, DWARF,
// Generic, Process Plugin
DEFINE_GPR(rax, nullptr, dwarf_rax_x86_64, dwarf_rax_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(rbx, nullptr, dwarf_rbx_x86_64, dwarf_rbx_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(rcx, "arg4", dwarf_rcx_x86_64, dwarf_rcx_x86_64,
LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM),
DEFINE_GPR(rdx, "arg3", dwarf_rdx_x86_64, dwarf_rdx_x86_64,
LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM),
DEFINE_GPR(rdi, "arg1", dwarf_rdi_x86_64, dwarf_rdi_x86_64,
LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM),
DEFINE_GPR(rsi, "arg2", dwarf_rsi_x86_64, dwarf_rsi_x86_64,
LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM),
DEFINE_GPR(rbp, "fp", dwarf_rbp_x86_64, dwarf_rbp_x86_64,
LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM),
DEFINE_GPR(rsp, "sp", dwarf_rsp_x86_64, dwarf_rsp_x86_64,
LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM),
DEFINE_GPR(r8, "arg5", dwarf_r8_x86_64, dwarf_r8_x86_64,
LLDB_REGNUM_GENERIC_ARG5, LLDB_INVALID_REGNUM),
DEFINE_GPR(r9, "arg6", dwarf_r9_x86_64, dwarf_r9_x86_64,
LLDB_REGNUM_GENERIC_ARG6, LLDB_INVALID_REGNUM),
DEFINE_GPR(r10, nullptr, dwarf_r10_x86_64, dwarf_r10_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(r11, nullptr, dwarf_r11_x86_64, dwarf_r11_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(r12, nullptr, dwarf_r12_x86_64, dwarf_r12_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(r13, nullptr, dwarf_r13_x86_64, dwarf_r13_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(r14, nullptr, dwarf_r14_x86_64, dwarf_r14_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(r15, nullptr, dwarf_r15_x86_64, dwarf_r15_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(rip, "pc", dwarf_rip_x86_64, dwarf_rip_x86_64,
LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
DEFINE_GPR(rflags, "flags", dwarf_rflags_x86_64, dwarf_rflags_x86_64,
LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM),
DEFINE_GPR(cs, nullptr, dwarf_cs_x86_64, dwarf_cs_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(fs, nullptr, dwarf_fs_x86_64, dwarf_fs_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(gs, nullptr, dwarf_gs_x86_64, dwarf_gs_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(ss, nullptr, dwarf_ss_x86_64, dwarf_ss_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(ds, nullptr, dwarf_ds_x86_64, dwarf_ds_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR(es, nullptr, dwarf_es_x86_64, dwarf_es_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_GPR_PSEUDO_32(eax, rax), DEFINE_GPR_PSEUDO_32(ebx, rbx),
DEFINE_GPR_PSEUDO_32(ecx, rcx), DEFINE_GPR_PSEUDO_32(edx, rdx),
DEFINE_GPR_PSEUDO_32(edi, rdi), DEFINE_GPR_PSEUDO_32(esi, rsi),
DEFINE_GPR_PSEUDO_32(ebp, rbp), DEFINE_GPR_PSEUDO_32(esp, rsp),
DEFINE_GPR_PSEUDO_32(r8d, r8), DEFINE_GPR_PSEUDO_32(r9d, r9),
DEFINE_GPR_PSEUDO_32(r10d, r10), DEFINE_GPR_PSEUDO_32(r11d, r11),
DEFINE_GPR_PSEUDO_32(r12d, r12), DEFINE_GPR_PSEUDO_32(r13d, r13),
DEFINE_GPR_PSEUDO_32(r14d, r14), DEFINE_GPR_PSEUDO_32(r15d, r15),
DEFINE_GPR_PSEUDO_16(ax, rax), DEFINE_GPR_PSEUDO_16(bx, rbx),
DEFINE_GPR_PSEUDO_16(cx, rcx), DEFINE_GPR_PSEUDO_16(dx, rdx),
DEFINE_GPR_PSEUDO_16(di, rdi), DEFINE_GPR_PSEUDO_16(si, rsi),
DEFINE_GPR_PSEUDO_16(bp, rbp), DEFINE_GPR_PSEUDO_16(sp, rsp),
DEFINE_GPR_PSEUDO_16(r8w, r8), DEFINE_GPR_PSEUDO_16(r9w, r9),
DEFINE_GPR_PSEUDO_16(r10w, r10), DEFINE_GPR_PSEUDO_16(r11w, r11),
DEFINE_GPR_PSEUDO_16(r12w, r12), DEFINE_GPR_PSEUDO_16(r13w, r13),
DEFINE_GPR_PSEUDO_16(r14w, r14), DEFINE_GPR_PSEUDO_16(r15w, r15),
DEFINE_GPR_PSEUDO_8H(ah, rax), DEFINE_GPR_PSEUDO_8H(bh, rbx),
DEFINE_GPR_PSEUDO_8H(ch, rcx), DEFINE_GPR_PSEUDO_8H(dh, rdx),
DEFINE_GPR_PSEUDO_8L(al, rax), DEFINE_GPR_PSEUDO_8L(bl, rbx),
DEFINE_GPR_PSEUDO_8L(cl, rcx), DEFINE_GPR_PSEUDO_8L(dl, rdx),
DEFINE_GPR_PSEUDO_8L(dil, rdi), DEFINE_GPR_PSEUDO_8L(sil, rsi),
DEFINE_GPR_PSEUDO_8L(bpl, rbp), DEFINE_GPR_PSEUDO_8L(spl, rsp),
DEFINE_GPR_PSEUDO_8L(r8l, r8), DEFINE_GPR_PSEUDO_8L(r9l, r9),
DEFINE_GPR_PSEUDO_8L(r10l, r10), DEFINE_GPR_PSEUDO_8L(r11l, r11),
DEFINE_GPR_PSEUDO_8L(r12l, r12), DEFINE_GPR_PSEUDO_8L(r13l, r13),
DEFINE_GPR_PSEUDO_8L(r14l, r14), DEFINE_GPR_PSEUDO_8L(r15l, r15),
// i387 Floating point registers. EH_frame,
// DWARF, Generic, Process Plugin
DEFINE_FPR(fctrl, fctrl, dwarf_fctrl_x86_64, dwarf_fctrl_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(fstat, fstat, dwarf_fstat_x86_64, dwarf_fstat_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(ftag, ftag, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(fop, fop, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(fiseg, ptr.i386_.fiseg, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(fioff, ptr.i386_.fioff, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(foseg, ptr.i386_.foseg, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(fooff, ptr.i386_.fooff, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(mxcsr, mxcsr, dwarf_mxcsr_x86_64, dwarf_mxcsr_x86_64,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
DEFINE_FPR(mxcsrmask, mxcsrmask, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
// FP registers.
DEFINE_FP_ST(st, 0), DEFINE_FP_ST(st, 1), DEFINE_FP_ST(st, 2),
DEFINE_FP_ST(st, 3), DEFINE_FP_ST(st, 4), DEFINE_FP_ST(st, 5),
DEFINE_FP_ST(st, 6), DEFINE_FP_ST(st, 7), DEFINE_FP_MM(mm, 0),
DEFINE_FP_MM(mm, 1), DEFINE_FP_MM(mm, 2), DEFINE_FP_MM(mm, 3),
DEFINE_FP_MM(mm, 4), DEFINE_FP_MM(mm, 5), DEFINE_FP_MM(mm, 6),
DEFINE_FP_MM(mm, 7),
// XMM registers
DEFINE_XMM(xmm, 0), DEFINE_XMM(xmm, 1), DEFINE_XMM(xmm, 2),
DEFINE_XMM(xmm, 3), DEFINE_XMM(xmm, 4), DEFINE_XMM(xmm, 5),
DEFINE_XMM(xmm, 6), DEFINE_XMM(xmm, 7), DEFINE_XMM(xmm, 8),
DEFINE_XMM(xmm, 9), DEFINE_XMM(xmm, 10), DEFINE_XMM(xmm, 11),
DEFINE_XMM(xmm, 12), DEFINE_XMM(xmm, 13), DEFINE_XMM(xmm, 14),
DEFINE_XMM(xmm, 15),
// Copy of YMM registers assembled from xmm and ymmh
DEFINE_YMM(ymm, 0), DEFINE_YMM(ymm, 1), DEFINE_YMM(ymm, 2),
DEFINE_YMM(ymm, 3), DEFINE_YMM(ymm, 4), DEFINE_YMM(ymm, 5),
DEFINE_YMM(ymm, 6), DEFINE_YMM(ymm, 7), DEFINE_YMM(ymm, 8),
DEFINE_YMM(ymm, 9), DEFINE_YMM(ymm, 10), DEFINE_YMM(ymm, 11),
DEFINE_YMM(ymm, 12), DEFINE_YMM(ymm, 13), DEFINE_YMM(ymm, 14),
DEFINE_YMM(ymm, 15),
};
krytarowskiAuthorUnsubmitted
Not Done
ReplyInline Actions

I checked Linux code and perhaps this define should look this way:

#define DR_OFFSET(reg_index)                                                   \
  (LLVM_EXTENSION offsetof(UserArea, dbg) +                                    \
LLVM_EXTENSION offsetof(DBG, dr[reg_index]))
krytarowski: I checked Linux code and perhaps this define should look this way: ``` #define DR_OFFSET…
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// End of cherry-pick of RegisterInfos_x86_64.h // Include RegisterInfos_x86_64 to declare our g_register_infos_x86_64
// structure.
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#define DECLARE_REGISTER_INFOS_X86_64_STRUCT
#include "RegisterInfos_x86_64.h"
#undef DECLARE_REGISTER_INFOS_X86_64_STRUCT
static const RegisterInfo * static const RegisterInfo *
labathUnsubmitted
Not Done
ReplyInline Actions

It looks like you copied this from freebsd code, but it does not appear to be used. Can this function be removed?

labath: It looks like you copied this from freebsd code, but it does not appear to be used. Can this…
PrivateGetRegisterInfoPtr(const lldb_private::ArchSpec &target_arch) { PrivateGetRegisterInfoPtr(const lldb_private::ArchSpec &target_arch) {
switch (target_arch.GetMachine()) { switch (target_arch.GetMachine()) {
case llvm::Triple::x86_64: case llvm::Triple::x86_64:
return g_register_infos_x86_64; return g_register_infos_x86_64;
default: default:
assert(false && "Unhandled target architecture."); assert(false && "Unhandled target architecture.");
return nullptr; return nullptr;
} }
Show All 29 Lines