contrib/llvm/tools/lldb/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp

   1 //===-- NativeRegisterContextNetBSD_x86_64.cpp ---------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #if defined(__x86_64__)
  11
  12 #include "NativeRegisterContextNetBSD_x86_64.h"
  13
  14 #include "lldb/Host/HostInfo.h"
  15 #include "lldb/Utility/DataBufferHeap.h"
  16 #include "lldb/Utility/Log.h"
  17 #include "lldb/Utility/RegisterValue.h"
  18 #include "lldb/Utility/Status.h"
  19
  20 #include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h"
  21
  22 // clang-format off
  23 #include <sys/types.h>
  24 #include <sys/sysctl.h>
  25 #include <x86/cpu.h>
  26 #include <elf.h>
  27 #include <err.h>
  28 #include <stdint.h>
  29 #include <stdlib.h>
  30 // clang-format on
  31
  32 using namespace lldb_private;
  33 using namespace lldb_private::process_netbsd;
  34
  35 // ----------------------------------------------------------------------------
  36 // Private namespace.
  37 // ----------------------------------------------------------------------------
  38
  39 namespace {
  40 // x86 64-bit general purpose registers.
  41 static const uint32_t g_gpr_regnums_x86_64[] = {
  42     lldb_rax_x86_64,    lldb_rbx_x86_64,    lldb_rcx_x86_64, lldb_rdx_x86_64,
  43     lldb_rdi_x86_64,    lldb_rsi_x86_64,    lldb_rbp_x86_64, lldb_rsp_x86_64,
  44     lldb_r8_x86_64,     lldb_r9_x86_64,     lldb_r10_x86_64, lldb_r11_x86_64,
  45     lldb_r12_x86_64,    lldb_r13_x86_64,    lldb_r14_x86_64, lldb_r15_x86_64,
  46     lldb_rip_x86_64,    lldb_rflags_x86_64, lldb_cs_x86_64,  lldb_fs_x86_64,
  47     lldb_gs_x86_64,     lldb_ss_x86_64,     lldb_ds_x86_64,  lldb_es_x86_64,
  48     lldb_eax_x86_64,    lldb_ebx_x86_64,    lldb_ecx_x86_64, lldb_edx_x86_64,
  49     lldb_edi_x86_64,    lldb_esi_x86_64,    lldb_ebp_x86_64, lldb_esp_x86_64,
  50     lldb_r8d_x86_64,  // Low 32 bits or r8
  51     lldb_r9d_x86_64,  // Low 32 bits or r9
  52     lldb_r10d_x86_64, // Low 32 bits or r10
  53     lldb_r11d_x86_64, // Low 32 bits or r11
  54     lldb_r12d_x86_64, // Low 32 bits or r12
  55     lldb_r13d_x86_64, // Low 32 bits or r13
  56     lldb_r14d_x86_64, // Low 32 bits or r14
  57     lldb_r15d_x86_64, // Low 32 bits or r15
  58     lldb_ax_x86_64,     lldb_bx_x86_64,     lldb_cx_x86_64,  lldb_dx_x86_64,
  59     lldb_di_x86_64,     lldb_si_x86_64,     lldb_bp_x86_64,  lldb_sp_x86_64,
  60     lldb_r8w_x86_64,  // Low 16 bits or r8
  61     lldb_r9w_x86_64,  // Low 16 bits or r9
  62     lldb_r10w_x86_64, // Low 16 bits or r10
  63     lldb_r11w_x86_64, // Low 16 bits or r11
  64     lldb_r12w_x86_64, // Low 16 bits or r12
  65     lldb_r13w_x86_64, // Low 16 bits or r13
  66     lldb_r14w_x86_64, // Low 16 bits or r14
  67     lldb_r15w_x86_64, // Low 16 bits or r15
  68     lldb_ah_x86_64,     lldb_bh_x86_64,     lldb_ch_x86_64,  lldb_dh_x86_64,
  69     lldb_al_x86_64,     lldb_bl_x86_64,     lldb_cl_x86_64,  lldb_dl_x86_64,
  70     lldb_dil_x86_64,    lldb_sil_x86_64,    lldb_bpl_x86_64, lldb_spl_x86_64,
  71     lldb_r8l_x86_64,    // Low 8 bits or r8
  72     lldb_r9l_x86_64,    // Low 8 bits or r9
  73     lldb_r10l_x86_64,   // Low 8 bits or r10
  74     lldb_r11l_x86_64,   // Low 8 bits or r11
  75     lldb_r12l_x86_64,   // Low 8 bits or r12
  76     lldb_r13l_x86_64,   // Low 8 bits or r13
  77     lldb_r14l_x86_64,   // Low 8 bits or r14
  78     lldb_r15l_x86_64,   // Low 8 bits or r15
  79     LLDB_INVALID_REGNUM // register sets need to end with this flag
  80 };
  81 static_assert((sizeof(g_gpr_regnums_x86_64) / sizeof(g_gpr_regnums_x86_64[0])) -
  82                       1 ==
  83                   k_num_gpr_registers_x86_64,
  84               "g_gpr_regnums_x86_64 has wrong number of register infos");
  85
  86 // Number of register sets provided by this context.
  87 enum { k_num_extended_register_sets = 2, k_num_register_sets = 4 };
  88
  89 // Register sets for x86 64-bit.
  90 static const RegisterSet g_reg_sets_x86_64[k_num_register_sets] = {
  91     {"General Purpose Registers", "gpr", k_num_gpr_registers_x86_64,
  92      g_gpr_regnums_x86_64},
  93 };
  94
  95 #define REG_CONTEXT_SIZE (GetRegisterInfoInterface().GetGPRSize())
  96
  97 const int fpu_present = []() -> int {
  98   int mib[2];
  99   int error;
 100   size_t len;
 101   int val;
 102
 103   len = sizeof(val);
 104   mib[0] = CTL_MACHDEP;
 105   mib[1] = CPU_FPU_PRESENT;
 106
 107   error = sysctl(mib, __arraycount(mib), &val, &len, NULL, 0);
 108   if (error)
 109     errx(EXIT_FAILURE, "sysctl");
 110
 111   return val;
 112 }();
 113
 114 const int osfxsr = []() -> int {
 115   int mib[2];
 116   int error;
 117   size_t len;
 118   int val;
 119
 120   len = sizeof(val);
 121   mib[0] = CTL_MACHDEP;
 122   mib[1] = CPU_OSFXSR;
 123
 124   error = sysctl(mib, __arraycount(mib), &val, &len, NULL, 0);
 125   if (error)
 126     errx(EXIT_FAILURE, "sysctl");
 127
 128   return val;
 129 }();
 130
 131 const int fpu_save = []() -> int {
 132   int mib[2];
 133   int error;
 134   size_t len;
 135   int val;
 136
 137   len = sizeof(val);
 138   mib[0] = CTL_MACHDEP;
 139   mib[1] = CPU_FPU_SAVE;
 140
 141   error = sysctl(mib, __arraycount(mib), &val, &len, NULL, 0);
 142   if (error)
 143     errx(EXIT_FAILURE, "sysctl");
 144
 145   return val;
 146 }();
 147
 148 } // namespace
 149
 150 NativeRegisterContextNetBSD *
 151 NativeRegisterContextNetBSD::CreateHostNativeRegisterContextNetBSD(
 152     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
 153   return new NativeRegisterContextNetBSD_x86_64(target_arch, native_thread);
 154 }
 155
 156 // ----------------------------------------------------------------------------
 157 // NativeRegisterContextNetBSD_x86_64 members.
 158 // ----------------------------------------------------------------------------
 159
 160 static RegisterInfoInterface *
 161 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
 162   assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
 163          "Register setting path assumes this is a 64-bit host");
 164   // X86_64 hosts know how to work with 64-bit and 32-bit EXEs using the x86_64
 165   // register context.
 166   return new RegisterContextNetBSD_x86_64(target_arch);
 167 }
 168
 169 NativeRegisterContextNetBSD_x86_64::NativeRegisterContextNetBSD_x86_64(
 170     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
 171     : NativeRegisterContextNetBSD(native_thread,
 172                                   CreateRegisterInfoInterface(target_arch)),
 173       m_gpr_x86_64(), m_fpr_x86_64(), m_dbr_x86_64() {}
 174
 175 // CONSIDER after local and llgs debugging are merged, register set support can
 176 // be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
 177 uint32_t NativeRegisterContextNetBSD_x86_64::GetRegisterSetCount() const {
 178   uint32_t sets = 0;
 179   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {
 180     if (GetSetForNativeRegNum(set_index) != -1)
 181       ++sets;
 182   }
 183
 184   return sets;
 185 }
 186
 187 const RegisterSet *
 188 NativeRegisterContextNetBSD_x86_64::GetRegisterSet(uint32_t set_index) const {
 189   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
 190   case llvm::Triple::x86_64:
 191     return &g_reg_sets_x86_64[set_index];
 192   default:
 193     assert(false && "Unhandled target architecture.");
 194     return nullptr;
 195   }
 196
 197   return nullptr;
 198 }
 199
 200 int NativeRegisterContextNetBSD_x86_64::GetSetForNativeRegNum(
 201     int reg_num) const {
 202   if (reg_num <= k_last_gpr_x86_64)
 203     return GPRegSet;
 204   else if (reg_num <= k_last_fpr_x86_64)
 205     return (fpu_present == 1 && osfxsr == 1 && fpu_save >= 1) ? FPRegSet : -1;
 206   else if (reg_num <= k_last_avx_x86_64)
 207     return -1; // AVX
 208   else if (reg_num <= k_last_mpxr_x86_64)
 209     return -1; // MPXR
 210   else if (reg_num <= k_last_mpxc_x86_64)
 211     return -1; // MPXC
 212   else if (reg_num <= lldb_dr7_x86_64)
 213     return DBRegSet; // DBR
 214   else
 215     return -1;
 216 }
 217
 218 int NativeRegisterContextNetBSD_x86_64::ReadRegisterSet(uint32_t set) {
 219   switch (set) {
 220   case GPRegSet:
 221     ReadGPR();
 222     return 0;
 223   case FPRegSet:
 224     ReadFPR();
 225     return 0;
 226   case DBRegSet:
 227     ReadDBR();
 228     return 0;
 229   default:
 230     break;
 231   }
 232   return -1;
 233 }
 234 int NativeRegisterContextNetBSD_x86_64::WriteRegisterSet(uint32_t set) {
 235   switch (set) {
 236   case GPRegSet:
 237     WriteGPR();
 238     return 0;
 239   case FPRegSet:
 240     WriteFPR();
 241     return 0;
 242   case DBRegSet:
 243     WriteDBR();
 244     return 0;
 245   default:
 246     break;
 247   }
 248   return -1;
 249 }
 250
 251 Status
 252 NativeRegisterContextNetBSD_x86_64::ReadRegister(const RegisterInfo *reg_info,
 253                                                  RegisterValue &reg_value) {
 254   Status error;
 255
 256   if (!reg_info) {
 257     error.SetErrorString("reg_info NULL");
 258     return error;
 259   }
 260
 261   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 262   if (reg == LLDB_INVALID_REGNUM) {
 263     // This is likely an internal register for lldb use only and should not be
 264     // directly queried.
 265     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
 266                                    "register, cannot read directly",
 267                                    reg_info->name);
 268     return error;
 269   }
 270
 271   int set = GetSetForNativeRegNum(reg);
 272   if (set == -1) {
 273     // This is likely an internal register for lldb use only and should not be
 274     // directly queried.
 275     error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
 276                                    reg_info->name);
 277     return error;
 278   }
 279
 280   if (ReadRegisterSet(set) != 0) {
 281     // This is likely an internal register for lldb use only and should not be
 282     // directly queried.
 283     error.SetErrorStringWithFormat(
 284         "reading register set for register \"%s\" failed", reg_info->name);
 285     return error;
 286   }
 287
 288   switch (reg) {
 289   case lldb_rax_x86_64:
 290     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RAX];
 291     break;
 292   case lldb_rbx_x86_64:
 293     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RBX];
 294     break;
 295   case lldb_rcx_x86_64:
 296     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RCX];
 297     break;
 298   case lldb_rdx_x86_64:
 299     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RDX];
 300     break;
 301   case lldb_rdi_x86_64:
 302     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RDI];
 303     break;
 304   case lldb_rsi_x86_64:
 305     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RSI];
 306     break;
 307   case lldb_rbp_x86_64:
 308     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RBP];
 309     break;
 310   case lldb_rsp_x86_64:
 311     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RSP];
 312     break;
 313   case lldb_r8_x86_64:
 314     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R8];
 315     break;
 316   case lldb_r9_x86_64:
 317     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R9];
 318     break;
 319   case lldb_r10_x86_64:
 320     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R10];
 321     break;
 322   case lldb_r11_x86_64:
 323     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R11];
 324     break;
 325   case lldb_r12_x86_64:
 326     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R12];
 327     break;
 328   case lldb_r13_x86_64:
 329     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R13];
 330     break;
 331   case lldb_r14_x86_64:
 332     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R14];
 333     break;
 334   case lldb_r15_x86_64:
 335     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_R15];
 336     break;
 337   case lldb_rip_x86_64:
 338     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RIP];
 339     break;
 340   case lldb_rflags_x86_64:
 341     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_RFLAGS];
 342     break;
 343   case lldb_cs_x86_64:
 344     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_CS];
 345     break;
 346   case lldb_fs_x86_64:
 347     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_FS];
 348     break;
 349   case lldb_gs_x86_64:
 350     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_GS];
 351     break;
 352   case lldb_ss_x86_64:
 353     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_SS];
 354     break;
 355   case lldb_ds_x86_64:
 356     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_DS];
 357     break;
 358   case lldb_es_x86_64:
 359     reg_value = (uint64_t)m_gpr_x86_64.regs[_REG_ES];
 360     break;
 361   case lldb_fctrl_x86_64:
 362     reg_value = (uint16_t)m_fpr_x86_64.fxstate.fx_cw;
 363     break;
 364   case lldb_fstat_x86_64:
 365     reg_value = (uint16_t)m_fpr_x86_64.fxstate.fx_sw;
 366     break;
 367   case lldb_ftag_x86_64:
 368     reg_value = (uint8_t)m_fpr_x86_64.fxstate.fx_tw;
 369     break;
 370   case lldb_fop_x86_64:
 371     reg_value = (uint64_t)m_fpr_x86_64.fxstate.fx_opcode;
 372     break;
 373   case lldb_fiseg_x86_64:
 374     reg_value = (uint64_t)m_fpr_x86_64.fxstate.fx_ip.fa_64;
 375     break;
 376   case lldb_fioff_x86_64:
 377     reg_value = (uint32_t)m_fpr_x86_64.fxstate.fx_ip.fa_32.fa_off;
 378     break;
 379   case lldb_foseg_x86_64:
 380     reg_value = (uint64_t)m_fpr_x86_64.fxstate.fx_dp.fa_64;
 381     break;
 382   case lldb_fooff_x86_64:
 383     reg_value = (uint32_t)m_fpr_x86_64.fxstate.fx_dp.fa_32.fa_off;
 384     break;
 385   case lldb_mxcsr_x86_64:
 386     reg_value = (uint32_t)m_fpr_x86_64.fxstate.fx_mxcsr;
 387     break;
 388   case lldb_mxcsrmask_x86_64:
 389     reg_value = (uint32_t)m_fpr_x86_64.fxstate.fx_mxcsr_mask;
 390     break;
 391   case lldb_st0_x86_64:
 392   case lldb_st1_x86_64:
 393   case lldb_st2_x86_64:
 394   case lldb_st3_x86_64:
 395   case lldb_st4_x86_64:
 396   case lldb_st5_x86_64:
 397   case lldb_st6_x86_64:
 398   case lldb_st7_x86_64:
 399     reg_value.SetBytes(&m_fpr_x86_64.fxstate.fx_87_ac[reg - lldb_st0_x86_64],
 400                        reg_info->byte_size, endian::InlHostByteOrder());
 401     break;
 402   case lldb_mm0_x86_64:
 403   case lldb_mm1_x86_64:
 404   case lldb_mm2_x86_64:
 405   case lldb_mm3_x86_64:
 406   case lldb_mm4_x86_64:
 407   case lldb_mm5_x86_64:
 408   case lldb_mm6_x86_64:
 409   case lldb_mm7_x86_64:
 410     reg_value.SetBytes(&m_fpr_x86_64.fxstate.fx_xmm[reg - lldb_mm0_x86_64],
 411                        reg_info->byte_size, endian::InlHostByteOrder());
 412     break;
 413   case lldb_xmm0_x86_64:
 414   case lldb_xmm1_x86_64:
 415   case lldb_xmm2_x86_64:
 416   case lldb_xmm3_x86_64:
 417   case lldb_xmm4_x86_64:
 418   case lldb_xmm5_x86_64:
 419   case lldb_xmm6_x86_64:
 420   case lldb_xmm7_x86_64:
 421   case lldb_xmm8_x86_64:
 422   case lldb_xmm9_x86_64:
 423   case lldb_xmm10_x86_64:
 424   case lldb_xmm11_x86_64:
 425   case lldb_xmm12_x86_64:
 426   case lldb_xmm13_x86_64:
 427   case lldb_xmm14_x86_64:
 428   case lldb_xmm15_x86_64:
 429     reg_value.SetBytes(&m_fpr_x86_64.fxstate.fx_xmm[reg - lldb_xmm0_x86_64],
 430                        reg_info->byte_size, endian::InlHostByteOrder());
 431     break;
 432   case lldb_dr0_x86_64:
 433   case lldb_dr1_x86_64:
 434   case lldb_dr2_x86_64:
 435   case lldb_dr3_x86_64:
 436   case lldb_dr4_x86_64:
 437   case lldb_dr5_x86_64:
 438   case lldb_dr6_x86_64:
 439   case lldb_dr7_x86_64:
 440     reg_value = (uint64_t)m_dbr_x86_64.dr[reg - lldb_dr0_x86_64];
 441     break;
 442   }
 443
 444   return error;
 445 }
 446
 447 Status NativeRegisterContextNetBSD_x86_64::WriteRegister(
 448     const RegisterInfo *reg_info, const RegisterValue &reg_value) {
 449
 450   Status error;
 451
 452   if (!reg_info) {
 453     error.SetErrorString("reg_info NULL");
 454     return error;
 455   }
 456
 457   const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
 458   if (reg == LLDB_INVALID_REGNUM) {
 459     // This is likely an internal register for lldb use only and should not be
 460     // directly queried.
 461     error.SetErrorStringWithFormat("register \"%s\" is an internal-only lldb "
 462                                    "register, cannot read directly",
 463                                    reg_info->name);
 464     return error;
 465   }
 466
 467   int set = GetSetForNativeRegNum(reg);
 468   if (set == -1) {
 469     // This is likely an internal register for lldb use only and should not be
 470     // directly queried.
 471     error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
 472                                    reg_info->name);
 473     return error;
 474   }
 475
 476   if (ReadRegisterSet(set) != 0) {
 477     // This is likely an internal register for lldb use only and should not be
 478     // directly queried.
 479     error.SetErrorStringWithFormat(
 480         "reading register set for register \"%s\" failed", reg_info->name);
 481     return error;
 482   }
 483
 484   switch (reg) {
 485   case lldb_rax_x86_64:
 486     m_gpr_x86_64.regs[_REG_RAX] = reg_value.GetAsUInt64();
 487     break;
 488   case lldb_rbx_x86_64:
 489     m_gpr_x86_64.regs[_REG_RBX] = reg_value.GetAsUInt64();
 490     break;
 491   case lldb_rcx_x86_64:
 492     m_gpr_x86_64.regs[_REG_RCX] = reg_value.GetAsUInt64();
 493     break;
 494   case lldb_rdx_x86_64:
 495     m_gpr_x86_64.regs[_REG_RDX] = reg_value.GetAsUInt64();
 496     break;
 497   case lldb_rdi_x86_64:
 498     m_gpr_x86_64.regs[_REG_RDI] = reg_value.GetAsUInt64();
 499     break;
 500   case lldb_rsi_x86_64:
 501     m_gpr_x86_64.regs[_REG_RSI] = reg_value.GetAsUInt64();
 502     break;
 503   case lldb_rbp_x86_64:
 504     m_gpr_x86_64.regs[_REG_RBP] = reg_value.GetAsUInt64();
 505     break;
 506   case lldb_rsp_x86_64:
 507     m_gpr_x86_64.regs[_REG_RSP] = reg_value.GetAsUInt64();
 508     break;
 509   case lldb_r8_x86_64:
 510     m_gpr_x86_64.regs[_REG_R8] = reg_value.GetAsUInt64();
 511     break;
 512   case lldb_r9_x86_64:
 513     m_gpr_x86_64.regs[_REG_R9] = reg_value.GetAsUInt64();
 514     break;
 515   case lldb_r10_x86_64:
 516     m_gpr_x86_64.regs[_REG_R10] = reg_value.GetAsUInt64();
 517     break;
 518   case lldb_r11_x86_64:
 519     m_gpr_x86_64.regs[_REG_R11] = reg_value.GetAsUInt64();
 520     break;
 521   case lldb_r12_x86_64:
 522     m_gpr_x86_64.regs[_REG_R12] = reg_value.GetAsUInt64();
 523     break;
 524   case lldb_r13_x86_64:
 525     m_gpr_x86_64.regs[_REG_R13] = reg_value.GetAsUInt64();
 526     break;
 527   case lldb_r14_x86_64:
 528     m_gpr_x86_64.regs[_REG_R14] = reg_value.GetAsUInt64();
 529     break;
 530   case lldb_r15_x86_64:
 531     m_gpr_x86_64.regs[_REG_R15] = reg_value.GetAsUInt64();
 532     break;
 533   case lldb_rip_x86_64:
 534     m_gpr_x86_64.regs[_REG_RIP] = reg_value.GetAsUInt64();
 535     break;
 536   case lldb_rflags_x86_64:
 537     m_gpr_x86_64.regs[_REG_RFLAGS] = reg_value.GetAsUInt64();
 538     break;
 539   case lldb_cs_x86_64:
 540     m_gpr_x86_64.regs[_REG_CS] = reg_value.GetAsUInt64();
 541     break;
 542   case lldb_fs_x86_64:
 543     m_gpr_x86_64.regs[_REG_FS] = reg_value.GetAsUInt64();
 544     break;
 545   case lldb_gs_x86_64:
 546     m_gpr_x86_64.regs[_REG_GS] = reg_value.GetAsUInt64();
 547     break;
 548   case lldb_ss_x86_64:
 549     m_gpr_x86_64.regs[_REG_SS] = reg_value.GetAsUInt64();
 550     break;
 551   case lldb_ds_x86_64:
 552     m_gpr_x86_64.regs[_REG_DS] = reg_value.GetAsUInt64();
 553     break;
 554   case lldb_es_x86_64:
 555     m_gpr_x86_64.regs[_REG_ES] = reg_value.GetAsUInt64();
 556     break;
 557   case lldb_fctrl_x86_64:
 558     m_fpr_x86_64.fxstate.fx_cw = reg_value.GetAsUInt16();
 559     break;
 560   case lldb_fstat_x86_64:
 561     m_fpr_x86_64.fxstate.fx_sw = reg_value.GetAsUInt16();
 562     break;
 563   case lldb_ftag_x86_64:
 564     m_fpr_x86_64.fxstate.fx_tw = reg_value.GetAsUInt8();
 565     break;
 566   case lldb_fop_x86_64:
 567     m_fpr_x86_64.fxstate.fx_opcode = reg_value.GetAsUInt16();
 568     break;
 569   case lldb_fiseg_x86_64:
 570     m_fpr_x86_64.fxstate.fx_ip.fa_64 = reg_value.GetAsUInt64();
 571     break;
 572   case lldb_fioff_x86_64:
 573     m_fpr_x86_64.fxstate.fx_ip.fa_32.fa_off = reg_value.GetAsUInt32();
 574     break;
 575   case lldb_foseg_x86_64:
 576     m_fpr_x86_64.fxstate.fx_dp.fa_64 = reg_value.GetAsUInt64();
 577     break;
 578   case lldb_fooff_x86_64:
 579     m_fpr_x86_64.fxstate.fx_dp.fa_32.fa_off = reg_value.GetAsUInt32();
 580     break;
 581   case lldb_mxcsr_x86_64:
 582     m_fpr_x86_64.fxstate.fx_mxcsr = reg_value.GetAsUInt32();
 583     break;
 584   case lldb_mxcsrmask_x86_64:
 585     m_fpr_x86_64.fxstate.fx_mxcsr_mask = reg_value.GetAsUInt32();
 586     break;
 587   case lldb_st0_x86_64:
 588   case lldb_st1_x86_64:
 589   case lldb_st2_x86_64:
 590   case lldb_st3_x86_64:
 591   case lldb_st4_x86_64:
 592   case lldb_st5_x86_64:
 593   case lldb_st6_x86_64:
 594   case lldb_st7_x86_64:
 595     ::memcpy(&m_fpr_x86_64.fxstate.fx_87_ac[reg - lldb_st0_x86_64],
 596              reg_value.GetBytes(), reg_value.GetByteSize());
 597     break;
 598   case lldb_mm0_x86_64:
 599   case lldb_mm1_x86_64:
 600   case lldb_mm2_x86_64:
 601   case lldb_mm3_x86_64:
 602   case lldb_mm4_x86_64:
 603   case lldb_mm5_x86_64:
 604   case lldb_mm6_x86_64:
 605   case lldb_mm7_x86_64:
 606     ::memcpy(&m_fpr_x86_64.fxstate.fx_xmm[reg - lldb_mm0_x86_64],
 607              reg_value.GetBytes(), reg_value.GetByteSize());
 608     break;
 609   case lldb_xmm0_x86_64:
 610   case lldb_xmm1_x86_64:
 611   case lldb_xmm2_x86_64:
 612   case lldb_xmm3_x86_64:
 613   case lldb_xmm4_x86_64:
 614   case lldb_xmm5_x86_64:
 615   case lldb_xmm6_x86_64:
 616   case lldb_xmm7_x86_64:
 617   case lldb_xmm8_x86_64:
 618   case lldb_xmm9_x86_64:
 619   case lldb_xmm10_x86_64:
 620   case lldb_xmm11_x86_64:
 621   case lldb_xmm12_x86_64:
 622   case lldb_xmm13_x86_64:
 623   case lldb_xmm14_x86_64:
 624   case lldb_xmm15_x86_64:
 625     ::memcpy(&m_fpr_x86_64.fxstate.fx_xmm[reg - lldb_xmm0_x86_64],
 626              reg_value.GetBytes(), reg_value.GetByteSize());
 627     break;
 628   case lldb_dr0_x86_64:
 629   case lldb_dr1_x86_64:
 630   case lldb_dr2_x86_64:
 631   case lldb_dr3_x86_64:
 632   case lldb_dr4_x86_64:
 633   case lldb_dr5_x86_64:
 634   case lldb_dr6_x86_64:
 635   case lldb_dr7_x86_64:
 636     m_dbr_x86_64.dr[reg - lldb_dr0_x86_64] = reg_value.GetAsUInt64();
 637     break;
 638   }
 639
 640   if (WriteRegisterSet(set) != 0)
 641     error.SetErrorStringWithFormat("failed to write register set");
 642
 643   return error;
 644 }
 645
 646 Status NativeRegisterContextNetBSD_x86_64::ReadAllRegisterValues(
 647     lldb::DataBufferSP &data_sp) {
 648   Status error;
 649
 650   data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
 651   if (!data_sp) {
 652     error.SetErrorStringWithFormat(
 653         "failed to allocate DataBufferHeap instance of size %" PRIu64,
 654         REG_CONTEXT_SIZE);
 655     return error;
 656   }
 657
 658   error = ReadGPR();
 659   if (error.Fail())
 660     return error;
 661
 662   uint8_t *dst = data_sp->GetBytes();
 663   if (dst == nullptr) {
 664     error.SetErrorStringWithFormat("DataBufferHeap instance of size %" PRIu64
 665                                    " returned a null pointer",
 666                                    REG_CONTEXT_SIZE);
 667     return error;
 668   }
 669
 670   ::memcpy(dst, &m_gpr_x86_64, GetRegisterInfoInterface().GetGPRSize());
 671   dst += GetRegisterInfoInterface().GetGPRSize();
 672
 673   RegisterValue value((uint64_t)-1);
 674   const RegisterInfo *reg_info =
 675       GetRegisterInfoInterface().GetDynamicRegisterInfo("orig_eax");
 676   if (reg_info == nullptr)
 677     reg_info = GetRegisterInfoInterface().GetDynamicRegisterInfo("orig_rax");
 678   return error;
 679 }
 680
 681 Status NativeRegisterContextNetBSD_x86_64::WriteAllRegisterValues(
 682     const lldb::DataBufferSP &data_sp) {
 683   Status error;
 684
 685   if (!data_sp) {
 686     error.SetErrorStringWithFormat(
 687         "NativeRegisterContextNetBSD_x86_64::%s invalid data_sp provided",
 688         __FUNCTION__);
 689     return error;
 690   }
 691
 692   if (data_sp->GetByteSize() != REG_CONTEXT_SIZE) {
 693     error.SetErrorStringWithFormat(
 694         "NativeRegisterContextNetBSD_x86_64::%s data_sp contained mismatched "
 695         "data size, expected %" PRIu64 ", actual %" PRIu64,
 696         __FUNCTION__, REG_CONTEXT_SIZE, data_sp->GetByteSize());
 697     return error;
 698   }
 699
 700   uint8_t *src = data_sp->GetBytes();
 701   if (src == nullptr) {
 702     error.SetErrorStringWithFormat("NativeRegisterContextNetBSD_x86_64::%s "
 703                                    "DataBuffer::GetBytes() returned a null "
 704                                    "pointer",
 705                                    __FUNCTION__);
 706     return error;
 707   }
 708   ::memcpy(&m_gpr_x86_64, src, GetRegisterInfoInterface().GetGPRSize());
 709
 710   error = WriteGPR();
 711   if (error.Fail())
 712     return error;
 713   src += GetRegisterInfoInterface().GetGPRSize();
 714
 715   return error;
 716 }
 717
 718 Status NativeRegisterContextNetBSD_x86_64::IsWatchpointHit(uint32_t wp_index,
 719                                                            bool &is_hit) {
 720   if (wp_index >= NumSupportedHardwareWatchpoints())
 721     return Status("Watchpoint index out of range");
 722
 723   RegisterValue reg_value;
 724   const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(lldb_dr6_x86_64);
 725   Status error = ReadRegister(reg_info, reg_value);
 726   if (error.Fail()) {
 727     is_hit = false;
 728     return error;
 729   }
 730
 731   uint64_t status_bits = reg_value.GetAsUInt64();
 732
 733   is_hit = status_bits & (1 << wp_index);
 734
 735   return error;
 736 }
 737
 738 Status NativeRegisterContextNetBSD_x86_64::GetWatchpointHitIndex(
 739     uint32_t &wp_index, lldb::addr_t trap_addr) {
 740   uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
 741   for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
 742     bool is_hit;
 743     Status error = IsWatchpointHit(wp_index, is_hit);
 744     if (error.Fail()) {
 745       wp_index = LLDB_INVALID_INDEX32;
 746       return error;
 747     } else if (is_hit) {
 748       return error;
 749     }
 750   }
 751   wp_index = LLDB_INVALID_INDEX32;
 752   return Status();
 753 }
 754
 755 Status NativeRegisterContextNetBSD_x86_64::IsWatchpointVacant(uint32_t wp_index,
 756                                                               bool &is_vacant) {
 757   if (wp_index >= NumSupportedHardwareWatchpoints())
 758     return Status("Watchpoint index out of range");
 759
 760   RegisterValue reg_value;
 761   const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(lldb_dr7_x86_64);
 762   Status error = ReadRegister(reg_info, reg_value);
 763   if (error.Fail()) {
 764     is_vacant = false;
 765     return error;
 766   }
 767
 768   uint64_t control_bits = reg_value.GetAsUInt64();
 769
 770   is_vacant = !(control_bits & (1 << (2 * wp_index)));
 771
 772   return error;
 773 }
 774
 775 Status NativeRegisterContextNetBSD_x86_64::SetHardwareWatchpointWithIndex(
 776     lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
 777
 778   if (wp_index >= NumSupportedHardwareWatchpoints())
 779     return Status("Watchpoint index out of range");
 780
 781   // Read only watchpoints aren't supported on x86_64. Fall back to read/write
 782   // waitchpoints instead.
 783   // TODO: Add logic to detect when a write happens and ignore that watchpoint
 784   // hit.
 785   if (watch_flags == 0x2)
 786     watch_flags = 0x3;
 787
 788   if (watch_flags != 0x1 && watch_flags != 0x3)
 789     return Status("Invalid read/write bits for watchpoint");
 790
 791   if (size != 1 && size != 2 && size != 4 && size != 8)
 792     return Status("Invalid size for watchpoint");
 793
 794   bool is_vacant;
 795   Status error = IsWatchpointVacant(wp_index, is_vacant);
 796   if (error.Fail())
 797     return error;
 798   if (!is_vacant)
 799     return Status("Watchpoint index not vacant");
 800
 801   RegisterValue reg_value;
 802   const RegisterInfo *const reg_info_dr7 =
 803       GetRegisterInfoAtIndex(lldb_dr7_x86_64);
 804   error = ReadRegister(reg_info_dr7, reg_value);
 805   if (error.Fail())
 806     return error;
 807
 808   // for watchpoints 0, 1, 2, or 3, respectively, set bits 1, 3, 5, or 7
 809   uint64_t enable_bit = 1 << (2 * wp_index);
 810
 811   // set bits 16-17, 20-21, 24-25, or 28-29
 812   // with 0b01 for write, and 0b11 for read/write
 813   uint64_t rw_bits = watch_flags << (16 + 4 * wp_index);
 814
 815   // set bits 18-19, 22-23, 26-27, or 30-31
 816   // with 0b00, 0b01, 0b10, or 0b11
 817   // for 1, 2, 8 (if supported), or 4 bytes, respectively
 818   uint64_t size_bits = (size == 8 ? 0x2 : size - 1) << (18 + 4 * wp_index);
 819
 820   uint64_t bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index));
 821
 822   uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask;
 823
 824   control_bits |= enable_bit | rw_bits | size_bits;
 825
 826   const RegisterInfo *const reg_info_drN =
 827       GetRegisterInfoAtIndex(lldb_dr0_x86_64 + wp_index);
 828   error = WriteRegister(reg_info_drN, RegisterValue(addr));
 829   if (error.Fail())
 830     return error;
 831
 832   error = WriteRegister(reg_info_dr7, RegisterValue(control_bits));
 833   if (error.Fail())
 834     return error;
 835
 836   error.Clear();
 837   return error;
 838 }
 839
 840 bool NativeRegisterContextNetBSD_x86_64::ClearHardwareWatchpoint(
 841     uint32_t wp_index) {
 842   if (wp_index >= NumSupportedHardwareWatchpoints())
 843     return false;
 844
 845   RegisterValue reg_value;
 846
 847   // for watchpoints 0, 1, 2, or 3, respectively, clear bits 0, 1, 2, or 3 of
 848   // the debug status register (DR6)
 849   const RegisterInfo *const reg_info_dr6 =
 850       GetRegisterInfoAtIndex(lldb_dr6_x86_64);
 851   Status error = ReadRegister(reg_info_dr6, reg_value);
 852   if (error.Fail())
 853     return false;
 854   uint64_t bit_mask = 1 << wp_index;
 855   uint64_t status_bits = reg_value.GetAsUInt64() & ~bit_mask;
 856   error = WriteRegister(reg_info_dr6, RegisterValue(status_bits));
 857   if (error.Fail())
 858     return false;
 859
 860   // for watchpoints 0, 1, 2, or 3, respectively, clear bits {0-1,16-19},
 861   // {2-3,20-23}, {4-5,24-27}, or {6-7,28-31} of the debug control register
 862   // (DR7)
 863   const RegisterInfo *const reg_info_dr7 =
 864       GetRegisterInfoAtIndex(lldb_dr7_x86_64);
 865   error = ReadRegister(reg_info_dr7, reg_value);
 866   if (error.Fail())
 867     return false;
 868   bit_mask = (0x3 << (2 * wp_index)) | (0xF << (16 + 4 * wp_index));
 869   uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask;
 870   return WriteRegister(reg_info_dr7, RegisterValue(control_bits)).Success();
 871 }
 872
 873 Status NativeRegisterContextNetBSD_x86_64::ClearAllHardwareWatchpoints() {
 874   RegisterValue reg_value;
 875
 876   // clear bits {0-4} of the debug status register (DR6)
 877   const RegisterInfo *const reg_info_dr6 =
 878       GetRegisterInfoAtIndex(lldb_dr6_x86_64);
 879   Status error = ReadRegister(reg_info_dr6, reg_value);
 880   if (error.Fail())
 881     return error;
 882   uint64_t bit_mask = 0xF;
 883   uint64_t status_bits = reg_value.GetAsUInt64() & ~bit_mask;
 884   error = WriteRegister(reg_info_dr6, RegisterValue(status_bits));
 885   if (error.Fail())
 886     return error;
 887
 888   // clear bits {0-7,16-31} of the debug control register (DR7)
 889   const RegisterInfo *const reg_info_dr7 =
 890       GetRegisterInfoAtIndex(lldb_dr7_x86_64);
 891   error = ReadRegister(reg_info_dr7, reg_value);
 892   if (error.Fail())
 893     return error;
 894   bit_mask = 0xFF | (0xFFFF << 16);
 895   uint64_t control_bits = reg_value.GetAsUInt64() & ~bit_mask;
 896   return WriteRegister(reg_info_dr7, RegisterValue(control_bits));
 897 }
 898
 899 uint32_t NativeRegisterContextNetBSD_x86_64::SetHardwareWatchpoint(
 900     lldb::addr_t addr, size_t size, uint32_t watch_flags) {
 901   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
 902   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 903   for (uint32_t wp_index = 0; wp_index < num_hw_watchpoints; ++wp_index) {
 904     bool is_vacant;
 905     Status error = IsWatchpointVacant(wp_index, is_vacant);
 906     if (is_vacant) {
 907       error = SetHardwareWatchpointWithIndex(addr, size, watch_flags, wp_index);
 908       if (error.Success())
 909         return wp_index;
 910     }
 911     if (error.Fail() && log) {
 912       log->Printf("NativeRegisterContextNetBSD_x86_64::%s Error: %s",
 913                   __FUNCTION__, error.AsCString());
 914     }
 915   }
 916   return LLDB_INVALID_INDEX32;
 917 }
 918
 919 lldb::addr_t
 920 NativeRegisterContextNetBSD_x86_64::GetWatchpointAddress(uint32_t wp_index) {
 921   if (wp_index >= NumSupportedHardwareWatchpoints())
 922     return LLDB_INVALID_ADDRESS;
 923   RegisterValue reg_value;
 924   const RegisterInfo *const reg_info_drN =
 925       GetRegisterInfoAtIndex(lldb_dr0_x86_64 + wp_index);
 926   if (ReadRegister(reg_info_drN, reg_value).Fail())
 927     return LLDB_INVALID_ADDRESS;
 928   return reg_value.GetAsUInt64();
 929 }
 930
 931 uint32_t NativeRegisterContextNetBSD_x86_64::NumSupportedHardwareWatchpoints() {
 932   // Available debug address registers: dr0, dr1, dr2, dr3
 933   return 4;
 934 }
 935
 936 #endif // defined(__x86_64__)