Differential D46321 Diff 144897 lldb/trunk/include/lldb/Breakpoint/Breakpoint.h

Changeset 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