source/Breakpoint/WatchpointOptions.cpp

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