contrib/llvm/tools/lldb/include/lldb/Breakpoint/Watchpoint.h

   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
  28 namespace lldb_private {
  29
  30 class Watchpoint :
  31     public std::enable_shared_from_this<Watchpoint>,
  32     public StoppointLocation
  33 {
  34 public:
  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
 204 private:
 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::unique_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_