//===-- Watchpoint.h --------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLDB_BREAKPOINT_WATCHPOINT_H #define LLDB_BREAKPOINT_WATCHPOINT_H #include #include #include "lldb/Breakpoint/StoppointSite.h" #include "lldb/Breakpoint/WatchpointOptions.h" #include "lldb/Symbol/CompilerType.h" #include "lldb/Target/Target.h" #include "lldb/Utility/UserID.h" #include "lldb/lldb-private.h" namespace lldb_private { class Watchpoint : public std::enable_shared_from_this, public StoppointSite { public: class WatchpointEventData : public EventData { public: WatchpointEventData(lldb::WatchpointEventType sub_type, const lldb::WatchpointSP &new_watchpoint_sp); ~WatchpointEventData() override; static llvm::StringRef GetFlavorString(); llvm::StringRef GetFlavor() const override; lldb::WatchpointEventType GetWatchpointEventType() const; lldb::WatchpointSP &GetWatchpoint(); void Dump(Stream *s) const override; static lldb::WatchpointEventType GetWatchpointEventTypeFromEvent(const lldb::EventSP &event_sp); static lldb::WatchpointSP GetWatchpointFromEvent(const lldb::EventSP &event_sp); static const WatchpointEventData * GetEventDataFromEvent(const Event *event_sp); private: lldb::WatchpointEventType m_watchpoint_event; lldb::WatchpointSP m_new_watchpoint_sp; WatchpointEventData(const WatchpointEventData &) = delete; const WatchpointEventData &operator=(const WatchpointEventData &) = delete; }; Watchpoint(Target &target, lldb::addr_t addr, uint32_t size, const CompilerType *type, bool hardware = true); ~Watchpoint() override; bool IsEnabled() const; // This doesn't really enable/disable the watchpoint. It is currently just // for use in the Process plugin's {Enable,Disable}Watchpoint, which should // be used instead. void SetEnabled(bool enabled, bool notify = true); bool IsHardware() const override; bool ShouldStop(StoppointCallbackContext *context) override; bool WatchpointRead() const; bool WatchpointWrite() const; bool WatchpointModify() const; uint32_t GetIgnoreCount() const; void SetIgnoreCount(uint32_t n); void SetWatchpointType(uint32_t type, bool notify = true); void SetDeclInfo(const std::string &str); std::string GetWatchSpec(); void SetWatchSpec(const std::string &str); bool WatchedValueReportable(const ExecutionContext &exe_ctx); // Snapshot management interface. bool IsWatchVariable() const; void SetWatchVariable(bool val); bool CaptureWatchedValue(const ExecutionContext &exe_ctx); /// \struct WatchpointVariableContext /// \brief Represents the context of a watchpoint variable. /// /// This struct encapsulates the information related to a watchpoint variable, /// including the watch ID and the execution context in which it is being /// used. This struct is passed as a Baton to the \b /// VariableWatchpointDisabler breakpoint callback. struct WatchpointVariableContext { /// \brief Constructor for WatchpointVariableContext. /// \param watch_id The ID of the watchpoint. /// \param exe_ctx The execution context associated with the watchpoint. WatchpointVariableContext(lldb::watch_id_t watch_id, ExecutionContext exe_ctx) : watch_id(watch_id), exe_ctx(exe_ctx) {} lldb::watch_id_t watch_id; ///< The ID of the watchpoint. ExecutionContext exe_ctx; ///< The execution context associated with the watchpoint. }; class WatchpointVariableBaton : public TypedBaton { public: WatchpointVariableBaton(std::unique_ptr Data) : TypedBaton(std::move(Data)) {} }; bool SetupVariableWatchpointDisabler(lldb::StackFrameSP frame_sp) const; /// Callback routine to disable the watchpoint set on a local variable when /// it goes out of scope. static bool VariableWatchpointDisabler( void *baton, lldb_private::StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id); void GetDescription(Stream *s, lldb::DescriptionLevel level); void Dump(Stream *s) const override; bool DumpSnapshots(Stream *s, const char *prefix = nullptr) const; void DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const; Target &GetTarget() { return m_target; } const Status &GetError() { return m_error; } /// Returns the WatchpointOptions structure set for this watchpoint. /// /// \return /// A pointer to this watchpoint's WatchpointOptions. WatchpointOptions *GetOptions() { return &m_options; } /// Set the callback action invoked when the watchpoint is hit. /// /// \param[in] callback /// The method that will get called when the watchpoint is hit. /// \param[in] callback_baton /// A void * pointer that will get passed back to the callback function. /// \param[in] is_synchronous /// If \b true the callback will be run on the private event thread /// before the stop event gets reported. If false, the callback will get /// handled on the public event thread after the stop has been posted. void SetCallback(WatchpointHitCallback callback, void *callback_baton, bool is_synchronous = false); void SetCallback(WatchpointHitCallback callback, const lldb::BatonSP &callback_baton_sp, bool is_synchronous = false); void ClearCallback(); /// Invoke the callback action when the watchpoint is hit. /// /// \param[in] context /// Described the watchpoint event. /// /// \return /// \b true if the target should stop at this watchpoint and \b false not. bool InvokeCallback(StoppointCallbackContext *context); // Condition /// Set the watchpoint's condition. /// /// \param[in] condition /// The condition expression to evaluate when the watchpoint is hit. /// Pass in nullptr to clear the condition. void SetCondition(const char *condition); /// Return a pointer to the text of the condition expression. /// /// \return /// A pointer to the condition expression text, or nullptr if no // condition has been set. const char *GetConditionText() const; void TurnOnEphemeralMode(); void TurnOffEphemeralMode(); bool IsDisabledDuringEphemeralMode(); const CompilerType &GetCompilerType() { return m_type; } private: friend class Target; friend class WatchpointList; friend class StopInfoWatchpoint; // This needs to call UndoHitCount() void ResetHistoricValues() { m_old_value_sp.reset(); m_new_value_sp.reset(); } void UndoHitCount() { m_hit_counter.Decrement(); } Target &m_target; bool m_enabled; // Is this watchpoint enabled bool m_is_hardware; // Is this a hardware watchpoint bool m_is_watch_variable; // True if set via 'watchpoint set variable'. bool m_is_ephemeral; // True if the watchpoint is in the ephemeral mode, // meaning that it is // undergoing a pair of temporary disable/enable actions to avoid recursively // triggering further watchpoint events. uint32_t m_disabled_count; // Keep track of the count that the watchpoint is // disabled while in ephemeral mode. // At the end of the ephemeral mode when the watchpoint is to be enabled // again, we check the count, if it is more than 1, it means the user- // supplied actions actually want the watchpoint to be disabled! uint32_t m_watch_read : 1, // 1 if we stop when the watched data is read from m_watch_write : 1, // 1 if we stop when the watched data is written to m_watch_modify : 1; // 1 if we stop when the watched data is changed uint32_t m_ignore_count; // Number of times to ignore this watchpoint std::string m_decl_str; // Declaration information, if any. std::string m_watch_spec_str; // Spec for the watchpoint. lldb::ValueObjectSP m_old_value_sp; lldb::ValueObjectSP m_new_value_sp; CompilerType m_type; Status m_error; // An error object describing errors associated with this // watchpoint. WatchpointOptions m_options; // Settable watchpoint options, which is a // delegate to handle the callback machinery. std::unique_ptr m_condition_up; // The condition to test. void SetID(lldb::watch_id_t id) { m_id = id; } void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind); Watchpoint(const Watchpoint &) = delete; const Watchpoint &operator=(const Watchpoint &) = delete; }; } // namespace lldb_private #endif // LLDB_BREAKPOINT_WATCHPOINT_H