Watchpoint.h revision 36da2aa6dc5ad9994b638ed09eb81c44cc05540b 
1//===-- Watchpoint.h --------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef liblldb_Watchpoint_h_
11#define liblldb_Watchpoint_h_
12
13// C Includes
14
15// C++ Includes
16#include <list>
17#include <string>
18
19// Other libraries and framework includes
20
21// Project includes
22#include "lldb/lldb-private.h"
23#include "lldb/Target/Target.h"
24#include "lldb/Core/UserID.h"
25#include "lldb/Breakpoint/WatchpointOptions.h"
26#include "lldb/Breakpoint/StoppointLocation.h"
27
28namespace lldb_private {
29
30class Watchpoint :
31    public STD_ENABLE_SHARED_FROM_THIS(Watchpoint),
32    public StoppointLocation
33{
34public:
35
36    class WatchpointEventData :
37        public EventData
38    {
39    public:
40
41        static const ConstString &
42        GetFlavorString ();
43
44        virtual const ConstString &
45        GetFlavor () const;
46
47        WatchpointEventData (lldb::WatchpointEventType sub_type,
48                             const lldb::WatchpointSP &new_watchpoint_sp);
49
50        virtual
51        ~WatchpointEventData();
52
53        lldb::WatchpointEventType
54        GetWatchpointEventType () const;
55
56        lldb::WatchpointSP &
57        GetWatchpoint ();
58
59        virtual void
60        Dump (Stream *s) const;
61
62        static lldb::WatchpointEventType
63        GetWatchpointEventTypeFromEvent (const lldb::EventSP &event_sp);
64
65        static lldb::WatchpointSP
66        GetWatchpointFromEvent (const lldb::EventSP &event_sp);
67
68        static const WatchpointEventData *
69        GetEventDataFromEvent (const Event *event_sp);
70
71    private:
72
73        lldb::WatchpointEventType m_watchpoint_event;
74        lldb::WatchpointSP m_new_watchpoint_sp;
75
76        DISALLOW_COPY_AND_ASSIGN (WatchpointEventData);
77    };
78
79    Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const ClangASTType *type, bool hardware = true);
80    ~Watchpoint ();
81
82    void
83    IncrementFalseAlarmsAndReviseHitCount();
84
85    bool
86    IsEnabled () const;
87
88    void
89    SetEnabled (bool enabled, bool notify = true);
90
91    virtual bool
92    IsHardware () const;
93
94    virtual bool
95    ShouldStop (StoppointCallbackContext *context);
96
97    bool        WatchpointRead () const;
98    bool        WatchpointWrite () const;
99    uint32_t    GetIgnoreCount () const;
100    void        SetIgnoreCount (uint32_t n);
101    void        SetWatchpointType (uint32_t type, bool notify = true);
102    void        SetDeclInfo (const std::string &str);
103    std::string GetWatchSpec();
104    void        SetWatchSpec (const std::string &str);
105
106    // Snapshot management interface.
107    bool        IsWatchVariable() const;
108    void        SetWatchVariable(bool val);
109    bool        CaptureWatchedValue (const ExecutionContext &exe_ctx);
110
111    void        GetDescription (Stream *s, lldb::DescriptionLevel level);
112    void        Dump (Stream *s) const;
113    void        DumpSnapshots (Stream *s, const char * prefix = NULL) const;
114    void        DumpWithLevel (Stream *s, lldb::DescriptionLevel description_level) const;
115    Target      &GetTarget() { return m_target; }
116    const Error &GetError() { return m_error; }
117
118    //------------------------------------------------------------------
119    /// Returns the WatchpointOptions structure set for this watchpoint.
120    ///
121    /// @return
122    ///     A pointer to this watchpoint's WatchpointOptions.
123    //------------------------------------------------------------------
124    WatchpointOptions *
125    GetOptions () { return &m_options; }
126
127    //------------------------------------------------------------------
128    /// Set the callback action invoked when the watchpoint is hit.
129    ///
130    /// @param[in] callback
131    ///    The method that will get called when the watchpoint is hit.
132    /// @param[in] callback_baton
133    ///    A void * pointer that will get passed back to the callback function.
134    /// @param[in] is_synchronous
135    ///    If \b true the callback will be run on the private event thread
136    ///    before the stop event gets reported.  If false, the callback will get
137    ///    handled on the public event thead after the stop has been posted.
138    ///
139    /// @return
140    ///    \b true if the process should stop when you hit the watchpoint.
141    ///    \b false if it should continue.
142    //------------------------------------------------------------------
143    void
144    SetCallback (WatchpointHitCallback callback,
145                 void *callback_baton,
146                 bool is_synchronous = false);
147
148    void
149    SetCallback (WatchpointHitCallback callback,
150                 const lldb::BatonSP &callback_baton_sp,
151                 bool is_synchronous = false);
152
153    void        ClearCallback();
154
155    //------------------------------------------------------------------
156    /// Invoke the callback action when the watchpoint is hit.
157    ///
158    /// @param[in] context
159    ///     Described the watchpoint event.
160    ///
161    /// @return
162    ///     \b true if the target should stop at this watchpoint and \b false not.
163    //------------------------------------------------------------------
164    bool
165    InvokeCallback (StoppointCallbackContext *context);
166
167    //------------------------------------------------------------------
168    // Condition
169    //------------------------------------------------------------------
170    //------------------------------------------------------------------
171    /// Set the watchpoint's condition.
172    ///
173    /// @param[in] condition
174    ///    The condition expression to evaluate when the watchpoint is hit.
175    ///    Pass in NULL to clear the condition.
176    //------------------------------------------------------------------
177    void SetCondition (const char *condition);
178
179    //------------------------------------------------------------------
180    /// Return a pointer to the text of the condition expression.
181    ///
182    /// @return
183    ///    A pointer to the condition expression text, or NULL if no
184    //     condition has been set.
185    //------------------------------------------------------------------
186    const char *GetConditionText () const;
187
188    void
189    TurnOnEphemeralMode();
190
191    void
192    TurnOffEphemeralMode();
193
194    bool
195    IsDisabledDuringEphemeralMode();
196
197    const ClangASTType &
198    GetClangASTType()
199    {
200        return m_type;
201    }
202
203
204private:
205    friend class Target;
206    friend class WatchpointList;
207
208    void        ResetHitCount() { m_hit_count = 0; }
209
210    Target      &m_target;
211    bool        m_enabled;             // Is this watchpoint enabled
212    bool        m_is_hardware;         // Is this a hardware watchpoint
213    bool        m_is_watch_variable;   // True if set via 'watchpoint set variable'.
214    bool        m_is_ephemeral;        // True if the watchpoint is in the ephemeral mode, meaning that it is
215                                       // undergoing a pair of temporary disable/enable actions to avoid recursively
216                                       // triggering further watchpoint events.
217    uint32_t    m_disabled_count;      // Keep track of the count that the watchpoint is disabled while in ephemeral mode.
218                                       // At the end of the ephemeral mode when the watchpoint is to be enabled agian,
219                                       // we check the count, if it is more than 1, it means the user-supplied actions
220                                       // actually want the watchpoint to be disabled!
221    uint32_t    m_watch_read:1,        // 1 if we stop when the watched data is read from
222                m_watch_write:1,       // 1 if we stop when the watched data is written to
223                m_watch_was_read:1,    // Set to 1 when watchpoint is hit for a read access
224                m_watch_was_written:1; // Set to 1 when watchpoint is hit for a write access
225    uint32_t    m_ignore_count;        // Number of times to ignore this watchpoint
226    uint32_t    m_false_alarms;        // Number of false alarms.
227    std::string m_decl_str;            // Declaration information, if any.
228    std::string m_watch_spec_str;      // Spec for the watchpoint.
229    lldb::ValueObjectSP m_old_value_sp;
230    lldb::ValueObjectSP m_new_value_sp;
231    ClangASTType m_type;
232    Error       m_error;               // An error object describing errors associated with this watchpoint.
233    WatchpointOptions m_options;       // Settable watchpoint options, which is a delegate to handle
234                                       // the callback machinery.
235    bool        m_being_created;
236
237    std::auto_ptr<ClangUserExpression> m_condition_ap;  // The condition to test.
238
239    void SetID(lldb::watch_id_t id) { m_loc_id = id; }
240
241    void
242    SendWatchpointChangedEvent (lldb::WatchpointEventType eventKind);
243
244    void
245    SendWatchpointChangedEvent (WatchpointEventData *data);
246
247    DISALLOW_COPY_AND_ASSIGN (Watchpoint);
248};
249
250} // namespace lldb_private
251
252#endif  // liblldb_Watchpoint_h_
253