1 //===-- Watchpoint.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/Watchpoint.h"
10 
11 #include "lldb/Breakpoint/StoppointCallbackContext.h"
12 #include "lldb/Core/Value.h"
13 #include "lldb/Core/ValueObject.h"
14 #include "lldb/Core/ValueObjectMemory.h"
15 #include "lldb/Expression/UserExpression.h"
16 #include "lldb/Symbol/ClangASTContext.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/Target.h"
19 #include "lldb/Target/ThreadSpec.h"
20 #include "lldb/Utility/Stream.h"
21 
22 using namespace lldb;
23 using namespace lldb_private;
24 
25 Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
26                        const CompilerType *type, bool hardware)
27     : StoppointLocation(0, addr, size, hardware), m_target(target),
28       m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
29       m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
30       m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
31       m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
32       m_type(), m_error(), m_options(), m_being_created(true) {
33   if (type && type->IsValid())
34     m_type = *type;
35   else {
36     // If we don't have a known type, then we force it to unsigned int of the
37     // right size.
38     ClangASTContext *ast_context = target.GetScratchClangASTContext();
39     m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
40                                                               8 * size);
41   }
42 
43   // Set the initial value of the watched variable:
44   if (m_target.GetProcessSP()) {
45     ExecutionContext exe_ctx;
46     m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
47     CaptureWatchedValue(exe_ctx);
48   }
49   m_being_created = false;
50 }
51 
52 Watchpoint::~Watchpoint() = default;
53 
54 // This function is used when "baton" doesn't need to be freed
55 void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton,
56                              bool is_synchronous) {
57   // The default "Baton" class will keep a copy of "baton" and won't free or
58   // delete it when it goes goes out of scope.
59   m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton),
60                         is_synchronous);
61 
62   SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
63 }
64 
65 // This function is used when a baton needs to be freed and therefore is
66 // contained in a "Baton" subclass.
67 void Watchpoint::SetCallback(WatchpointHitCallback callback,
68                              const BatonSP &callback_baton_sp,
69                              bool is_synchronous) {
70   m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
71   SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
72 }
73 
74 void Watchpoint::ClearCallback() {
75   m_options.ClearCallback();
76   SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
77 }
78 
79 void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
80 
81 std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; }
82 
83 void Watchpoint::SetWatchSpec(const std::string &str) {
84   m_watch_spec_str = str;
85 }
86 
87 // Override default impl of StoppointLocation::IsHardware() since m_is_hardware
88 // member field is more accurate.
89 bool Watchpoint::IsHardware() const { return m_is_hardware; }
90 
91 bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
92 
93 void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; }
94 
95 bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) {
96   ConstString watch_name("$__lldb__watch_value");
97   m_old_value_sp = m_new_value_sp;
98   Address watch_address(GetLoadAddress());
99   if (!m_type.IsValid()) {
100     // Don't know how to report new & old values, since we couldn't make a
101     // scalar type for this watchpoint. This works around an assert in
102     // ValueObjectMemory::Create.
103     // FIXME: This should not happen, but if it does in some case we care about,
104     // we can go grab the value raw and print it as unsigned.
105     return false;
106   }
107   m_new_value_sp = ValueObjectMemory::Create(
108       exe_ctx.GetBestExecutionContextScope(), watch_name.GetStringRef(),
109       watch_address, m_type);
110   m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
111   return (m_new_value_sp && m_new_value_sp->GetError().Success());
112 }
113 
114 void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() {
115   ++m_false_alarms;
116   if (m_false_alarms) {
117     if (m_hit_count >= m_false_alarms) {
118       m_hit_count -= m_false_alarms;
119       m_false_alarms = 0;
120     } else {
121       m_false_alarms -= m_hit_count;
122       m_hit_count = 0;
123     }
124   }
125 }
126 
127 // RETURNS - true if we should stop at this breakpoint, false if we
128 // should continue.
129 
130 bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
131   IncrementHitCount();
132 
133   return IsEnabled();
134 }
135 
136 void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
137   DumpWithLevel(s, level);
138 }
139 
140 void Watchpoint::Dump(Stream *s) const {
141   DumpWithLevel(s, lldb::eDescriptionLevelBrief);
142 }
143 
144 // If prefix is nullptr, we display the watch id and ignore the prefix
145 // altogether.
146 void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
147   if (!prefix) {
148     s->Printf("\nWatchpoint %u hit:", GetID());
149     prefix = "";
150   }
151 
152   if (m_old_value_sp) {
153     const char *old_value_cstr = m_old_value_sp->GetValueAsCString();
154     if (old_value_cstr && old_value_cstr[0])
155       s->Printf("\n%sold value: %s", prefix, old_value_cstr);
156     else {
157       const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString();
158       if (old_summary_cstr && old_summary_cstr[0])
159         s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
160     }
161   }
162 
163   if (m_new_value_sp) {
164     const char *new_value_cstr = m_new_value_sp->GetValueAsCString();
165     if (new_value_cstr && new_value_cstr[0])
166       s->Printf("\n%snew value: %s", prefix, new_value_cstr);
167     else {
168       const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString();
169       if (new_summary_cstr && new_summary_cstr[0])
170         s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
171     }
172   }
173 }
174 
175 void Watchpoint::DumpWithLevel(Stream *s,
176                                lldb::DescriptionLevel description_level) const {
177   if (s == nullptr)
178     return;
179 
180   assert(description_level >= lldb::eDescriptionLevelBrief &&
181          description_level <= lldb::eDescriptionLevelVerbose);
182 
183   s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
184             " size = %u state = %s type = %s%s",
185             GetID(), GetLoadAddress(), m_byte_size,
186             IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
187             m_watch_write ? "w" : "");
188 
189   if (description_level >= lldb::eDescriptionLevelFull) {
190     if (!m_decl_str.empty())
191       s->Printf("\n    declare @ '%s'", m_decl_str.c_str());
192     if (!m_watch_spec_str.empty())
193       s->Printf("\n    watchpoint spec = '%s'", m_watch_spec_str.c_str());
194 
195     // Dump the snapshots we have taken.
196     DumpSnapshots(s, "    ");
197 
198     if (GetConditionText())
199       s->Printf("\n    condition = '%s'", GetConditionText());
200     m_options.GetCallbackDescription(s, description_level);
201   }
202 
203   if (description_level >= lldb::eDescriptionLevelVerbose) {
204     s->Printf("\n    hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
205               GetHardwareIndex(), GetHitCount(), GetIgnoreCount());
206   }
207 }
208 
209 bool Watchpoint::IsEnabled() const { return m_enabled; }
210 
211 // Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
212 // temporarily disable the watchpoint in order to perform possible watchpoint
213 // actions without triggering further watchpoint events. After the temporary
214 // disabled watchpoint is enabled, we then turn off the ephemeral mode.
215 
216 void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
217 
218 void Watchpoint::TurnOffEphemeralMode() {
219   m_is_ephemeral = false;
220   // Leaving ephemeral mode, reset the m_disabled_count!
221   m_disabled_count = 0;
222 }
223 
224 bool Watchpoint::IsDisabledDuringEphemeralMode() {
225   return m_disabled_count > 1 && m_is_ephemeral;
226 }
227 
228 void Watchpoint::SetEnabled(bool enabled, bool notify) {
229   if (!enabled) {
230     if (!m_is_ephemeral)
231       SetHardwareIndex(LLDB_INVALID_INDEX32);
232     else
233       ++m_disabled_count;
234 
235     // Don't clear the snapshots for now.
236     // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
237     // performing watchpoint actions.
238   }
239   bool changed = enabled != m_enabled;
240   m_enabled = enabled;
241   if (notify && !m_is_ephemeral && changed)
242     SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
243                                        : eWatchpointEventTypeDisabled);
244 }
245 
246 void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
247   int old_watch_read = m_watch_read;
248   int old_watch_write = m_watch_write;
249   m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
250   m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
251   if (notify &&
252       (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
253     SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
254 }
255 
256 bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
257 
258 bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
259 
260 uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
261 
262 void Watchpoint::SetIgnoreCount(uint32_t n) {
263   bool changed = m_ignore_count != n;
264   m_ignore_count = n;
265   if (changed)
266     SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
267 }
268 
269 bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) {
270   return m_options.InvokeCallback(context, GetID());
271 }
272 
273 void Watchpoint::SetCondition(const char *condition) {
274   if (condition == nullptr || condition[0] == '\0') {
275     if (m_condition_ap.get())
276       m_condition_ap.reset();
277   } else {
278     // Pass nullptr for expr_prefix (no translation-unit level definitions).
279     Status error;
280     m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
281         condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
282         UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error));
283     if (error.Fail()) {
284       // FIXME: Log something...
285       m_condition_ap.reset();
286     }
287   }
288   SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
289 }
290 
291 const char *Watchpoint::GetConditionText() const {
292   if (m_condition_ap.get())
293     return m_condition_ap->GetUserText();
294   else
295     return nullptr;
296 }
297 
298 void Watchpoint::SendWatchpointChangedEvent(
299     lldb::WatchpointEventType eventKind) {
300   if (!m_being_created &&
301       GetTarget().EventTypeHasListeners(
302           Target::eBroadcastBitWatchpointChanged)) {
303     WatchpointEventData *data =
304         new Watchpoint::WatchpointEventData(eventKind, shared_from_this());
305     GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
306   }
307 }
308 
309 void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) {
310   if (data == nullptr)
311     return;
312 
313   if (!m_being_created &&
314       GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
315     GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
316   else
317     delete data;
318 }
319 
320 Watchpoint::WatchpointEventData::WatchpointEventData(
321     WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
322     : EventData(), m_watchpoint_event(sub_type),
323       m_new_watchpoint_sp(new_watchpoint_sp) {}
324 
325 Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
326 
327 const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() {
328   static ConstString g_flavor("Watchpoint::WatchpointEventData");
329   return g_flavor;
330 }
331 
332 const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const {
333   return WatchpointEventData::GetFlavorString();
334 }
335 
336 WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
337   return m_new_watchpoint_sp;
338 }
339 
340 WatchpointEventType
341 Watchpoint::WatchpointEventData::GetWatchpointEventType() const {
342   return m_watchpoint_event;
343 }
344 
345 void Watchpoint::WatchpointEventData::Dump(Stream *s) const {}
346 
347 const Watchpoint::WatchpointEventData *
348 Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) {
349   if (event) {
350     const EventData *event_data = event->GetData();
351     if (event_data &&
352         event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
353       return static_cast<const WatchpointEventData *>(event->GetData());
354   }
355   return nullptr;
356 }
357 
358 WatchpointEventType
359 Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
360     const EventSP &event_sp) {
361   const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
362 
363   if (data == nullptr)
364     return eWatchpointEventTypeInvalidType;
365   else
366     return data->GetWatchpointEventType();
367 }
368 
369 WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
370     const EventSP &event_sp) {
371   WatchpointSP wp_sp;
372 
373   const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
374   if (data)
375     wp_sp = data->m_new_watchpoint_sp;
376 
377   return wp_sp;
378 }
379