1//===-- Watchpoint.cpp ----------------------------------------------------===//
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/Breakpoint/WatchpointResource.h"
13#include "lldb/Core/Value.h"
14#include "lldb/Core/ValueObject.h"
15#include "lldb/Core/ValueObjectMemory.h"
16#include "lldb/DataFormatters/DumpValueObjectOptions.h"
17#include "lldb/Expression/UserExpression.h"
18#include "lldb/Symbol/TypeSystem.h"
19#include "lldb/Target/Process.h"
20#include "lldb/Target/Target.h"
21#include "lldb/Target/ThreadSpec.h"
22#include "lldb/Utility/LLDBLog.h"
23#include "lldb/Utility/Log.h"
24#include "lldb/Utility/Stream.h"
25
26using namespace lldb;
27using namespace lldb_private;
28
29Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
30                       const CompilerType *type, bool hardware)
31    : StoppointSite(0, addr, size, hardware), m_target(target),
32      m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
33      m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
34      m_watch_write(0), m_watch_modify(0), m_ignore_count(0),
35      m_being_created(true) {
36
37  if (type && type->IsValid())
38    m_type = *type;
39  else {
40    // If we don't have a known type, then we force it to unsigned int of the
41    // right size.
42    auto type_system_or_err =
43        target.GetScratchTypeSystemForLanguage(eLanguageTypeC);
44    if (auto err = type_system_or_err.takeError()) {
45      LLDB_LOG_ERROR(GetLog(LLDBLog::Watchpoints), std::move(err),
46                     "Failed to set type: {0}");
47    } else {
48      if (auto ts = *type_system_or_err)
49        m_type =
50            ts->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size);
51      else
52        LLDB_LOG_ERROR(GetLog(LLDBLog::Watchpoints), std::move(err),
53                       "Failed to set type: Typesystem is no longer live: {0}");
54    }
55  }
56
57  // Set the initial value of the watched variable:
58  if (m_target.GetProcessSP()) {
59    ExecutionContext exe_ctx;
60    m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
61    CaptureWatchedValue(exe_ctx);
62  }
63  m_being_created = false;
64}
65
66Watchpoint::~Watchpoint() = default;
67
68// This function is used when "baton" doesn't need to be freed
69void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton,
70                             bool is_synchronous) {
71  // The default "Baton" class will keep a copy of "baton" and won't free or
72  // delete it when it goes out of scope.
73  m_options.SetCallback(callback, std::make_shared<UntypedBaton>(baton),
74                        is_synchronous);
75
76  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
77}
78
79// This function is used when a baton needs to be freed and therefore is
80// contained in a "Baton" subclass.
81void Watchpoint::SetCallback(WatchpointHitCallback callback,
82                             const BatonSP &callback_baton_sp,
83                             bool is_synchronous) {
84  m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
85  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
86}
87
88bool Watchpoint::SetupVariableWatchpointDisabler(StackFrameSP frame_sp) const {
89  if (!frame_sp)
90    return false;
91
92  ThreadSP thread_sp = frame_sp->GetThread();
93  if (!thread_sp)
94    return false;
95
96  uint32_t return_frame_index =
97      thread_sp->GetSelectedFrameIndex(DoNoSelectMostRelevantFrame) + 1;
98  if (return_frame_index >= LLDB_INVALID_FRAME_ID)
99    return false;
100
101  StackFrameSP return_frame_sp(
102      thread_sp->GetStackFrameAtIndex(return_frame_index));
103  if (!return_frame_sp)
104    return false;
105
106  ExecutionContext exe_ctx(return_frame_sp);
107  TargetSP target_sp = exe_ctx.GetTargetSP();
108  if (!target_sp)
109    return false;
110
111  Address return_address(return_frame_sp->GetFrameCodeAddress());
112  lldb::addr_t return_addr = return_address.GetLoadAddress(target_sp.get());
113  if (return_addr == LLDB_INVALID_ADDRESS)
114    return false;
115
116  BreakpointSP bp_sp = target_sp->CreateBreakpoint(
117      return_addr, /*internal=*/true, /*request_hardware=*/false);
118  if (!bp_sp || !bp_sp->HasResolvedLocations())
119    return false;
120
121  auto wvc_up = std::make_unique<WatchpointVariableContext>(GetID(), exe_ctx);
122  auto baton_sp = std::make_shared<WatchpointVariableBaton>(std::move(wvc_up));
123  bp_sp->SetCallback(VariableWatchpointDisabler, baton_sp);
124  bp_sp->SetOneShot(true);
125  bp_sp->SetBreakpointKind("variable watchpoint disabler");
126  return true;
127}
128
129bool Watchpoint::VariableWatchpointDisabler(void *baton,
130                                            StoppointCallbackContext *context,
131                                            user_id_t break_id,
132                                            user_id_t break_loc_id) {
133  assert(baton && "null baton");
134  if (!baton || !context)
135    return false;
136
137  Log *log = GetLog(LLDBLog::Watchpoints);
138
139  WatchpointVariableContext *wvc =
140      static_cast<WatchpointVariableContext *>(baton);
141
142  LLDB_LOGF(log, "called by breakpoint %" PRIu64 ".%" PRIu64, break_id,
143            break_loc_id);
144
145  if (wvc->watch_id == LLDB_INVALID_WATCH_ID)
146    return false;
147
148  TargetSP target_sp = context->exe_ctx_ref.GetTargetSP();
149  if (!target_sp)
150    return false;
151
152  ProcessSP process_sp = target_sp->GetProcessSP();
153  if (!process_sp)
154    return false;
155
156  WatchpointSP watch_sp =
157      target_sp->GetWatchpointList().FindByID(wvc->watch_id);
158  if (!watch_sp)
159    return false;
160
161  if (wvc->exe_ctx == context->exe_ctx_ref) {
162    LLDB_LOGF(log,
163              "callback for watchpoint %" PRId32
164              " matched internal breakpoint execution context",
165              watch_sp->GetID());
166    process_sp->DisableWatchpoint(watch_sp);
167    return false;
168  }
169  LLDB_LOGF(log,
170            "callback for watchpoint %" PRId32
171            " didn't match internal breakpoint execution context",
172            watch_sp->GetID());
173  return false;
174}
175
176void Watchpoint::ClearCallback() {
177  m_options.ClearCallback();
178  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
179}
180
181void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
182
183std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; }
184
185void Watchpoint::SetWatchSpec(const std::string &str) {
186  m_watch_spec_str = str;
187}
188
189bool Watchpoint::IsHardware() const {
190  lldbassert(m_is_hardware || !HardwareRequired());
191  return m_is_hardware;
192}
193
194bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
195
196void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; }
197
198bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) {
199  ConstString g_watch_name("$__lldb__watch_value");
200  m_old_value_sp = m_new_value_sp;
201  Address watch_address(GetLoadAddress());
202  if (!m_type.IsValid()) {
203    // Don't know how to report new & old values, since we couldn't make a
204    // scalar type for this watchpoint. This works around an assert in
205    // ValueObjectMemory::Create.
206    // FIXME: This should not happen, but if it does in some case we care about,
207    // we can go grab the value raw and print it as unsigned.
208    return false;
209  }
210  m_new_value_sp = ValueObjectMemory::Create(
211      exe_ctx.GetBestExecutionContextScope(), g_watch_name.GetStringRef(),
212      watch_address, m_type);
213  m_new_value_sp = m_new_value_sp->CreateConstantValue(g_watch_name);
214  return (m_new_value_sp && m_new_value_sp->GetError().Success());
215}
216
217bool Watchpoint::WatchedValueReportable(const ExecutionContext &exe_ctx) {
218  if (!m_watch_modify || m_watch_read)
219    return true;
220  if (!m_type.IsValid())
221    return true;
222
223  ConstString g_watch_name("$__lldb__watch_value");
224  Address watch_address(GetLoadAddress());
225  ValueObjectSP newest_valueobj_sp = ValueObjectMemory::Create(
226      exe_ctx.GetBestExecutionContextScope(), g_watch_name.GetStringRef(),
227      watch_address, m_type);
228  newest_valueobj_sp = newest_valueobj_sp->CreateConstantValue(g_watch_name);
229  Status error;
230
231  DataExtractor new_data;
232  DataExtractor old_data;
233
234  newest_valueobj_sp->GetData(new_data, error);
235  if (error.Fail())
236    return true;
237  m_new_value_sp->GetData(old_data, error);
238  if (error.Fail())
239    return true;
240
241  if (new_data.GetByteSize() != old_data.GetByteSize() ||
242      new_data.GetByteSize() == 0)
243    return true;
244
245  if (memcmp(new_data.GetDataStart(), old_data.GetDataStart(),
246             old_data.GetByteSize()) == 0)
247    return false; // Value has not changed, user requested modify watchpoint
248
249  return true;
250}
251
252// RETURNS - true if we should stop at this breakpoint, false if we
253// should continue.
254
255bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
256  m_hit_counter.Increment();
257
258  return IsEnabled();
259}
260
261void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
262  DumpWithLevel(s, level);
263}
264
265void Watchpoint::Dump(Stream *s) const {
266  DumpWithLevel(s, lldb::eDescriptionLevelBrief);
267}
268
269// If prefix is nullptr, we display the watch id and ignore the prefix
270// altogether.
271bool Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
272  bool printed_anything = false;
273
274  // For read watchpoints, don't display any before/after value changes.
275  if (m_watch_read && !m_watch_modify && !m_watch_write)
276    return printed_anything;
277
278  s->Printf("\n");
279  s->Printf("Watchpoint %u hit:\n", GetID());
280
281  StreamString values_ss;
282  if (prefix)
283    values_ss.Indent(prefix);
284
285  if (m_old_value_sp) {
286    if (auto *old_value_cstr = m_old_value_sp->GetValueAsCString()) {
287      values_ss.Printf("old value: %s", old_value_cstr);
288    } else {
289      if (auto *old_summary_cstr = m_old_value_sp->GetSummaryAsCString())
290        values_ss.Printf("old value: %s", old_summary_cstr);
291      else {
292        StreamString strm;
293        DumpValueObjectOptions options;
294        options.SetUseDynamicType(eNoDynamicValues)
295            .SetHideRootType(true)
296            .SetHideRootName(true)
297            .SetHideName(true);
298        m_old_value_sp->Dump(strm, options);
299        if (strm.GetData())
300          values_ss.Printf("old value: %s", strm.GetData());
301      }
302    }
303  }
304
305  if (m_new_value_sp) {
306    if (values_ss.GetSize())
307      values_ss.Printf("\n");
308
309    if (auto *new_value_cstr = m_new_value_sp->GetValueAsCString())
310      values_ss.Printf("new value: %s", new_value_cstr);
311    else {
312      if (auto *new_summary_cstr = m_new_value_sp->GetSummaryAsCString())
313        values_ss.Printf("new value: %s", new_summary_cstr);
314      else {
315        StreamString strm;
316        DumpValueObjectOptions options;
317        options.SetUseDynamicType(eNoDynamicValues)
318            .SetHideRootType(true)
319            .SetHideRootName(true)
320            .SetHideName(true);
321        m_new_value_sp->Dump(strm, options);
322        if (strm.GetData())
323          values_ss.Printf("new value: %s", strm.GetData());
324      }
325    }
326  }
327
328  if (values_ss.GetSize()) {
329    s->Printf("%s", values_ss.GetData());
330    printed_anything = true;
331  }
332
333  return printed_anything;
334}
335
336void Watchpoint::DumpWithLevel(Stream *s,
337                               lldb::DescriptionLevel description_level) const {
338  if (s == nullptr)
339    return;
340
341  assert(description_level >= lldb::eDescriptionLevelBrief &&
342         description_level <= lldb::eDescriptionLevelVerbose);
343
344  s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
345            " size = %u state = %s type = %s%s%s",
346            GetID(), GetLoadAddress(), m_byte_size,
347            IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
348            m_watch_write ? "w" : "", m_watch_modify ? "m" : "");
349
350  if (description_level >= lldb::eDescriptionLevelFull) {
351    if (!m_decl_str.empty())
352      s->Printf("\n    declare @ '%s'", m_decl_str.c_str());
353    if (!m_watch_spec_str.empty())
354      s->Printf("\n    watchpoint spec = '%s'", m_watch_spec_str.c_str());
355
356    // Dump the snapshots we have taken.
357    DumpSnapshots(s, "    ");
358
359    if (GetConditionText())
360      s->Printf("\n    condition = '%s'", GetConditionText());
361    m_options.GetCallbackDescription(s, description_level);
362  }
363
364  if (description_level >= lldb::eDescriptionLevelVerbose) {
365    s->Printf("\n    hit_count = %-4u  ignore_count = %-4u", GetHitCount(),
366              GetIgnoreCount());
367  }
368}
369
370bool Watchpoint::IsEnabled() const { return m_enabled; }
371
372// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
373// temporarily disable the watchpoint in order to perform possible watchpoint
374// actions without triggering further watchpoint events. After the temporary
375// disabled watchpoint is enabled, we then turn off the ephemeral mode.
376
377void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
378
379void Watchpoint::TurnOffEphemeralMode() {
380  m_is_ephemeral = false;
381  // Leaving ephemeral mode, reset the m_disabled_count!
382  m_disabled_count = 0;
383}
384
385bool Watchpoint::IsDisabledDuringEphemeralMode() {
386  return m_disabled_count > 1 && m_is_ephemeral;
387}
388
389void Watchpoint::SetEnabled(bool enabled, bool notify) {
390  if (!enabled) {
391    if (m_is_ephemeral)
392      ++m_disabled_count;
393
394    // Don't clear the snapshots for now.
395    // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
396    // performing watchpoint actions.
397  }
398  bool changed = enabled != m_enabled;
399  m_enabled = enabled;
400  if (notify && !m_is_ephemeral && changed)
401    SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
402                                       : eWatchpointEventTypeDisabled);
403}
404
405void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
406  int old_watch_read = m_watch_read;
407  int old_watch_write = m_watch_write;
408  int old_watch_modify = m_watch_modify;
409  m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
410  m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
411  m_watch_modify = (type & LLDB_WATCH_TYPE_MODIFY) != 0;
412  if (notify &&
413      (old_watch_read != m_watch_read || old_watch_write != m_watch_write ||
414       old_watch_modify != m_watch_modify))
415    SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
416}
417
418bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
419
420bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
421
422bool Watchpoint::WatchpointModify() const { return m_watch_modify != 0; }
423
424uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
425
426void Watchpoint::SetIgnoreCount(uint32_t n) {
427  bool changed = m_ignore_count != n;
428  m_ignore_count = n;
429  if (changed)
430    SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
431}
432
433bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) {
434  return m_options.InvokeCallback(context, GetID());
435}
436
437void Watchpoint::SetCondition(const char *condition) {
438  if (condition == nullptr || condition[0] == '\0') {
439    if (m_condition_up)
440      m_condition_up.reset();
441  } else {
442    // Pass nullptr for expr_prefix (no translation-unit level definitions).
443    Status error;
444    m_condition_up.reset(m_target.GetUserExpressionForLanguage(
445        condition, llvm::StringRef(), lldb::eLanguageTypeUnknown,
446        UserExpression::eResultTypeAny, EvaluateExpressionOptions(), nullptr,
447        error));
448    if (error.Fail()) {
449      // FIXME: Log something...
450      m_condition_up.reset();
451    }
452  }
453  SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
454}
455
456const char *Watchpoint::GetConditionText() const {
457  if (m_condition_up)
458    return m_condition_up->GetUserText();
459  else
460    return nullptr;
461}
462
463void Watchpoint::SendWatchpointChangedEvent(
464    lldb::WatchpointEventType eventKind) {
465  if (!m_being_created && GetTarget().EventTypeHasListeners(
466                              Target::eBroadcastBitWatchpointChanged)) {
467    auto data_sp =
468        std::make_shared<WatchpointEventData>(eventKind, shared_from_this());
469    GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data_sp);
470  }
471}
472
473Watchpoint::WatchpointEventData::WatchpointEventData(
474    WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
475    : m_watchpoint_event(sub_type), m_new_watchpoint_sp(new_watchpoint_sp) {}
476
477Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
478
479llvm::StringRef Watchpoint::WatchpointEventData::GetFlavorString() {
480  return "Watchpoint::WatchpointEventData";
481}
482
483llvm::StringRef Watchpoint::WatchpointEventData::GetFlavor() const {
484  return WatchpointEventData::GetFlavorString();
485}
486
487WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
488  return m_new_watchpoint_sp;
489}
490
491WatchpointEventType
492Watchpoint::WatchpointEventData::GetWatchpointEventType() const {
493  return m_watchpoint_event;
494}
495
496void Watchpoint::WatchpointEventData::Dump(Stream *s) const {}
497
498const Watchpoint::WatchpointEventData *
499Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) {
500  if (event) {
501    const EventData *event_data = event->GetData();
502    if (event_data &&
503        event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
504      return static_cast<const WatchpointEventData *>(event->GetData());
505  }
506  return nullptr;
507}
508
509WatchpointEventType
510Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
511    const EventSP &event_sp) {
512  const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
513
514  if (data == nullptr)
515    return eWatchpointEventTypeInvalidType;
516  else
517    return data->GetWatchpointEventType();
518}
519
520WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
521    const EventSP &event_sp) {
522  WatchpointSP wp_sp;
523
524  const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
525  if (data)
526    wp_sp = data->m_new_watchpoint_sp;
527
528  return wp_sp;
529}
530