lldb/source/API/SBWatchpoint.cpp

   1 //===-- SBWatchpoint.cpp --------------------------------*- C++ -*-===//
   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 "lldb/API/SBWatchpoint.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "lldb/API/SBAddress.h"
  12 #include "lldb/API/SBDebugger.h"
  13 #include "lldb/API/SBDefines.h"
  14 #include "lldb/API/SBEvent.h"
  15 #include "lldb/API/SBStream.h"
  16
  17 #include "lldb/Breakpoint/Watchpoint.h"
  18 #include "lldb/Breakpoint/WatchpointList.h"
  19 #include "lldb/Core/StreamFile.h"
  20 #include "lldb/Target/Process.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Utility/Stream.h"
  23 #include "lldb/lldb-defines.h"
  24 #include "lldb/lldb-types.h"
  25
  26 using namespace lldb;
  27 using namespace lldb_private;
  28
  29 SBWatchpoint::SBWatchpoint() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBWatchpoint); }
  30
  31 SBWatchpoint::SBWatchpoint(const lldb::WatchpointSP &wp_sp)
  32     : m_opaque_wp(wp_sp) {
  33   LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &), wp_sp);
  34 }
  35
  36 SBWatchpoint::SBWatchpoint(const SBWatchpoint &rhs)
  37     : m_opaque_wp(rhs.m_opaque_wp) {
  38   LLDB_RECORD_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &), rhs);
  39 }
  40
  41 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
  42   LLDB_RECORD_METHOD(const lldb::SBWatchpoint &,
  43                      SBWatchpoint, operator=,(const lldb::SBWatchpoint &), rhs);
  44
  45   m_opaque_wp = rhs.m_opaque_wp;
  46   return LLDB_RECORD_RESULT(*this);
  47 }
  48
  49 SBWatchpoint::~SBWatchpoint() {}
  50
  51 watch_id_t SBWatchpoint::GetID() {
  52   LLDB_RECORD_METHOD_NO_ARGS(lldb::watch_id_t, SBWatchpoint, GetID);
  53
  54
  55   watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
  56   lldb::WatchpointSP watchpoint_sp(GetSP());
  57   if (watchpoint_sp)
  58     watch_id = watchpoint_sp->GetID();
  59
  60   return watch_id;
  61 }
  62
  63 bool SBWatchpoint::IsValid() const {
  64   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
  65   return this->operator bool();
  66 }
  67 SBWatchpoint::operator bool() const {
  68   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
  69
  70   return bool(m_opaque_wp.lock());
  71 }
  72
  73 bool SBWatchpoint::operator==(const SBWatchpoint &rhs) const {
  74   LLDB_RECORD_METHOD_CONST(
  75       bool, SBWatchpoint, operator==,(const SBWatchpoint &), rhs);
  76
  77   return GetSP() == rhs.GetSP();
  78 }
  79
  80 bool SBWatchpoint::operator!=(const SBWatchpoint &rhs) const {
  81   LLDB_RECORD_METHOD_CONST(
  82       bool, SBWatchpoint, operator!=,(const SBWatchpoint &), rhs);
  83
  84   return !(*this == rhs);
  85 }
  86
  87 SBError SBWatchpoint::GetError() {
  88   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
  89
  90   SBError sb_error;
  91   lldb::WatchpointSP watchpoint_sp(GetSP());
  92   if (watchpoint_sp) {
  93     sb_error.SetError(watchpoint_sp->GetError());
  94   }
  95   return LLDB_RECORD_RESULT(sb_error);
  96 }
  97
  98 int32_t SBWatchpoint::GetHardwareIndex() {
  99   LLDB_RECORD_METHOD_NO_ARGS(int32_t, SBWatchpoint, GetHardwareIndex);
 100
 101   int32_t hw_index = -1;
 102
 103   lldb::WatchpointSP watchpoint_sp(GetSP());
 104   if (watchpoint_sp) {
 105     std::lock_guard<std::recursive_mutex> guard(
 106         watchpoint_sp->GetTarget().GetAPIMutex());
 107     hw_index = watchpoint_sp->GetHardwareIndex();
 108   }
 109
 110   return hw_index;
 111 }
 112
 113 addr_t SBWatchpoint::GetWatchAddress() {
 114   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBWatchpoint, GetWatchAddress);
 115
 116   addr_t ret_addr = LLDB_INVALID_ADDRESS;
 117
 118   lldb::WatchpointSP watchpoint_sp(GetSP());
 119   if (watchpoint_sp) {
 120     std::lock_guard<std::recursive_mutex> guard(
 121         watchpoint_sp->GetTarget().GetAPIMutex());
 122     ret_addr = watchpoint_sp->GetLoadAddress();
 123   }
 124
 125   return ret_addr;
 126 }
 127
 128 size_t SBWatchpoint::GetWatchSize() {
 129   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBWatchpoint, GetWatchSize);
 130
 131   size_t watch_size = 0;
 132
 133   lldb::WatchpointSP watchpoint_sp(GetSP());
 134   if (watchpoint_sp) {
 135     std::lock_guard<std::recursive_mutex> guard(
 136         watchpoint_sp->GetTarget().GetAPIMutex());
 137     watch_size = watchpoint_sp->GetByteSize();
 138   }
 139
 140   return watch_size;
 141 }
 142
 143 void SBWatchpoint::SetEnabled(bool enabled) {
 144   LLDB_RECORD_METHOD(void, SBWatchpoint, SetEnabled, (bool), enabled);
 145
 146   lldb::WatchpointSP watchpoint_sp(GetSP());
 147   if (watchpoint_sp) {
 148     Target &target = watchpoint_sp->GetTarget();
 149     std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
 150     ProcessSP process_sp = target.GetProcessSP();
 151     const bool notify = true;
 152     if (process_sp) {
 153       if (enabled)
 154         process_sp->EnableWatchpoint(watchpoint_sp.get(), notify);
 155       else
 156         process_sp->DisableWatchpoint(watchpoint_sp.get(), notify);
 157     } else {
 158       watchpoint_sp->SetEnabled(enabled, notify);
 159     }
 160   }
 161 }
 162
 163 bool SBWatchpoint::IsEnabled() {
 164   LLDB_RECORD_METHOD_NO_ARGS(bool, SBWatchpoint, IsEnabled);
 165
 166   lldb::WatchpointSP watchpoint_sp(GetSP());
 167   if (watchpoint_sp) {
 168     std::lock_guard<std::recursive_mutex> guard(
 169         watchpoint_sp->GetTarget().GetAPIMutex());
 170     return watchpoint_sp->IsEnabled();
 171   } else
 172     return false;
 173 }
 174
 175 uint32_t SBWatchpoint::GetHitCount() {
 176   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetHitCount);
 177
 178   uint32_t count = 0;
 179   lldb::WatchpointSP watchpoint_sp(GetSP());
 180   if (watchpoint_sp) {
 181     std::lock_guard<std::recursive_mutex> guard(
 182         watchpoint_sp->GetTarget().GetAPIMutex());
 183     count = watchpoint_sp->GetHitCount();
 184   }
 185
 186   return count;
 187 }
 188
 189 uint32_t SBWatchpoint::GetIgnoreCount() {
 190   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBWatchpoint, GetIgnoreCount);
 191
 192   lldb::WatchpointSP watchpoint_sp(GetSP());
 193   if (watchpoint_sp) {
 194     std::lock_guard<std::recursive_mutex> guard(
 195         watchpoint_sp->GetTarget().GetAPIMutex());
 196     return watchpoint_sp->GetIgnoreCount();
 197   } else
 198     return 0;
 199 }
 200
 201 void SBWatchpoint::SetIgnoreCount(uint32_t n) {
 202   LLDB_RECORD_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t), n);
 203
 204   lldb::WatchpointSP watchpoint_sp(GetSP());
 205   if (watchpoint_sp) {
 206     std::lock_guard<std::recursive_mutex> guard(
 207         watchpoint_sp->GetTarget().GetAPIMutex());
 208     watchpoint_sp->SetIgnoreCount(n);
 209   }
 210 }
 211
 212 const char *SBWatchpoint::GetCondition() {
 213   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBWatchpoint, GetCondition);
 214
 215   lldb::WatchpointSP watchpoint_sp(GetSP());
 216   if (watchpoint_sp) {
 217     std::lock_guard<std::recursive_mutex> guard(
 218         watchpoint_sp->GetTarget().GetAPIMutex());
 219     return watchpoint_sp->GetConditionText();
 220   }
 221   return nullptr;
 222 }
 223
 224 void SBWatchpoint::SetCondition(const char *condition) {
 225   LLDB_RECORD_METHOD(void, SBWatchpoint, SetCondition, (const char *),
 226                      condition);
 227
 228   lldb::WatchpointSP watchpoint_sp(GetSP());
 229   if (watchpoint_sp) {
 230     std::lock_guard<std::recursive_mutex> guard(
 231         watchpoint_sp->GetTarget().GetAPIMutex());
 232     watchpoint_sp->SetCondition(condition);
 233   }
 234 }
 235
 236 bool SBWatchpoint::GetDescription(SBStream &description,
 237                                   DescriptionLevel level) {
 238   LLDB_RECORD_METHOD(bool, SBWatchpoint, GetDescription,
 239                      (lldb::SBStream &, lldb::DescriptionLevel), description,
 240                      level);
 241
 242   Stream &strm = description.ref();
 243
 244   lldb::WatchpointSP watchpoint_sp(GetSP());
 245   if (watchpoint_sp) {
 246     std::lock_guard<std::recursive_mutex> guard(
 247         watchpoint_sp->GetTarget().GetAPIMutex());
 248     watchpoint_sp->GetDescription(&strm, level);
 249     strm.EOL();
 250   } else
 251     strm.PutCString("No value");
 252
 253   return true;
 254 }
 255
 256 void SBWatchpoint::Clear() {
 257   LLDB_RECORD_METHOD_NO_ARGS(void, SBWatchpoint, Clear);
 258
 259   m_opaque_wp.reset();
 260 }
 261
 262 lldb::WatchpointSP SBWatchpoint::GetSP() const {
 263   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::WatchpointSP, SBWatchpoint, GetSP);
 264
 265   return LLDB_RECORD_RESULT(m_opaque_wp.lock());
 266 }
 267
 268 void SBWatchpoint::SetSP(const lldb::WatchpointSP &sp) {
 269   LLDB_RECORD_METHOD(void, SBWatchpoint, SetSP, (const lldb::WatchpointSP &),
 270                      sp);
 271
 272   m_opaque_wp = sp;
 273 }
 274
 275 bool SBWatchpoint::EventIsWatchpointEvent(const lldb::SBEvent &event) {
 276   LLDB_RECORD_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
 277                             (const lldb::SBEvent &), event);
 278
 279   return Watchpoint::WatchpointEventData::GetEventDataFromEvent(event.get()) !=
 280          nullptr;
 281 }
 282
 283 WatchpointEventType
 284 SBWatchpoint::GetWatchpointEventTypeFromEvent(const SBEvent &event) {
 285   LLDB_RECORD_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
 286                             GetWatchpointEventTypeFromEvent,
 287                             (const lldb::SBEvent &), event);
 288
 289   if (event.IsValid())
 290     return Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
 291         event.GetSP());
 292   return eWatchpointEventTypeInvalidType;
 293 }
 294
 295 SBWatchpoint SBWatchpoint::GetWatchpointFromEvent(const lldb::SBEvent &event) {
 296   LLDB_RECORD_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
 297                             GetWatchpointFromEvent, (const lldb::SBEvent &),
 298                             event);
 299
 300   SBWatchpoint sb_watchpoint;
 301   if (event.IsValid())
 302     sb_watchpoint =
 303         Watchpoint::WatchpointEventData::GetWatchpointFromEvent(event.GetSP());
 304   return LLDB_RECORD_RESULT(sb_watchpoint);
 305 }
 306
 307 namespace lldb_private {
 308 namespace repro {
 309
 310 template <>
 311 void RegisterMethods<SBWatchpoint>(Registry &R) {
 312   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
 313   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
 314   LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
 315   LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
 316                        SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
 317   LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
 318   LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
 319   LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
 320   LLDB_REGISTER_METHOD_CONST(
 321       bool, SBWatchpoint, operator==,(const lldb::SBWatchpoint &));
 322   LLDB_REGISTER_METHOD_CONST(
 323       bool, SBWatchpoint, operator!=,(const lldb::SBWatchpoint &));
 324   LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
 325   LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
 326   LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());
 327   LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
 328   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
 329   LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
 330   LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
 331   LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());
 332   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetIgnoreCount, (uint32_t));
 333   LLDB_REGISTER_METHOD(const char *, SBWatchpoint, GetCondition, ());
 334   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetCondition, (const char *));
 335   LLDB_REGISTER_METHOD(bool, SBWatchpoint, GetDescription,
 336                        (lldb::SBStream &, lldb::DescriptionLevel));
 337   LLDB_REGISTER_METHOD(void, SBWatchpoint, Clear, ());
 338   LLDB_REGISTER_METHOD_CONST(lldb::WatchpointSP, SBWatchpoint, GetSP, ());
 339   LLDB_REGISTER_METHOD(void, SBWatchpoint, SetSP,
 340                        (const lldb::WatchpointSP &));
 341   LLDB_REGISTER_STATIC_METHOD(bool, SBWatchpoint, EventIsWatchpointEvent,
 342                               (const lldb::SBEvent &));
 343   LLDB_REGISTER_STATIC_METHOD(lldb::WatchpointEventType, SBWatchpoint,
 344                               GetWatchpointEventTypeFromEvent,
 345                               (const lldb::SBEvent &));
 346   LLDB_REGISTER_STATIC_METHOD(lldb::SBWatchpoint, SBWatchpoint,
 347                               GetWatchpointFromEvent,
 348                               (const lldb::SBEvent &));
 349 }
 350
 351 }
 352 }