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