contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp

   1 //===-- RegisterContextPOSIXProcessMonitor_x86.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 #include "lldb/Core/RegisterValue.h"
  11 #include "lldb/Target/Thread.h"
  12 #include "lldb/Utility/DataBufferHeap.h"
  13
  14 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
  15 #include "Plugins/Process/FreeBSD/ProcessMonitor.h"
  16 #include "RegisterContextPOSIXProcessMonitor_x86.h"
  17
  18 using namespace lldb_private;
  19 using namespace lldb;
  20
  21 // Support ptrace extensions even when compiled without required kernel support
  22 #ifndef NT_X86_XSTATE
  23 #define NT_X86_XSTATE 0x202
  24 #endif
  25
  26 #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(FPR))
  27
  28 static uint32_t size_and_rw_bits(size_t size, bool read, bool write) {
  29   uint32_t rw;
  30
  31   if (read)
  32     rw = 0x3; // READ or READ/WRITE
  33   else if (write)
  34     rw = 0x1; // WRITE
  35   else
  36     assert(0 && "read and write cannot both be false");
  37
  38   switch (size) {
  39   case 1:
  40     return rw;
  41   case 2:
  42     return (0x1 << 2) | rw;
  43   case 4:
  44     return (0x3 << 2) | rw;
  45   case 8:
  46     return (0x2 << 2) | rw;
  47   default:
  48     assert(0 && "invalid size, must be one of 1, 2, 4, or 8");
  49     return 0; // Unreachable. Just to silence compiler.
  50   }
  51 }
  52
  53 RegisterContextPOSIXProcessMonitor_x86_64::
  54     RegisterContextPOSIXProcessMonitor_x86_64(
  55         Thread &thread, uint32_t concrete_frame_idx,
  56         lldb_private::RegisterInfoInterface *register_info)
  57     : RegisterContextPOSIX_x86(thread, concrete_frame_idx, register_info) {
  58   // Store byte offset of fctrl (i.e. first register of FPR) wrt 'UserArea'
  59   const RegisterInfo *reg_info_fctrl = GetRegisterInfoByName("fctrl");
  60   m_fctrl_offset_in_userarea = reg_info_fctrl->byte_offset;
  61
  62   m_iovec.iov_base = &m_fpr.xsave;
  63   m_iovec.iov_len = sizeof(m_fpr.xsave);
  64 }
  65
  66 ProcessMonitor &RegisterContextPOSIXProcessMonitor_x86_64::GetMonitor() {
  67   ProcessSP base = CalculateProcess();
  68   ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
  69   return process->GetMonitor();
  70 }
  71
  72 bool RegisterContextPOSIXProcessMonitor_x86_64::ReadGPR() {
  73   ProcessMonitor &monitor = GetMonitor();
  74   return monitor.ReadGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize());
  75 }
  76
  77 bool RegisterContextPOSIXProcessMonitor_x86_64::ReadFPR() {
  78   ProcessMonitor &monitor = GetMonitor();
  79   if (GetFPRType() == eFXSAVE)
  80     return monitor.ReadFPR(m_thread.GetID(), &m_fpr.fxsave,
  81                            sizeof(m_fpr.fxsave));
  82
  83   if (GetFPRType() == eXSAVE)
  84     return monitor.ReadRegisterSet(m_thread.GetID(), &m_iovec,
  85                                    sizeof(m_fpr.xsave), NT_X86_XSTATE);
  86   return false;
  87 }
  88
  89 bool RegisterContextPOSIXProcessMonitor_x86_64::WriteGPR() {
  90   ProcessMonitor &monitor = GetMonitor();
  91   return monitor.WriteGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize());
  92 }
  93
  94 bool RegisterContextPOSIXProcessMonitor_x86_64::WriteFPR() {
  95   ProcessMonitor &monitor = GetMonitor();
  96   if (GetFPRType() == eFXSAVE)
  97     return monitor.WriteFPR(m_thread.GetID(), &m_fpr.fxsave,
  98                             sizeof(m_fpr.fxsave));
  99
 100   if (GetFPRType() == eXSAVE)
 101     return monitor.WriteRegisterSet(m_thread.GetID(), &m_iovec,
 102                                     sizeof(m_fpr.xsave), NT_X86_XSTATE);
 103   return false;
 104 }
 105
 106 bool RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(
 107     const unsigned reg, RegisterValue &value) {
 108   ProcessMonitor &monitor = GetMonitor();
 109
 110 #if defined(__FreeBSD__)
 111   if (reg >= m_reg_info.first_dr)
 112     return monitor.ReadDebugRegisterValue(
 113         m_thread.GetID(), GetRegisterOffset(reg), GetRegisterName(reg),
 114         GetRegisterSize(reg), value);
 115 #endif
 116   return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
 117                                    GetRegisterName(reg), GetRegisterSize(reg),
 118                                    value);
 119 }
 120
 121 bool RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(
 122     const unsigned reg, const RegisterValue &value) {
 123   unsigned reg_to_write = reg;
 124   RegisterValue value_to_write = value;
 125
 126   // Check if this is a subregister of a full register.
 127   const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
 128   if (reg_info->invalidate_regs &&
 129       (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
 130     RegisterValue full_value;
 131     uint32_t full_reg = reg_info->invalidate_regs[0];
 132     const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
 133
 134     // Read the full register.
 135     if (ReadRegister(full_reg_info, full_value)) {
 136       Status error;
 137       ByteOrder byte_order = GetByteOrder();
 138       uint8_t dst[RegisterValue::kMaxRegisterByteSize];
 139
 140       // Get the bytes for the full register.
 141       const uint32_t dest_size = full_value.GetAsMemoryData(
 142           full_reg_info, dst, sizeof(dst), byte_order, error);
 143       if (error.Success() && dest_size) {
 144         uint8_t src[RegisterValue::kMaxRegisterByteSize];
 145
 146         // Get the bytes for the source data.
 147         const uint32_t src_size = value.GetAsMemoryData(
 148             reg_info, src, sizeof(src), byte_order, error);
 149         if (error.Success() && src_size && (src_size < dest_size)) {
 150           // Copy the src bytes to the destination.
 151           memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
 152           // Set this full register as the value to write.
 153           value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
 154           value_to_write.SetType(full_reg_info);
 155           reg_to_write = full_reg;
 156         }
 157       }
 158     }
 159   }
 160
 161   ProcessMonitor &monitor = GetMonitor();
 162 #if defined(__FreeBSD__)
 163   if (reg >= m_reg_info.first_dr)
 164     return monitor.WriteDebugRegisterValue(
 165         m_thread.GetID(), GetRegisterOffset(reg_to_write),
 166         GetRegisterName(reg_to_write), value_to_write);
 167 #endif
 168   return monitor.WriteRegisterValue(
 169       m_thread.GetID(), GetRegisterOffset(reg_to_write),
 170       GetRegisterName(reg_to_write), value_to_write);
 171 }
 172
 173 bool RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(
 174     const RegisterInfo *reg_info, RegisterValue &value) {
 175   if (!reg_info)
 176     return false;
 177
 178   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 179
 180   if (IsFPR(reg, GetFPRType())) {
 181     if (!ReadFPR())
 182       return false;
 183   } else {
 184     uint32_t full_reg = reg;
 185     bool is_subreg = reg_info->invalidate_regs &&
 186                      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
 187
 188     if (is_subreg) {
 189       // Read the full aligned 64-bit register.
 190       full_reg = reg_info->invalidate_regs[0];
 191     }
 192
 193     bool success = ReadRegister(full_reg, value);
 194
 195     if (success) {
 196       // If our read was not aligned (for ah,bh,ch,dh), shift our returned
 197       // value one byte to the right.
 198       if (is_subreg && (reg_info->byte_offset & 0x1))
 199         value.SetUInt64(value.GetAsUInt64() >> 8);
 200
 201       // If our return byte size was greater than the return value reg size,
 202       // then use the type specified by reg_info rather than the uint64_t
 203       // default
 204       if (value.GetByteSize() > reg_info->byte_size)
 205         value.SetType(reg_info);
 206     }
 207     return success;
 208   }
 209
 210   if (reg_info->encoding == eEncodingVector) {
 211     ByteOrder byte_order = GetByteOrder();
 212
 213     if (byte_order != ByteOrder::eByteOrderInvalid) {
 214       if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st)
 215         value.SetBytes(m_fpr.fxsave.stmm[reg - m_reg_info.first_st].bytes,
 216                        reg_info->byte_size, byte_order);
 217       if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm)
 218         value.SetBytes(m_fpr.fxsave.stmm[reg - m_reg_info.first_mm].bytes,
 219                        reg_info->byte_size, byte_order);
 220       if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm)
 221         value.SetBytes(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
 222                        reg_info->byte_size, byte_order);
 223       if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
 224         // Concatenate ymm using the register halves in xmm.bytes and
 225         // ymmh.bytes
 226         if (GetFPRType() == eXSAVE && CopyXSTATEtoYMM(reg, byte_order))
 227           value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
 228                          reg_info->byte_size, byte_order);
 229         else
 230           return false;
 231       }
 232       return value.GetType() == RegisterValue::eTypeBytes;
 233     }
 234     return false;
 235   }
 236
 237   // Get pointer to m_fpr.fxsave variable and set the data from it. Byte
 238   // offsets of all registers are calculated wrt 'UserArea' structure. However,
 239   // ReadFPR() reads fpu registers {using ptrace(PT_GETFPREGS,..)} and stores
 240   // them in 'm_fpr' (of type FPR structure). To extract values of fpu
 241   // registers, m_fpr should be read at byte offsets calculated wrt to FPR
 242   // structure.
 243
 244   // Since, FPR structure is also one of the member of UserArea structure.
 245   // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
 246   // byte_offset(fctrl wrt UserArea)
 247   assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) < sizeof(m_fpr));
 248   uint8_t *src =
 249       (uint8_t *)&m_fpr + reg_info->byte_offset - m_fctrl_offset_in_userarea;
 250   switch (reg_info->byte_size) {
 251   case 1:
 252     value.SetUInt8(*(uint8_t *)src);
 253     return true;
 254   case 2:
 255     value.SetUInt16(*(uint16_t *)src);
 256     return true;
 257   case 4:
 258     value.SetUInt32(*(uint32_t *)src);
 259     return true;
 260   case 8:
 261     value.SetUInt64(*(uint64_t *)src);
 262     return true;
 263   default:
 264     assert(false && "Unhandled data size.");
 265     return false;
 266   }
 267 }
 268
 269 bool RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(
 270     const RegisterInfo *reg_info, const RegisterValue &value) {
 271   const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 272
 273   if (IsGPR(reg))
 274     return WriteRegister(reg, value);
 275
 276   if (IsFPR(reg, GetFPRType())) {
 277     if (reg_info->encoding == eEncodingVector) {
 278       if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st)
 279         ::memcpy(m_fpr.fxsave.stmm[reg - m_reg_info.first_st].bytes,
 280                  value.GetBytes(), value.GetByteSize());
 281
 282       if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm)
 283         ::memcpy(m_fpr.fxsave.stmm[reg - m_reg_info.first_mm].bytes,
 284                  value.GetBytes(), value.GetByteSize());
 285
 286       if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm)
 287         ::memcpy(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
 288                  value.GetBytes(), value.GetByteSize());
 289
 290       if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
 291         if (GetFPRType() != eXSAVE)
 292           return false; // the target processor does not support AVX
 293
 294         // Store ymm register content, and split into the register halves in
 295         // xmm.bytes and ymmh.bytes
 296         ::memcpy(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
 297                  value.GetBytes(), value.GetByteSize());
 298         if (false == CopyYMMtoXSTATE(reg, GetByteOrder()))
 299           return false;
 300       }
 301     } else {
 302       // Get pointer to m_fpr.fxsave variable and set the data to it. Byte
 303       // offsets of all registers are calculated wrt 'UserArea' structure.
 304       // However, WriteFPR() takes m_fpr (of type FPR structure) and writes
 305       // only fpu registers using ptrace(PT_SETFPREGS,..) API. Hence fpu
 306       // registers should be written in m_fpr at byte offsets calculated wrt
 307       // FPR structure.
 308
 309       // Since, FPR structure is also one of the member of UserArea structure.
 310       // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
 311       // byte_offset(fctrl wrt UserArea)
 312       assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) <
 313              sizeof(m_fpr));
 314       uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset -
 315                      m_fctrl_offset_in_userarea;
 316       switch (reg_info->byte_size) {
 317       case 1:
 318         *(uint8_t *)dst = value.GetAsUInt8();
 319         break;
 320       case 2:
 321         *(uint16_t *)dst = value.GetAsUInt16();
 322         break;
 323       case 4:
 324         *(uint32_t *)dst = value.GetAsUInt32();
 325         break;
 326       case 8:
 327         *(uint64_t *)dst = value.GetAsUInt64();
 328         break;
 329       default:
 330         assert(false && "Unhandled data size.");
 331         return false;
 332       }
 333     }
 334
 335     if (WriteFPR()) {
 336       if (IsAVX(reg))
 337         return CopyYMMtoXSTATE(reg, GetByteOrder());
 338       return true;
 339     }
 340   }
 341   return false;
 342 }
 343
 344 bool RegisterContextPOSIXProcessMonitor_x86_64::ReadAllRegisterValues(
 345     DataBufferSP &data_sp) {
 346   bool success = false;
 347   data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
 348   if (data_sp && ReadGPR() && ReadFPR()) {
 349     uint8_t *dst = data_sp->GetBytes();
 350     success = dst != 0;
 351
 352     if (success) {
 353       ::memcpy(dst, &m_gpr_x86_64, GetGPRSize());
 354       dst += GetGPRSize();
 355       if (GetFPRType() == eFXSAVE)
 356         ::memcpy(dst, &m_fpr.fxsave, sizeof(m_fpr.fxsave));
 357     }
 358
 359     if (GetFPRType() == eXSAVE) {
 360       ByteOrder byte_order = GetByteOrder();
 361
 362       // Assemble the YMM register content from the register halves.
 363       for (uint32_t reg = m_reg_info.first_ymm;
 364            success && reg <= m_reg_info.last_ymm; ++reg)
 365         success = CopyXSTATEtoYMM(reg, byte_order);
 366
 367       if (success) {
 368         // Copy the extended register state including the assembled ymm
 369         // registers.
 370         ::memcpy(dst, &m_fpr, sizeof(m_fpr));
 371       }
 372     }
 373   }
 374   return success;
 375 }
 376
 377 bool RegisterContextPOSIXProcessMonitor_x86_64::WriteAllRegisterValues(
 378     const DataBufferSP &data_sp) {
 379   bool success = false;
 380   if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
 381     uint8_t *src = data_sp->GetBytes();
 382     if (src) {
 383       ::memcpy(&m_gpr_x86_64, src, GetGPRSize());
 384
 385       if (WriteGPR()) {
 386         src += GetGPRSize();
 387         if (GetFPRType() == eFXSAVE)
 388           ::memcpy(&m_fpr.fxsave, src, sizeof(m_fpr.fxsave));
 389         if (GetFPRType() == eXSAVE)
 390           ::memcpy(&m_fpr.xsave, src, sizeof(m_fpr.xsave));
 391
 392         success = WriteFPR();
 393         if (success) {
 394           if (GetFPRType() == eXSAVE) {
 395             ByteOrder byte_order = GetByteOrder();
 396
 397             // Parse the YMM register content from the register halves.
 398             for (uint32_t reg = m_reg_info.first_ymm;
 399                  success && reg <= m_reg_info.last_ymm; ++reg)
 400               success = CopyYMMtoXSTATE(reg, byte_order);
 401           }
 402         }
 403       }
 404     }
 405   }
 406   return success;
 407 }
 408
 409 uint32_t RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpoint(
 410     addr_t addr, size_t size, bool read, bool write) {
 411   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 412   uint32_t hw_index;
 413
 414   for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
 415     if (IsWatchpointVacant(hw_index))
 416       return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
 417   }
 418
 419   return LLDB_INVALID_INDEX32;
 420 }
 421
 422 bool RegisterContextPOSIXProcessMonitor_x86_64::ClearHardwareWatchpoint(
 423     uint32_t hw_index) {
 424   if (hw_index < NumSupportedHardwareWatchpoints()) {
 425     RegisterValue current_dr7_bits;
 426
 427     if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) {
 428       uint64_t new_dr7_bits =
 429           current_dr7_bits.GetAsUInt64() & ~(3 << (2 * hw_index));
 430
 431       if (WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits)))
 432         return true;
 433     }
 434   }
 435
 436   return false;
 437 }
 438
 439 bool RegisterContextPOSIXProcessMonitor_x86_64::HardwareSingleStep(
 440     bool enable) {
 441   enum { TRACE_BIT = 0x100 };
 442   uint64_t rflags;
 443
 444   if ((rflags = ReadRegisterAsUnsigned(m_reg_info.gpr_flags, -1UL)) == -1UL)
 445     return false;
 446
 447   if (enable) {
 448     if (rflags & TRACE_BIT)
 449       return true;
 450
 451     rflags |= TRACE_BIT;
 452   } else {
 453     if (!(rflags & TRACE_BIT))
 454       return false;
 455
 456     rflags &= ~TRACE_BIT;
 457   }
 458
 459   return WriteRegisterFromUnsigned(m_reg_info.gpr_flags, rflags);
 460 }
 461
 462 bool RegisterContextPOSIXProcessMonitor_x86_64::UpdateAfterBreakpoint() {
 463   // PC points one byte past the int3 responsible for the breakpoint.
 464   lldb::addr_t pc;
 465
 466   if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
 467     return false;
 468
 469   SetPC(pc - 1);
 470   return true;
 471 }
 472
 473 unsigned RegisterContextPOSIXProcessMonitor_x86_64::GetRegisterIndexFromOffset(
 474     unsigned offset) {
 475   unsigned reg;
 476   for (reg = 0; reg < m_reg_info.num_registers; reg++) {
 477     if (GetRegisterInfo()[reg].byte_offset == offset)
 478       break;
 479   }
 480   assert(reg < m_reg_info.num_registers && "Invalid register offset.");
 481   return reg;
 482 }
 483
 484 bool RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointHit(
 485     uint32_t hw_index) {
 486   bool is_hit = false;
 487
 488   if (m_watchpoints_initialized == false) {
 489     // Reset the debug status and debug control registers
 490     RegisterValue zero_bits = RegisterValue(uint64_t(0));
 491     if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) ||
 492         !WriteRegister(m_reg_info.first_dr + 7, zero_bits))
 493       assert(false && "Could not initialize watchpoint registers");
 494     m_watchpoints_initialized = true;
 495   }
 496
 497   if (hw_index < NumSupportedHardwareWatchpoints()) {
 498     RegisterValue value;
 499
 500     if (ReadRegister(m_reg_info.first_dr + 6, value)) {
 501       uint64_t val = value.GetAsUInt64();
 502       is_hit = val & (1 << hw_index);
 503     }
 504   }
 505
 506   return is_hit;
 507 }
 508
 509 bool RegisterContextPOSIXProcessMonitor_x86_64::ClearWatchpointHits() {
 510   return WriteRegister(m_reg_info.first_dr + 6, RegisterValue((uint64_t)0));
 511 }
 512
 513 addr_t RegisterContextPOSIXProcessMonitor_x86_64::GetWatchpointAddress(
 514     uint32_t hw_index) {
 515   addr_t wp_monitor_addr = LLDB_INVALID_ADDRESS;
 516
 517   if (hw_index < NumSupportedHardwareWatchpoints()) {
 518     if (!IsWatchpointVacant(hw_index)) {
 519       RegisterValue value;
 520
 521       if (ReadRegister(m_reg_info.first_dr + hw_index, value))
 522         wp_monitor_addr = value.GetAsUInt64();
 523     }
 524   }
 525
 526   return wp_monitor_addr;
 527 }
 528
 529 bool RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointVacant(
 530     uint32_t hw_index) {
 531   bool is_vacant = false;
 532   RegisterValue value;
 533
 534   assert(hw_index < NumSupportedHardwareWatchpoints());
 535
 536   if (m_watchpoints_initialized == false) {
 537     // Reset the debug status and debug control registers
 538     RegisterValue zero_bits = RegisterValue(uint64_t(0));
 539     if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) ||
 540         !WriteRegister(m_reg_info.first_dr + 7, zero_bits))
 541       assert(false && "Could not initialize watchpoint registers");
 542     m_watchpoints_initialized = true;
 543   }
 544
 545   if (ReadRegister(m_reg_info.first_dr + 7, value)) {
 546     uint64_t val = value.GetAsUInt64();
 547     is_vacant = (val & (3 << 2 * hw_index)) == 0;
 548   }
 549
 550   return is_vacant;
 551 }
 552
 553 bool RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpointWithIndex(
 554     addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
 555   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 556
 557   if (num_hw_watchpoints == 0 || hw_index >= num_hw_watchpoints)
 558     return false;
 559
 560   if (!(size == 1 || size == 2 || size == 4 || size == 8))
 561     return false;
 562
 563   if (read == false && write == false)
 564     return false;
 565
 566   if (!IsWatchpointVacant(hw_index))
 567     return false;
 568
 569   // Set both dr7 (debug control register) and dri (debug address register).
 570
 571   // dr7{7-0} encodes the local/global enable bits:
 572   //  global enable --. .-- local enable
 573   //                  | |
 574   //                  v v
 575   //      dr0 -> bits{1-0}
 576   //      dr1 -> bits{3-2}
 577   //      dr2 -> bits{5-4}
 578   //      dr3 -> bits{7-6}
 579   //
 580   // dr7{31-16} encodes the rw/len bits:
 581   //  b_x+3, b_x+2, b_x+1, b_x
 582   //      where bits{x+1, x} => rw
 583   //            0b00: execute, 0b01: write, 0b11: read-or-write,
 584   //            0b10: io read-or-write (unused)
 585   //      and bits{x+3, x+2} => len
 586   //            0b00: 1-byte, 0b01: 2-byte, 0b11: 4-byte, 0b10: 8-byte
 587   //
 588   //      dr0 -> bits{19-16}
 589   //      dr1 -> bits{23-20}
 590   //      dr2 -> bits{27-24}
 591   //      dr3 -> bits{31-28}
 592   if (hw_index < num_hw_watchpoints) {
 593     RegisterValue current_dr7_bits;
 594
 595     if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) {
 596       uint64_t new_dr7_bits =
 597           current_dr7_bits.GetAsUInt64() |
 598           (1 << (2 * hw_index) |
 599            size_and_rw_bits(size, read, write) << (16 + 4 * hw_index));
 600
 601       if (WriteRegister(m_reg_info.first_dr + hw_index, RegisterValue(addr)) &&
 602           WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits)))
 603         return true;
 604     }
 605   }
 606
 607   return false;
 608 }
 609
 610 uint32_t
 611 RegisterContextPOSIXProcessMonitor_x86_64::NumSupportedHardwareWatchpoints() {
 612   // Available debug address registers: dr0, dr1, dr2, dr3
 613   return 4;
 614 }