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

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