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