contrib/llvm-project/lldb/source/Breakpoint/WatchpointOptions.cpp

   1 //===-- WatchpointOptions.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/Breakpoint/WatchpointOptions.h"
  10
  11 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  12 #include "lldb/Core/Value.h"
  13 #include "lldb/Target/Process.h"
  14 #include "lldb/Target/Target.h"
  15 #include "lldb/Target/ThreadSpec.h"
  16 #include "lldb/Utility/Stream.h"
  17 #include "lldb/Utility/StringList.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 bool WatchpointOptions::NullCallback(void *baton,
  23                                      StoppointCallbackContext *context,
  24                                      lldb::user_id_t watch_id) {
  25   return true;
  26 }
  27
  28 // WatchpointOptions constructor
  29 WatchpointOptions::WatchpointOptions()
  30     : m_callback(WatchpointOptions::NullCallback), m_callback_baton_sp(),
  31       m_callback_is_synchronous(false), m_thread_spec_up() {}
  32
  33 // WatchpointOptions copy constructor
  34 WatchpointOptions::WatchpointOptions(const WatchpointOptions &rhs)
  35     : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
  36       m_callback_is_synchronous(rhs.m_callback_is_synchronous),
  37       m_thread_spec_up() {
  38   if (rhs.m_thread_spec_up != nullptr)
  39     m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
  40 }
  41
  42 // WatchpointOptions assignment operator
  43 const WatchpointOptions &WatchpointOptions::
  44 operator=(const WatchpointOptions &rhs) {
  45   m_callback = rhs.m_callback;
  46   m_callback_baton_sp = rhs.m_callback_baton_sp;
  47   m_callback_is_synchronous = rhs.m_callback_is_synchronous;
  48   if (rhs.m_thread_spec_up != nullptr)
  49     m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
  50   return *this;
  51 }
  52
  53 WatchpointOptions *
  54 WatchpointOptions::CopyOptionsNoCallback(WatchpointOptions &orig) {
  55   WatchpointHitCallback orig_callback = orig.m_callback;
  56   lldb::BatonSP orig_callback_baton_sp = orig.m_callback_baton_sp;
  57   bool orig_is_sync = orig.m_callback_is_synchronous;
  58
  59   orig.ClearCallback();
  60   WatchpointOptions *ret_val = new WatchpointOptions(orig);
  61
  62   orig.SetCallback(orig_callback, orig_callback_baton_sp, orig_is_sync);
  63
  64   return ret_val;
  65 }
  66
  67 // Destructor
  68 WatchpointOptions::~WatchpointOptions() = default;
  69
  70 // Callbacks
  71 void WatchpointOptions::SetCallback(WatchpointHitCallback callback,
  72                                     const BatonSP &callback_baton_sp,
  73                                     bool callback_is_synchronous) {
  74   m_callback_is_synchronous = callback_is_synchronous;
  75   m_callback = callback;
  76   m_callback_baton_sp = callback_baton_sp;
  77 }
  78
  79 void WatchpointOptions::ClearCallback() {
  80   m_callback = WatchpointOptions::NullCallback;
  81   m_callback_is_synchronous = false;
  82   m_callback_baton_sp.reset();
  83 }
  84
  85 Baton *WatchpointOptions::GetBaton() { return m_callback_baton_sp.get(); }
  86
  87 const Baton *WatchpointOptions::GetBaton() const {
  88   return m_callback_baton_sp.get();
  89 }
  90
  91 bool WatchpointOptions::InvokeCallback(StoppointCallbackContext *context,
  92                                        lldb::user_id_t watch_id) {
  93   if (m_callback && context->is_synchronous == IsCallbackSynchronous()) {
  94     return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
  95                                           : nullptr,
  96                       context, watch_id);
  97   } else
  98     return true;
  99 }
 100
 101 bool WatchpointOptions::HasCallback() {
 102   return m_callback != WatchpointOptions::NullCallback;
 103 }
 104
 105 const ThreadSpec *WatchpointOptions::GetThreadSpecNoCreate() const {
 106   return m_thread_spec_up.get();
 107 }
 108
 109 ThreadSpec *WatchpointOptions::GetThreadSpec() {
 110   if (m_thread_spec_up == nullptr)
 111     m_thread_spec_up.reset(new ThreadSpec());
 112
 113   return m_thread_spec_up.get();
 114 }
 115
 116 void WatchpointOptions::SetThreadID(lldb::tid_t thread_id) {
 117   GetThreadSpec()->SetTID(thread_id);
 118 }
 119
 120 void WatchpointOptions::GetCallbackDescription(
 121     Stream *s, lldb::DescriptionLevel level) const {
 122   if (m_callback_baton_sp.get()) {
 123     s->EOL();
 124     m_callback_baton_sp->GetDescription(s, level);
 125   }
 126 }
 127
 128 void WatchpointOptions::GetDescription(Stream *s,
 129                                        lldb::DescriptionLevel level) const {
 130   // Figure out if there are any options not at their default value, and only
 131   // print anything if there are:
 132
 133   if ((GetThreadSpecNoCreate() != nullptr &&
 134        GetThreadSpecNoCreate()->HasSpecification())) {
 135     if (level == lldb::eDescriptionLevelVerbose) {
 136       s->EOL();
 137       s->IndentMore();
 138       s->Indent();
 139       s->PutCString("Watchpoint Options:\n");
 140       s->IndentMore();
 141       s->Indent();
 142     } else
 143       s->PutCString(" Options: ");
 144
 145     if (m_thread_spec_up)
 146       m_thread_spec_up->GetDescription(s, level);
 147     else if (level == eDescriptionLevelBrief)
 148       s->PutCString("thread spec: no ");
 149     if (level == lldb::eDescriptionLevelFull) {
 150       s->IndentLess();
 151       s->IndentMore();
 152     }
 153   }
 154
 155   GetCallbackDescription(s, level);
 156 }
 157
 158 void WatchpointOptions::CommandBaton::GetDescription(
 159     Stream *s, lldb::DescriptionLevel level) const {
 160   const CommandData *data = getItem();
 161
 162   if (level == eDescriptionLevelBrief) {
 163     s->Printf(", commands = %s",
 164               (data && data->user_source.GetSize() > 0) ? "yes" : "no");
 165     return;
 166   }
 167
 168   s->IndentMore();
 169   s->Indent("watchpoint commands:\n");
 170
 171   s->IndentMore();
 172   if (data && data->user_source.GetSize() > 0) {
 173     const size_t num_strings = data->user_source.GetSize();
 174     for (size_t i = 0; i < num_strings; ++i) {
 175       s->Indent(data->user_source.GetStringAtIndex(i));
 176       s->EOL();
 177     }
 178   } else {
 179     s->PutCString("No commands.\n");
 180   }
 181   s->IndentLess();
 182   s->IndentLess();
 183 }