Changeset View
Changeset View
Standalone View
Standalone View
lldb/trunk/include/lldb/Breakpoint/Breakpoint.h
Show All 27 Lines | |||||
#include "lldb/Core/Event.h" | #include "lldb/Core/Event.h" | ||||
#include "lldb/Core/SearchFilter.h" | #include "lldb/Core/SearchFilter.h" | ||||
#include "lldb/Utility/StringList.h" | #include "lldb/Utility/StringList.h" | ||||
#include "lldb/Utility/StructuredData.h" | #include "lldb/Utility/StructuredData.h" | ||||
namespace lldb_private { | namespace lldb_private { | ||||
//---------------------------------------------------------------------- | //---------------------------------------------------------------------- | ||||
/// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" | /// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that | ||||
/// @brief Class that manages logical breakpoint setting. | /// manages logical breakpoint setting. | ||||
//---------------------------------------------------------------------- | //---------------------------------------------------------------------- | ||||
//---------------------------------------------------------------------- | //---------------------------------------------------------------------- | ||||
/// General Outline: | /// General Outline: | ||||
/// A breakpoint has four main parts, a filter, a resolver, the list of | /// A breakpoint has four main parts, a filter, a resolver, the list of | ||||
/// breakpoint | /// breakpoint | ||||
/// locations that have been determined for the filter/resolver pair, and | /// locations that have been determined for the filter/resolver pair, and | ||||
/// finally | /// finally a set of options for the breakpoint. | ||||
/// a set of options for the breakpoint. | |||||
/// | /// | ||||
/// \b Filter: | /// \b Filter: | ||||
/// This is an object derived from SearchFilter. It manages the search | /// This is an object derived from SearchFilter. It manages the search for | ||||
/// for breakpoint location matches through the symbols in the module list of | /// breakpoint location matches through the symbols in the module list of the | ||||
/// the target | /// target that owns it. It also filters out locations based on whatever | ||||
/// that owns it. It also filters out locations based on whatever logic it | /// logic it wants. | ||||
/// wants. | |||||
/// | /// | ||||
/// \b Resolver: | /// \b Resolver: | ||||
/// This is an object derived from BreakpointResolver. It provides a | /// This is an object derived from BreakpointResolver. It provides a callback | ||||
/// callback to the filter that will find breakpoint locations. How it does | /// to the filter that will find breakpoint locations. How it does this is | ||||
/// this is | |||||
/// determined by what kind of resolver it is. | /// determined by what kind of resolver it is. | ||||
/// | /// | ||||
/// The Breakpoint class also provides constructors for the common breakpoint | /// The Breakpoint class also provides constructors for the common breakpoint | ||||
/// cases | /// cases which make the appropriate filter and resolver for you. | ||||
/// which make the appropriate filter and resolver for you. | |||||
/// | /// | ||||
/// \b Location List: | /// \b Location List: | ||||
/// This stores the breakpoint locations that have been determined | /// This stores the breakpoint locations that have been determined to date. | ||||
/// to date. For a given breakpoint, there will be only one location with a | /// For a given breakpoint, there will be only one location with a given | ||||
/// given | /// address. Adding a location at an already taken address will just return | ||||
/// address. Adding a location at an already taken address will just return the | /// the location already at that address. Locations can be looked up by ID, | ||||
/// location | /// or by address. | ||||
/// already at that address. Locations can be looked up by ID, or by address. | |||||
/// | /// | ||||
/// \b Options: | /// \b Options: | ||||
/// This includes: | /// This includes: | ||||
/// \b Enabled/Disabled | /// \b Enabled/Disabled | ||||
/// \b Ignore Count | /// \b Ignore Count | ||||
/// \b Callback | /// \b Callback | ||||
/// \b Condition | /// \b Condition | ||||
/// Note, these options can be set on the breakpoint, and they can also be set | /// Note, these options can be set on the breakpoint, and they can also be set | ||||
/// on the | /// on the individual locations. The options set on the breakpoint take | ||||
/// individual locations. The options set on the breakpoint take precedence | /// precedence over the options set on the individual location. So for | ||||
/// over the | /// instance disabling the breakpoint will cause NONE of the locations to get | ||||
/// options set on the individual location. | /// hit. But if the breakpoint is enabled, then the location's enabled state | ||||
/// So for instance disabling the breakpoint will cause NONE of the locations to | /// will be checked to determine whether to insert that breakpoint location. | ||||
/// get hit. | |||||
/// But if the breakpoint is enabled, then the location's enabled state will be | |||||
/// checked | |||||
/// to determine whether to insert that breakpoint location. | |||||
/// Similarly, if the breakpoint condition says "stop", we won't check the | /// Similarly, if the breakpoint condition says "stop", we won't check the | ||||
/// location's condition. | /// location's condition. But if the breakpoint condition says "continue", | ||||
/// But if the breakpoint condition says "continue", then we will check the | /// then we will check the location for whether to actually stop or not. One | ||||
/// location for whether | /// subtle point worth observing here is that you don't actually stop at a | ||||
/// to actually stop or not. | /// Breakpoint, you always stop at one of its locations. So the "should stop" | ||||
/// One subtle point worth observing here is that you don't actually stop at a | /// tests are done by the location, not by the breakpoint. | ||||
/// Breakpoint, you | |||||
/// always stop at one of its locations. So the "should stop" tests are done by | |||||
/// the location, | |||||
/// not by the breakpoint. | |||||
//---------------------------------------------------------------------- | //---------------------------------------------------------------------- | ||||
class Breakpoint : public std::enable_shared_from_this<Breakpoint>, | class Breakpoint : public std::enable_shared_from_this<Breakpoint>, | ||||
public Stoppoint { | public Stoppoint { | ||||
public: | public: | ||||
static const ConstString &GetEventIdentifier(); | static const ConstString &GetEventIdentifier(); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// An enum specifying the match style for breakpoint settings. At | /// An enum specifying the match style for breakpoint settings. At present | ||||
/// present only used for function name style breakpoints. | /// only used for function name style breakpoints. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
typedef enum { Exact, Regexp, Glob } MatchType; | typedef enum { Exact, Regexp, Glob } MatchType; | ||||
private: | private: | ||||
enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName }; | enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName }; | ||||
static const char | static const char | ||||
*g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)]; | *g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)]; | ||||
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines | SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp, | ||||
std::vector<std::string> &names); | std::vector<std::string> &names); | ||||
virtual StructuredData::ObjectSP SerializeToStructuredData(); | virtual StructuredData::ObjectSP SerializeToStructuredData(); | ||||
static const char *GetSerializationKey() { return "Breakpoint"; } | static const char *GetSerializationKey() { return "Breakpoint"; } | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Destructor. | /// Destructor. | ||||
/// | /// | ||||
/// The destructor is not virtual since there should be no reason to subclass | /// The destructor is not virtual since there should be no reason to | ||||
/// breakpoints. The varieties of breakpoints are specified instead by | /// subclass breakpoints. The varieties of breakpoints are specified | ||||
/// providing different resolvers & filters. | /// instead by providing different resolvers & filters. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
~Breakpoint() override; | ~Breakpoint() override; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
// Methods | // Methods | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tell whether this breakpoint is an "internal" breakpoint. | /// Tell whether this breakpoint is an "internal" breakpoint. @return | ||||
/// @return | |||||
/// Returns \b true if this is an internal breakpoint, \b false otherwise. | /// Returns \b true if this is an internal breakpoint, \b false otherwise. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
bool IsInternal() const; | bool IsInternal() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Standard "Dump" method. At present it does nothing. | /// Standard "Dump" method. At present it does nothing. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void Dump(Stream *s) override; | void Dump(Stream *s) override; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
// The next set of methods provide ways to tell the breakpoint to update it's | // The next set of methods provide ways to tell the breakpoint to update it's | ||||
// location list - usually done when modules appear or disappear. | // location list - usually done when modules appear or disappear. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tell this breakpoint to clear all its breakpoint sites. Done | /// Tell this breakpoint to clear all its breakpoint sites. Done when the | ||||
/// when the process holding the breakpoint sites is destroyed. | /// process holding the breakpoint sites is destroyed. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ClearAllBreakpointSites(); | void ClearAllBreakpointSites(); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tell this breakpoint to scan it's target's module list and resolve any | /// Tell this breakpoint to scan it's target's module list and resolve any | ||||
/// new locations that match the breakpoint's specifications. | /// new locations that match the breakpoint's specifications. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ResolveBreakpoint(); | void ResolveBreakpoint(); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tell this breakpoint to scan a given module list and resolve any | /// Tell this breakpoint to scan a given module list and resolve any new | ||||
/// new locations that match the breakpoint's specifications. | /// locations that match the breakpoint's specifications. | ||||
/// | /// | ||||
/// @param[in] module_list | /// @param[in] module_list | ||||
/// The list of modules to look in for new locations. | /// The list of modules to look in for new locations. | ||||
/// | /// | ||||
/// @param[in] send_event | /// @param[in] send_event | ||||
/// If \b true, send a breakpoint location added event for non-internal | /// If \b true, send a breakpoint location added event for non-internal | ||||
/// breakpoints. | /// breakpoints. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ResolveBreakpointInModules(ModuleList &module_list, | void ResolveBreakpointInModules(ModuleList &module_list, | ||||
bool send_event = true); | bool send_event = true); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tell this breakpoint to scan a given module list and resolve any | /// Tell this breakpoint to scan a given module list and resolve any new | ||||
/// new locations that match the breakpoint's specifications. | /// locations that match the breakpoint's specifications. | ||||
/// | /// | ||||
/// @param[in] changed_modules | /// @param[in] changed_modules | ||||
/// The list of modules to look in for new locations. | /// The list of modules to look in for new locations. | ||||
/// | /// | ||||
/// @param[in] new_locations | /// @param[in] new_locations | ||||
/// Fills new_locations with the new locations that were made. | /// Fills new_locations with the new locations that were made. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ResolveBreakpointInModules(ModuleList &module_list, | void ResolveBreakpointInModules(ModuleList &module_list, | ||||
Show All 11 Lines | public: | ||||
/// @param[in] delete_locations | /// @param[in] delete_locations | ||||
/// If \b true then the modules were unloaded delete any locations in the | /// If \b true then the modules were unloaded delete any locations in the | ||||
/// changed modules. | /// changed modules. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ModulesChanged(ModuleList &changed_modules, bool load_event, | void ModulesChanged(ModuleList &changed_modules, bool load_event, | ||||
bool delete_locations = false); | bool delete_locations = false); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Tells the breakpoint the old module \a old_module_sp has been | /// Tells the breakpoint the old module \a old_module_sp has been replaced | ||||
/// replaced by new_module_sp (usually because the underlying file has been | /// by new_module_sp (usually because the underlying file has been rebuilt, | ||||
/// rebuilt, and the old version is gone.) | /// and the old version is gone.) | ||||
/// | /// | ||||
/// @param[in] old_module_sp | /// @param[in] old_module_sp | ||||
/// The old module that is going away. | /// The old module that is going away. | ||||
/// @param[in] new_module_sp | /// @param[in] new_module_sp | ||||
/// The new module that is replacing it. | /// The new module that is replacing it. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void ModuleReplaced(lldb::ModuleSP old_module_sp, | void ModuleReplaced(lldb::ModuleSP old_module_sp, | ||||
lldb::ModuleSP new_module_sp); | lldb::ModuleSP new_module_sp); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
// The next set of methods provide access to the breakpoint locations for | // The next set of methods provide access to the breakpoint locations for | ||||
// this breakpoint. | // this breakpoint. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Add a location to the breakpoint's location list. This is only meant | /// Add a location to the breakpoint's location list. This is only meant to | ||||
/// to be called by the breakpoint's resolver. FIXME: how do I ensure that? | /// be called by the breakpoint's resolver. FIXME: how do I ensure that? | ||||
/// | /// | ||||
/// @param[in] addr | /// @param[in] addr | ||||
/// The Address specifying the new location. | /// The Address specifying the new location. | ||||
/// @param[out] new_location | /// @param[out] new_location | ||||
/// Set to \b true if a new location was created, to \b false if there | /// Set to \b true if a new location was created, to \b false if there | ||||
/// already was a location at this Address. | /// already was a location at this Address. | ||||
/// @return | /// @return | ||||
/// Returns a pointer to the new location. | /// Returns a pointer to the new location. | ||||
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines | public: | ||||
/// greater than then number of actual locations. | /// greater than then number of actual locations. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
lldb::BreakpointLocationSP GetLocationAtIndex(size_t index); | lldb::BreakpointLocationSP GetLocationAtIndex(size_t index); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Removes all invalid breakpoint locations. | /// Removes all invalid breakpoint locations. | ||||
/// | /// | ||||
/// Removes all breakpoint locations with architectures that aren't | /// Removes all breakpoint locations with architectures that aren't | ||||
/// compatible with \a arch. Also remove any breakpoint locations | /// compatible with \a arch. Also remove any breakpoint locations with whose | ||||
/// with whose locations have address where the section has been | /// locations have address where the section has been deleted (module and | ||||
/// deleted (module and object files no longer exist). | /// object files no longer exist). | ||||
/// | /// | ||||
/// This is typically used after the process calls exec, or anytime | /// This is typically used after the process calls exec, or anytime the | ||||
/// the architecture of the target changes. | /// architecture of the target changes. | ||||
/// | /// | ||||
/// @param[in] arch | /// @param[in] arch | ||||
/// If valid, check the module in each breakpoint to make sure | /// If valid, check the module in each breakpoint to make sure | ||||
/// they are compatible, otherwise, ignore architecture. | /// they are compatible, otherwise, ignore architecture. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void RemoveInvalidLocations(const ArchSpec &arch); | void RemoveInvalidLocations(const ArchSpec &arch); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
Show All 22 Lines | public: | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Return the current ignore count/ | /// Return the current ignore count/ | ||||
/// @return | /// @return | ||||
/// The number of breakpoint hits to be ignored. | /// The number of breakpoint hits to be ignored. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
uint32_t GetIgnoreCount() const; | uint32_t GetIgnoreCount() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Return the current hit count for all locations. | /// Return the current hit count for all locations. @return | ||||
/// @return | |||||
/// The current hit count for all locations. | /// The current hit count for all locations. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
uint32_t GetHitCount() const; | uint32_t GetHitCount() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// If \a one_shot is \b true, breakpoint will be deleted on first hit. | /// If \a one_shot is \b true, breakpoint will be deleted on first hit. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void SetOneShot(bool one_shot); | void SetOneShot(bool one_shot); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Check the OneShot state. | /// Check the OneShot state. | ||||
/// @return | /// @return | ||||
/// \b true if the breakpoint is one shot, \b false otherwise. | /// \b true if the breakpoint is one shot, \b false otherwise. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
bool IsOneShot() const; | bool IsOneShot() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// If \a auto_continue is \b true, breakpoint will auto-continue when on hit. | /// If \a auto_continue is \b true, breakpoint will auto-continue when on | ||||
/// hit. | |||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void SetAutoContinue(bool auto_continue); | void SetAutoContinue(bool auto_continue); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Check the AutoContinue state. | /// Check the AutoContinue state. | ||||
/// @return | /// @return | ||||
/// \b true if the breakpoint is set to auto-continue, \b false otherwise. | /// \b true if the breakpoint is set to auto-continue, \b false otherwise. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines | public: | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
const char *GetConditionText() const; | const char *GetConditionText() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
// The next section are various utility functions. | // The next section are various utility functions. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Return the number of breakpoint locations that have resolved to | /// Return the number of breakpoint locations that have resolved to actual | ||||
/// actual breakpoint sites. | /// breakpoint sites. | ||||
/// | /// | ||||
/// @return | /// @return | ||||
/// The number locations resolved breakpoint sites. | /// The number locations resolved breakpoint sites. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
size_t GetNumResolvedLocations() const; | size_t GetNumResolvedLocations() const; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Return the number of breakpoint locations. | /// Return the number of breakpoint locations. | ||||
Show All 15 Lines | public: | ||||
/// | /// | ||||
/// @see lldb::DescriptionLevel | /// @see lldb::DescriptionLevel | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void GetDescription(Stream *s, lldb::DescriptionLevel level, | void GetDescription(Stream *s, lldb::DescriptionLevel level, | ||||
bool show_locations = false); | bool show_locations = false); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Set the "kind" description for a breakpoint. If the breakpoint is hit | /// Set the "kind" description for a breakpoint. If the breakpoint is hit | ||||
/// the stop info will show this "kind" description instead of the breakpoint | /// the stop info will show this "kind" description instead of the | ||||
/// number. Mostly useful for internal breakpoints, where the breakpoint | /// breakpoint number. Mostly useful for internal breakpoints, where the | ||||
/// number | /// breakpoint number doesn't have meaning to the user. | ||||
/// doesn't have meaning to the user. | |||||
/// | /// | ||||
/// @param[in] kind | /// @param[in] kind | ||||
/// New "kind" description. | /// New "kind" description. | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); } | void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); } | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Return the "kind" description for a breakpoint. | /// Return the "kind" description for a breakpoint. | ||||
Show All 13 Lines | public: | ||||
const Target &GetTarget() const { return m_target; } | const Target &GetTarget() const { return m_target; } | ||||
const lldb::TargetSP GetTargetSP(); | const lldb::TargetSP GetTargetSP(); | ||||
void GetResolverDescription(Stream *s); | void GetResolverDescription(Stream *s); | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Find breakpoint locations which match the (filename, line_number) | /// Find breakpoint locations which match the (filename, line_number) | ||||
/// description. | /// description. The breakpoint location collection is to be filled with the | ||||
/// The breakpoint location collection is to be filled with the matching | /// matching locations. It should be initialized with 0 size by the API | ||||
/// locations. | /// client. | ||||
/// It should be initialized with 0 size by the API client. | |||||
/// | /// | ||||
/// @return | /// @return | ||||
/// True if there is a match | /// True if there is a match | ||||
/// | /// | ||||
/// The locations which match the filename and line_number in loc_coll. | /// The locations which match the filename and line_number in loc_coll. | ||||
/// If its | /// If its | ||||
/// size is 0 and true is returned, it means the breakpoint fully matches | /// size is 0 and true is returned, it means the breakpoint fully matches | ||||
/// the | /// the | ||||
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines | for (auto name : m_name_list) { | ||||
names.push_back(name); | names.push_back(name); | ||||
} | } | ||||
} | } | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Set a pre-condition filter that overrides all user provided | /// Set a pre-condition filter that overrides all user provided | ||||
/// filters/callbacks etc. | /// filters/callbacks etc. | ||||
/// | /// | ||||
/// Used to define fancy breakpoints that can do dynamic hit detection without | /// Used to define fancy breakpoints that can do dynamic hit detection | ||||
/// taking up the condition slot - | /// without taking up the condition slot - which really belongs to the user | ||||
/// which really belongs to the user anyway... | /// anyway... | ||||
/// | /// | ||||
/// The Precondition should not continue the target, it should return true if | /// The Precondition should not continue the target, it should return true | ||||
/// the condition says to stop and | /// if the condition says to stop and false otherwise. | ||||
/// false otherwise. | |||||
/// | /// | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
void SetPrecondition(BreakpointPreconditionSP precondition_sp) { | void SetPrecondition(BreakpointPreconditionSP precondition_sp) { | ||||
m_precondition_sp = precondition_sp; | m_precondition_sp = precondition_sp; | ||||
} | } | ||||
bool EvaluatePrecondition(StoppointCallbackContext &context); | bool EvaluatePrecondition(StoppointCallbackContext &context); | ||||
Show All 22 Lines | protected: | ||||
friend class Target; | friend class Target; | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
// Protected Methods | // Protected Methods | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
//------------------------------------------------------------------ | //------------------------------------------------------------------ | ||||
/// Constructors and Destructors | /// Constructors and Destructors | ||||
/// Only the Target can make a breakpoint, and it owns the breakpoint | /// Only the Target can make a breakpoint, and it owns the breakpoint | ||||
/// lifespans. | /// lifespans. The constructor takes a filter and a resolver. Up in Target | ||||
/// The constructor takes a filter and a resolver. Up in Target there are | /// there are convenience variants that make breakpoints for some common | ||||
/// convenience | /// cases. | ||||
/// variants that make breakpoints for some common cases. | |||||
/// | /// | ||||
/// @param[in] target | /// @param[in] target | ||||
/// The target in which the breakpoint will be set. | /// The target in which the breakpoint will be set. | ||||
/// | /// | ||||
/// @param[in] filter_sp | /// @param[in] filter_sp | ||||
/// Shared pointer to the search filter that restricts the search domain of | /// Shared pointer to the search filter that restricts the search domain of | ||||
/// the breakpoint. | /// the breakpoint. | ||||
/// | /// | ||||
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines |