| //===-- BreakpointLocation.h ------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef liblldb_BreakpointLocation_h_ |
| #define liblldb_BreakpointLocation_h_ |
| |
| // C Includes |
| |
| // C++ Includes |
| #include <list> |
| #include <memory> |
| |
| // Other libraries and framework includes |
| |
| // Project includes |
| #include "lldb/lldb-private.h" |
| #include "lldb/Breakpoint/StoppointLocation.h" |
| #include "lldb/Core/UserID.h" |
| #include "lldb/Core/Address.h" |
| #include "lldb/Target/Process.h" |
| #include "lldb/Core/StringList.h" |
| |
| namespace lldb_private { |
| |
| //---------------------------------------------------------------------- |
| /// @class BreakpointLocation BreakpointLocation.h "lldb/Breakpoint/BreakpointLocation.h" |
| /// @brief Class that manages one unique (by address) instance of a logical breakpoint. |
| //---------------------------------------------------------------------- |
| |
| //---------------------------------------------------------------------- |
| /// General Outline: |
| /// A breakpoint location is defined by the breakpoint that produces it, |
| /// and the address that resulted in this particular instantiation. |
| /// Each breakpoint location also may have a breakpoint site if its |
| /// address has been loaded into the program. |
| /// Finally it has a settable options object. |
| /// |
| /// FIXME: Should we also store some fingerprint for the location, so |
| /// we can map one location to the "equivalent location" on rerun? This |
| /// would be useful if you've set options on the locations. |
| //---------------------------------------------------------------------- |
| |
| class BreakpointLocation : public StoppointLocation |
| { |
| public: |
| |
| ~BreakpointLocation (); |
| |
| //------------------------------------------------------------------ |
| /// Gets the load address for this breakpoint location |
| /// @return |
| /// Returns breakpoint location load address, \b |
| /// LLDB_INVALID_ADDRESS if not yet set. |
| //------------------------------------------------------------------ |
| lldb::addr_t |
| GetLoadAddress () const; |
| |
| //------------------------------------------------------------------ |
| /// Gets the Address for this breakpoint location |
| /// @return |
| /// Returns breakpoint location Address. |
| //------------------------------------------------------------------ |
| Address & |
| GetAddress (); |
| //------------------------------------------------------------------ |
| /// Gets the Breakpoint that created this breakpoint location |
| /// @return |
| /// Returns the owning breakpoint. |
| //------------------------------------------------------------------ |
| Breakpoint & |
| GetBreakpoint (); |
| |
| //------------------------------------------------------------------ |
| /// Determines whether we should stop due to a hit at this |
| /// breakpoint location. |
| /// |
| /// Side Effects: This may evaluate the breakpoint condition, and |
| /// run the callback. So this command may do a considerable amount |
| /// of work. |
| /// |
| /// @return |
| /// \b true if this breakpoint location thinks we should stop, |
| /// \b false otherwise. |
| //------------------------------------------------------------------ |
| bool |
| ShouldStop (StoppointCallbackContext *context); |
| |
| //------------------------------------------------------------------ |
| // The next section deals with various breakpoint options. |
| //------------------------------------------------------------------ |
| |
| //------------------------------------------------------------------ |
| /// If \a enable is \b true, enable the breakpoint, if \b false |
| /// disable it. |
| //------------------------------------------------------------------ |
| void |
| SetEnabled(bool enabled); |
| |
| //------------------------------------------------------------------ |
| /// Check the Enable/Disable state. |
| /// |
| /// @return |
| /// \b true if the breakpoint is enabled, \b false if disabled. |
| //------------------------------------------------------------------ |
| bool |
| IsEnabled (); |
| |
| //------------------------------------------------------------------ |
| /// Return the current Ignore Count. |
| /// |
| /// @return |
| /// The number of breakpoint hits to be ignored. |
| //------------------------------------------------------------------ |
| uint32_t |
| GetIgnoreCount (); |
| |
| //------------------------------------------------------------------ |
| /// Set the breakpoint to ignore the next \a count breakpoint hits. |
| /// |
| /// @param[in] count |
| /// The number of breakpoint hits to ignore. |
| //------------------------------------------------------------------ |
| void |
| SetIgnoreCount (uint32_t n); |
| |
| //------------------------------------------------------------------ |
| /// Set the callback action invoked when the breakpoint is hit. |
| /// |
| /// The callback will return a bool indicating whether the target |
| /// should stop at this breakpoint or not. |
| /// |
| /// @param[in] callback |
| /// The method that will get called when the breakpoint is hit. |
| /// |
| /// @param[in] callback_baton_sp |
| /// A shared pointer to a Baton that provides the void * needed |
| /// for the callback. |
| /// |
| /// @see lldb_private::Baton |
| //------------------------------------------------------------------ |
| void |
| SetCallback (BreakpointHitCallback callback, |
| const lldb::BatonSP &callback_baton_sp, |
| bool is_synchronous); |
| |
| void |
| SetCallback (BreakpointHitCallback callback, |
| void *baton, |
| bool is_synchronous); |
| |
| void |
| ClearCallback (); |
| |
| //------------------------------------------------------------------ |
| /// Set the breakpoint location's condition. |
| /// |
| /// @param[in] condition |
| /// The condition expression to evaluate when the breakpoint is hit. |
| //------------------------------------------------------------------ |
| void |
| SetCondition (const char *condition); |
| |
| //------------------------------------------------------------------ |
| /// Test the breakpoint location's condition in the Execution context passed in. |
| /// |
| /// @param[in] exe_ctx |
| /// The execution context in which to evaluate this expression. |
| /// |
| /// @param[in] error |
| /// Error messages will be written to this stream. |
| /// |
| /// @return |
| /// A thread plan to run to test the condition, or NULL if there is no condition. |
| //------------------------------------------------------------------ |
| ThreadPlan * |
| GetThreadPlanToTestCondition (ExecutionContext &exe_ctx, |
| Stream &error); |
| |
| //------------------------------------------------------------------ |
| /// Return a pointer to the text of the condition expression. |
| /// |
| /// @return |
| /// A pointer to the condition expression text, or NULL if no |
| // condition has been set. |
| //------------------------------------------------------------------ |
| const char * |
| GetConditionText (); |
| |
| |
| //------------------------------------------------------------------ |
| /// Set the valid thread to be checked when the breakpoint is hit. |
| /// |
| /// @param[in] thread_id |
| /// If this thread hits the breakpoint, we stop, otherwise not. |
| //------------------------------------------------------------------ |
| void |
| SetThreadID (lldb::tid_t thread_id); |
| |
| //------------------------------------------------------------------ |
| // The next section deals with this location's breakpoint sites. |
| //------------------------------------------------------------------ |
| |
| //------------------------------------------------------------------ |
| /// Try to resolve the breakpoint site for this location. |
| /// |
| /// @return |
| /// \b true if we were successful at setting a breakpoint site, |
| /// \b false otherwise. |
| //------------------------------------------------------------------ |
| bool |
| ResolveBreakpointSite (); |
| |
| //------------------------------------------------------------------ |
| /// Clear this breakpoint location's breakpoint site - for instance |
| /// when disabling the breakpoint. |
| /// |
| /// @return |
| /// \b true if there was a breakpoint site to be cleared, \b false |
| /// otherwise. |
| //------------------------------------------------------------------ |
| bool |
| ClearBreakpointSite (); |
| |
| //------------------------------------------------------------------ |
| /// Return whether this breakpoint location has a breakpoint site. |
| /// @return |
| /// \b true if there was a breakpoint site for this breakpoint |
| /// location, \b false otherwise. |
| //------------------------------------------------------------------ |
| bool |
| IsResolved () const; |
| |
| lldb::BreakpointSiteSP |
| GetBreakpointSite() const; |
| |
| //------------------------------------------------------------------ |
| // The next section are generic report functions. |
| //------------------------------------------------------------------ |
| |
| //------------------------------------------------------------------ |
| /// Print a description of this breakpoint location to the stream |
| /// \a s. |
| /// |
| /// @param[in] s |
| /// The stream to which to print the description. |
| /// |
| /// @param[in] level |
| /// The description level that indicates the detail level to |
| /// provide. |
| /// |
| /// @see lldb::DescriptionLevel |
| //------------------------------------------------------------------ |
| void |
| GetDescription (Stream *s, lldb::DescriptionLevel level); |
| |
| //------------------------------------------------------------------ |
| /// Standard "Dump" method. At present it does nothing. |
| //------------------------------------------------------------------ |
| void |
| Dump (Stream *s) const; |
| |
| //------------------------------------------------------------------ |
| /// Use this to set location specific breakpoint options. |
| /// |
| /// It will create a copy of the containing breakpoint's options if |
| /// that hasn't been done already |
| /// |
| /// @return |
| /// A pointer to the breakpoint options. |
| //------------------------------------------------------------------ |
| BreakpointOptions * |
| GetLocationOptions (); |
| |
| //------------------------------------------------------------------ |
| /// Use this to access breakpoint options from this breakpoint location. |
| /// This will point to the owning breakpoint's options unless options have |
| /// been set specifically on this location. |
| /// |
| /// @return |
| /// A pointer to the containing breakpoint's options if this |
| /// location doesn't have its own copy. |
| //------------------------------------------------------------------ |
| const BreakpointOptions * |
| GetOptionsNoCreate () const; |
| |
| bool |
| ValidForThisThread (Thread *thread); |
| |
| |
| //------------------------------------------------------------------ |
| /// Invoke the callback action when the breakpoint is hit. |
| /// |
| /// Meant to be used by the BreakpointLocation class. |
| /// |
| /// @param[in] context |
| /// Described the breakpoint event. |
| /// |
| /// @param[in] bp_loc_id |
| /// Which breakpoint location hit this breakpoint. |
| /// |
| /// @return |
| /// \b true if the target should stop at this breakpoint and \b |
| /// false not. |
| //------------------------------------------------------------------ |
| bool |
| InvokeCallback (StoppointCallbackContext *context); |
| |
| protected: |
| friend class BreakpointLocationList; |
| friend class CommandObjectBreakpointCommandAdd; |
| friend class Process; |
| |
| //------------------------------------------------------------------ |
| /// Set the breakpoint site for this location to \a bp_site_sp. |
| /// |
| /// @param[in] bp_site_sp |
| /// The breakpoint site we are setting for this location. |
| /// |
| /// @return |
| /// \b true if we were successful at setting the breakpoint site, |
| /// \b false otherwise. |
| //------------------------------------------------------------------ |
| bool |
| SetBreakpointSite (lldb::BreakpointSiteSP& bp_site_sp); |
| |
| private: |
| |
| //------------------------------------------------------------------ |
| // Constructors and Destructors |
| // |
| // Only the Breakpoint can make breakpoint locations, and it owns |
| // them. |
| //------------------------------------------------------------------ |
| |
| //------------------------------------------------------------------ |
| /// Constructor. |
| /// |
| /// @param[in] owner |
| /// A back pointer to the breakpoint that owns this location. |
| /// |
| /// @param[in] addr |
| /// The Address defining this location. |
| /// |
| /// @param[in] tid |
| /// The thread for which this breakpoint location is valid, or |
| /// LLDB_INVALID_THREAD_ID if it is valid for all threads. |
| /// |
| /// @param[in] hardware |
| /// \b true if a hardware breakpoint is requested. |
| //------------------------------------------------------------------ |
| |
| BreakpointLocation (lldb::break_id_t bid, |
| Breakpoint &owner, |
| const Address &addr, |
| lldb::tid_t tid = LLDB_INVALID_THREAD_ID, |
| bool hardware = false); |
| |
| //------------------------------------------------------------------ |
| // Data members: |
| //------------------------------------------------------------------ |
| Address m_address; ///< The address defining this location. |
| Breakpoint &m_owner; ///< The breakpoint that produced this object. |
| std::auto_ptr<BreakpointOptions> m_options_ap; ///< Breakpoint options pointer, NULL if we're using our breakpoint's options. |
| lldb::BreakpointSiteSP m_bp_site_sp; ///< Our breakpoint site (it may be shared by more than one location.) |
| |
| DISALLOW_COPY_AND_ASSIGN (BreakpointLocation); |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // liblldb_BreakpointLocation_h_ |