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