Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Breakpoint/Watchpoint.h
Line
Count
Source (jump to first uncovered line)
1
//===-- Watchpoint.h --------------------------------------------*- 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
#ifndef LLDB_BREAKPOINT_WATCHPOINT_H
10
#define LLDB_BREAKPOINT_WATCHPOINT_H
11
12
#include <memory>
13
#include <string>
14
15
#include "lldb/Breakpoint/StoppointSite.h"
16
#include "lldb/Breakpoint/WatchpointOptions.h"
17
#include "lldb/Symbol/CompilerType.h"
18
#include "lldb/Target/Target.h"
19
#include "lldb/Utility/UserID.h"
20
#include "lldb/lldb-private.h"
21
22
namespace lldb_private {
23
24
class Watchpoint : public std::enable_shared_from_this<Watchpoint>,
25
                   public StoppointSite {
26
public:
27
  class WatchpointEventData : public EventData {
28
  public:
29
    WatchpointEventData(lldb::WatchpointEventType sub_type,
30
                        const lldb::WatchpointSP &new_watchpoint_sp);
31
32
    ~WatchpointEventData() override;
33
34
    static ConstString GetFlavorString();
35
36
    ConstString GetFlavor() const override;
37
38
    lldb::WatchpointEventType GetWatchpointEventType() const;
39
40
    lldb::WatchpointSP &GetWatchpoint();
41
42
    void Dump(Stream *s) const override;
43
44
    static lldb::WatchpointEventType
45
    GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp);
46
47
    static lldb::WatchpointSP
48
    GetWatchpointFromEvent(const lldb::EventSP &event_sp);
49
50
    static const WatchpointEventData *
51
    GetEventDataFromEvent(const Event *event_sp);
52
53
  private:
54
    lldb::WatchpointEventType m_watchpoint_event;
55
    lldb::WatchpointSP m_new_watchpoint_sp;
56
57
    WatchpointEventData(const WatchpointEventData &) = delete;
58
    const WatchpointEventData &operator=(const WatchpointEventData &) = delete;
59
  };
60
61
  Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
62
             const CompilerType *type, bool hardware = true);
63
64
  ~Watchpoint() override;
65
66
  void IncrementFalseAlarmsAndReviseHitCount();
67
68
  bool IsEnabled() const;
69
70
  // This doesn't really enable/disable the watchpoint.   It is currently just
71
  // for use in the Process plugin's {Enable,Disable}Watchpoint, which should
72
  // be used instead.
73
  void SetEnabled(bool enabled, bool notify = true);
74
75
  bool IsHardware() const override;
76
77
  bool ShouldStop(StoppointCallbackContext *context) override;
78
79
  bool WatchpointRead() const;
80
  bool WatchpointWrite() const;
81
  uint32_t GetIgnoreCount() const;
82
  void SetIgnoreCount(uint32_t n);
83
  void SetWatchpointType(uint32_t type, bool notify = true);
84
  void SetDeclInfo(const std::string &str);
85
  std::string GetWatchSpec();
86
  void SetWatchSpec(const std::string &str);
87
88
  // Snapshot management interface.
89
  bool IsWatchVariable() const;
90
  void SetWatchVariable(bool val);
91
  bool CaptureWatchedValue(const ExecutionContext &exe_ctx);
92
93
  void GetDescription(Stream *s, lldb::DescriptionLevel level);
94
  void Dump(Stream *s) const override;
95
  void DumpSnapshots(Stream *s, const char *prefix = nullptr) const;
96
  void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const;
97
314
  Target &GetTarget() { return m_target; }
98
0
  const Status &GetError() { return m_error; }
99
100
  /// Returns the WatchpointOptions structure set for this watchpoint.
101
  ///
102
  /// \return
103
  ///     A pointer to this watchpoint's WatchpointOptions.
104
8
  WatchpointOptions *GetOptions() { return &m_options; }
105
106
  /// Set the callback action invoked when the watchpoint is hit.
107
  ///
108
  /// \param[in] callback
109
  ///    The method that will get called when the watchpoint is hit.
110
  /// \param[in] callback_baton
111
  ///    A void * pointer that will get passed back to the callback function.
112
  /// \param[in] is_synchronous
113
  ///    If \b true the callback will be run on the private event thread
114
  ///    before the stop event gets reported.  If false, the callback will get
115
  ///    handled on the public event thread after the stop has been posted.
116
  void SetCallback(WatchpointHitCallback callback, void *callback_baton,
117
                   bool is_synchronous = false);
118
119
  void SetCallback(WatchpointHitCallback callback,
120
                   const lldb::BatonSP &callback_baton_sp,
121
                   bool is_synchronous = false);
122
123
  void ClearCallback();
124
125
  /// Invoke the callback action when the watchpoint is hit.
126
  ///
127
  /// \param[in] context
128
  ///     Described the watchpoint event.
129
  ///
130
  /// \return
131
  ///     \b true if the target should stop at this watchpoint and \b false not.
132
  bool InvokeCallback(StoppointCallbackContext *context);
133
134
  // Condition
135
  /// Set the watchpoint's condition.
136
  ///
137
  /// \param[in] condition
138
  ///    The condition expression to evaluate when the watchpoint is hit.
139
  ///    Pass in nullptr to clear the condition.
140
  void SetCondition(const char *condition);
141
142
  /// Return a pointer to the text of the condition expression.
143
  ///
144
  /// \return
145
  ///    A pointer to the condition expression text, or nullptr if no
146
  //     condition has been set.
147
  const char *GetConditionText() const;
148
149
  void TurnOnEphemeralMode();
150
151
  void TurnOffEphemeralMode();
152
153
  bool IsDisabledDuringEphemeralMode();
154
155
0
  const CompilerType &GetCompilerType() { return m_type; }
156
157
private:
158
  friend class Target;
159
  friend class WatchpointList;
160
161
53
  void ResetHistoricValues() {
162
53
    m_old_value_sp.reset();
163
53
    m_new_value_sp.reset();
164
53
  }
165
166
  Target &m_target;
167
  bool m_enabled;           // Is this watchpoint enabled
168
  bool m_is_hardware;       // Is this a hardware watchpoint
169
  bool m_is_watch_variable; // True if set via 'watchpoint set variable'.
170
  bool m_is_ephemeral;      // True if the watchpoint is in the ephemeral mode,
171
                            // meaning that it is
172
  // undergoing a pair of temporary disable/enable actions to avoid recursively
173
  // triggering further watchpoint events.
174
  uint32_t m_disabled_count; // Keep track of the count that the watchpoint is
175
                             // disabled while in ephemeral mode.
176
  // At the end of the ephemeral mode when the watchpoint is to be enabled
177
  // again, we check the count, if it is more than 1, it means the user-
178
  // supplied actions actually want the watchpoint to be disabled!
179
  uint32_t m_watch_read : 1, // 1 if we stop when the watched data is read from
180
      m_watch_write : 1,     // 1 if we stop when the watched data is written to
181
      m_watch_was_read : 1, // Set to 1 when watchpoint is hit for a read access
182
      m_watch_was_written : 1;  // Set to 1 when watchpoint is hit for a write
183
                                // access
184
  uint32_t m_ignore_count;      // Number of times to ignore this watchpoint
185
  uint32_t m_false_alarms;      // Number of false alarms.
186
  std::string m_decl_str;       // Declaration information, if any.
187
  std::string m_watch_spec_str; // Spec for the watchpoint.
188
  lldb::ValueObjectSP m_old_value_sp;
189
  lldb::ValueObjectSP m_new_value_sp;
190
  CompilerType m_type;
191
  Status m_error; // An error object describing errors associated with this
192
                  // watchpoint.
193
  WatchpointOptions
194
      m_options; // Settable watchpoint options, which is a delegate to handle
195
                 // the callback machinery.
196
  bool m_being_created;
197
198
  std::unique_ptr<UserExpression> m_condition_up; // The condition to test.
199
200
71
  void SetID(lldb::watch_id_t id) { m_id = id; }
201
202
  void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind);
203
204
  void SendWatchpointChangedEvent(WatchpointEventData *data);
205
206
  Watchpoint(const Watchpoint &) = delete;
207
  const Watchpoint &operator=(const Watchpoint &) = delete;
208
};
209
210
} // namespace lldb_private
211
212
#endif // LLDB_BREAKPOINT_WATCHPOINT_H