lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp

   1 //===-- NativeRegisterContextDBReg_x86.cpp --------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "NativeRegisterContextDBReg_x86.h"
  10 #include "lldb/Utility/LLDBLog.h"
  11 #include "lldb/Utility/RegisterValue.h"
  12
  13 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
  14
  15 using namespace lldb_private;
  16
  17 // Returns mask/value for status bit of wp_index in DR6
  18 static inline uint64_t GetStatusBit(uint32_t wp_index) {
  19   // DR6: ...BBBB
  20   //         3210 <- status bits for bp./wp. i; 1 if hit
  21   return 1ULL << wp_index;
  22 }
  23
  24 // Returns mask/value for global enable bit of wp_index in DR7
  25 static inline uint64_t GetEnableBit(uint32_t wp_index) {
  26   // DR7: ...GLGLGLGL
  27   //         33221100 <- global/local enable for bp./wp.; 1 if enabled
  28   // we use global bits because NetBSD kernel does not preserve local
  29   // bits reliably; Linux seems fine with either
  30   return 1ULL << (2 * wp_index + 1);
  31 }
  32
  33 // Returns mask for both enable bits of wp_index in DR7
  34 static inline uint64_t GetBothEnableBitMask(uint32_t wp_index) {
  35   // DR7: ...GLGLGLGL
  36   //         33221100 <- global/local enable for bp./wp.; 1 if enabled
  37   return 3ULL << (2 * wp_index + 1);
  38 }
  39
  40 // Returns value for type bits of wp_index in DR7
  41 static inline uint64_t GetWatchTypeBits(uint32_t watch_flags,
  42                                         uint32_t wp_index) {
  43   // DR7:
  44   // bit: 3322222222221111...
  45   //      1098765432109876...
  46   // val: SSTTSSTTSSTTSSTT...
  47   // wp.: 3333222211110000...
  48   //
  49   // where T - type is 01 for write, 11 for r/w
  50   return static_cast<uint64_t>(watch_flags) << (16 + 4 * wp_index);
  51 }
  52
  53 // Returns value for size bits of wp_index in DR7
  54 static inline uint64_t GetWatchSizeBits(uint32_t size, uint32_t wp_index) {
  55   // DR7:
  56   // bit: 3322222222221111...
  57   //      1098765432109876...
  58   // val: SSTTSSTTSSTTSSTT...
  59   // wp.: 3333222211110000...
  60   //
  61   // where S - size is:
  62   // 00 for 1 byte
  63   // 01 for 2 bytes
  64   // 10 for 8 bytes
  65   // 11 for 4 bytes
  66   return static_cast<uint64_t>(size == 8 ? 0x2 : size - 1)
  67          << (18 + 4 * wp_index);
  68 }
  69
  70 // Returns bitmask for all bits controlling wp_index in DR7
  71 static inline uint64_t GetWatchControlBitmask(uint32_t wp_index) {
  72   // DR7:
  73   // bit: 33222222222211111111110000000000
  74   //      10987654321098765432109876543210
  75   // val: SSTTSSTTSSTTSSTTxxxxxxGLGLGLGLGL
  76   // wp.: 3333222211110000xxxxxxEE33221100
  77   return GetBothEnableBitMask(wp_index) | (0xF << (16 + 4 * wp_index));
  78 }
  79
  80 // Bit mask for control bits regarding all watchpoints.
  81 static constexpr uint64_t watchpoint_all_control_bit_mask = 0xFFFF00FF;
  82
  83 const RegisterInfo *NativeRegisterContextDBReg_x86::GetDR(int num) const {
  84   assert(num >= 0 && num <= 7);
  85   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
  86   case llvm::Triple::x86:
  87     return GetRegisterInfoAtIndex(lldb_dr0_i386 + num);
  88   case llvm::Triple::x86_64:
  89     return GetRegisterInfoAtIndex(lldb_dr0_x86_64 + num);
  90   default:
  91     llvm_unreachable("Unhandled target architecture.");
  92   }
  93 }
  94
  95 Status NativeRegisterContextDBReg_x86::IsWatchpointHit(uint32_t wp_index,
  96                                                        bool &is_hit) {
  97   if (wp_index >= NumSupportedHardwareWatchpoints())
  98     return Status("Watchpoint index out of range");
  99
 100   RegisterValue dr6;
 101   Status error = ReadRegister(GetDR(6), dr6);
 102   if (error.Fail())
 103     is_hit = false;
 104   else
 105     is_hit = dr6.GetAsUInt64() & GetStatusBit(wp_index);
 106
 107   return error;
 108 }
 109
 110 Status
 111 NativeRegisterContextDBReg_x86::GetWatchpointHitIndex(uint32_t &wp_index,
 112                                                       lldb::addr_t trap_addr) {
 113   uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
 114   for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
 115     bool is_hit;
 116     Status error = IsWatchpointHit(wp_index, is_hit);
 117     if (error.Fail()) {
 118       wp_index = LLDB_INVALID_INDEX32;
 119       return error;
 120     } else if (is_hit) {
 121       return error;
 122     }
 123   }
 124   wp_index = LLDB_INVALID_INDEX32;
 125   return Status();
 126 }
 127
 128 Status NativeRegisterContextDBReg_x86::IsWatchpointVacant(uint32_t wp_index,
 129                                                           bool &is_vacant) {
 130   if (wp_index >= NumSupportedHardwareWatchpoints())
 131     return Status("Watchpoint index out of range");
 132
 133   RegisterValue dr7;
 134   Status error = ReadRegister(GetDR(7), dr7);
 135   if (error.Fail())
 136     is_vacant = false;
 137   else
 138     is_vacant = !(dr7.GetAsUInt64() & GetEnableBit(wp_index));
 139
 140   return error;
 141 }
 142
 143 Status NativeRegisterContextDBReg_x86::SetHardwareWatchpointWithIndex(
 144     lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
 145
 146   if (wp_index >= NumSupportedHardwareWatchpoints())
 147     return Status("Watchpoint index out of range");
 148
 149   // Read only watchpoints aren't supported on x86_64. Fall back to read/write
 150   // waitchpoints instead.
 151   // TODO: Add logic to detect when a write happens and ignore that watchpoint
 152   // hit.
 153   if (watch_flags == 2)
 154     watch_flags = 3;
 155
 156   if (watch_flags != 1 && watch_flags != 3)
 157     return Status("Invalid read/write bits for watchpoint");
 158   if (size != 1 && size != 2 && size != 4 && size != 8)
 159     return Status("Invalid size for watchpoint");
 160
 161   bool is_vacant;
 162   Status error = IsWatchpointVacant(wp_index, is_vacant);
 163   if (error.Fail())
 164     return error;
 165   if (!is_vacant)
 166     return Status("Watchpoint index not vacant");
 167
 168   RegisterValue dr7, drN;
 169   error = ReadRegister(GetDR(7), dr7);
 170   if (error.Fail())
 171     return error;
 172   error = ReadRegister(GetDR(wp_index), drN);
 173   if (error.Fail())
 174     return error;
 175
 176   uint64_t control_bits = dr7.GetAsUInt64() & ~GetWatchControlBitmask(wp_index);
 177   control_bits |= GetEnableBit(wp_index) |
 178                   GetWatchTypeBits(watch_flags, wp_index) |
 179                   GetWatchSizeBits(size, wp_index);
 180
 181   // Clear dr6 if address or bits changed (i.e. we're not reenabling the same
 182   // watchpoint).  This can not be done when clearing watchpoints since
 183   // the gdb-remote protocol repeatedly clears and readds watchpoints on all
 184   // program threads, effectively clearing pending events on NetBSD.
 185   // NB: enable bits in dr7 are always 0 here since we're (re)adding it
 186   if (drN.GetAsUInt64() != addr ||
 187       (dr7.GetAsUInt64() & GetWatchControlBitmask(wp_index)) !=
 188           (GetWatchTypeBits(watch_flags, wp_index) |
 189            GetWatchSizeBits(size, wp_index))) {
 190     ClearWatchpointHit(wp_index);
 191
 192     // We skip update to drN if neither address nor mode changed.
 193     error = WriteRegister(GetDR(wp_index), RegisterValue(addr));
 194     if (error.Fail())
 195       return error;
 196   }
 197
 198   error = WriteRegister(GetDR(7), RegisterValue(control_bits));
 199   if (error.Fail())
 200     return error;
 201
 202   return error;
 203 }
 204
 205 bool NativeRegisterContextDBReg_x86::ClearHardwareWatchpoint(
 206     uint32_t wp_index) {
 207   if (wp_index >= NumSupportedHardwareWatchpoints())
 208     return false;
 209
 210   RegisterValue dr7;
 211   Status error = ReadRegister(GetDR(7), dr7);
 212   if (error.Fail())
 213     return false;
 214
 215   return WriteRegister(GetDR(7), RegisterValue(dr7.GetAsUInt64() &
 216                                                ~GetBothEnableBitMask(wp_index)))
 217       .Success();
 218 }
 219
 220 Status NativeRegisterContextDBReg_x86::ClearWatchpointHit(uint32_t wp_index) {
 221   if (wp_index >= NumSupportedHardwareWatchpoints())
 222     return Status("Watchpoint index out of range");
 223
 224   RegisterValue dr6;
 225   Status error = ReadRegister(GetDR(6), dr6);
 226   if (error.Fail())
 227     return error;
 228
 229   return WriteRegister(
 230       GetDR(6), RegisterValue(dr6.GetAsUInt64() & ~GetStatusBit(wp_index)));
 231 }
 232
 233 Status NativeRegisterContextDBReg_x86::ClearAllHardwareWatchpoints() {
 234   RegisterValue dr7;
 235   Status error = ReadRegister(GetDR(7), dr7);
 236   if (error.Fail())
 237     return error;
 238   return WriteRegister(
 239       GetDR(7),
 240       RegisterValue(dr7.GetAsUInt64() & ~watchpoint_all_control_bit_mask));
 241 }
 242
 243 uint32_t NativeRegisterContextDBReg_x86::SetHardwareWatchpoint(
 244     lldb::addr_t addr, size_t size, uint32_t watch_flags) {
 245   Log *log = GetLog(LLDBLog::Watchpoints);
 246   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
 247   for (uint32_t wp_index = 0; wp_index < num_hw_watchpoints; ++wp_index) {
 248     bool is_vacant;
 249     Status error = IsWatchpointVacant(wp_index, is_vacant);
 250     if (is_vacant) {
 251       error = SetHardwareWatchpointWithIndex(addr, size, watch_flags, wp_index);
 252       if (error.Success())
 253         return wp_index;
 254     }
 255     if (error.Fail() && log) {
 256       LLDB_LOGF(log, "NativeRegisterContextDBReg_x86::%s Error: %s",
 257                 __FUNCTION__, error.AsCString());
 258     }
 259   }
 260   return LLDB_INVALID_INDEX32;
 261 }
 262
 263 lldb::addr_t
 264 NativeRegisterContextDBReg_x86::GetWatchpointAddress(uint32_t wp_index) {
 265   if (wp_index >= NumSupportedHardwareWatchpoints())
 266     return LLDB_INVALID_ADDRESS;
 267   RegisterValue drN;
 268   if (ReadRegister(GetDR(wp_index), drN).Fail())
 269     return LLDB_INVALID_ADDRESS;
 270   return drN.GetAsUInt64();
 271 }
 272
 273 uint32_t NativeRegisterContextDBReg_x86::NumSupportedHardwareWatchpoints() {
 274   // Available debug address registers: dr0, dr1, dr2, dr3
 275   return 4;
 276 }