1 //===-- Breakpoint.h --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef liblldb_Breakpoint_h_
11 #define liblldb_Breakpoint_h_
17 #include <unordered_set>
20 // Other libraries and framework includes
22 #include "lldb/Breakpoint/BreakpointID.h"
23 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
24 #include "lldb/Breakpoint/BreakpointLocationList.h"
25 #include "lldb/Breakpoint/BreakpointName.h"
26 #include "lldb/Breakpoint/BreakpointOptions.h"
27 #include "lldb/Breakpoint/Stoppoint.h"
28 #include "lldb/Core/Event.h"
29 #include "lldb/Core/SearchFilter.h"
30 #include "lldb/Utility/StringList.h"
31 #include "lldb/Utility/StructuredData.h"
33 namespace lldb_private {
35 //----------------------------------------------------------------------
36 /// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h"
37 /// @brief Class that manages logical breakpoint setting.
38 //----------------------------------------------------------------------
40 //----------------------------------------------------------------------
42 /// A breakpoint has four main parts, a filter, a resolver, the list of
44 /// locations that have been determined for the filter/resolver pair, and
46 /// a set of options for the breakpoint.
49 /// This is an object derived from SearchFilter. It manages the search
50 /// for breakpoint location matches through the symbols in the module list of
52 /// that owns it. It also filters out locations based on whatever logic it
56 /// This is an object derived from BreakpointResolver. It provides a
57 /// callback to the filter that will find breakpoint locations. How it does
59 /// determined by what kind of resolver it is.
61 /// The Breakpoint class also provides constructors for the common breakpoint
63 /// which make the appropriate filter and resolver for you.
66 /// This stores the breakpoint locations that have been determined
67 /// to date. For a given breakpoint, there will be only one location with a
69 /// address. Adding a location at an already taken address will just return the
71 /// already at that address. Locations can be looked up by ID, or by address.
75 /// \b Enabled/Disabled
79 /// Note, these options can be set on the breakpoint, and they can also be set
81 /// individual locations. The options set on the breakpoint take precedence
83 /// options set on the individual location.
84 /// So for instance disabling the breakpoint will cause NONE of the locations to
86 /// But if the breakpoint is enabled, then the location's enabled state will be
88 /// to determine whether to insert that breakpoint location.
89 /// Similarly, if the breakpoint condition says "stop", we won't check the
90 /// location's condition.
91 /// But if the breakpoint condition says "continue", then we will check the
92 /// location for whether
93 /// to actually stop or not.
94 /// One subtle point worth observing here is that you don't actually stop at a
96 /// always stop at one of its locations. So the "should stop" tests are done by
98 /// not by the breakpoint.
99 //----------------------------------------------------------------------
100 class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
103 static const ConstString &GetEventIdentifier();
105 //------------------------------------------------------------------
106 /// An enum specifying the match style for breakpoint settings. At
107 /// present only used for function name style breakpoints.
108 //------------------------------------------------------------------
109 typedef enum { Exact, Regexp, Glob } MatchType;
112 enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName };
115 *g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)];
117 static const char *GetKey(OptionNames enum_value) {
118 return g_option_names[static_cast<uint32_t>(enum_value)];
122 class BreakpointEventData : public EventData {
124 BreakpointEventData(lldb::BreakpointEventType sub_type,
125 const lldb::BreakpointSP &new_breakpoint_sp);
127 ~BreakpointEventData() override;
129 static const ConstString &GetFlavorString();
131 const ConstString &GetFlavor() const override;
133 lldb::BreakpointEventType GetBreakpointEventType() const;
135 lldb::BreakpointSP &GetBreakpoint();
137 BreakpointLocationCollection &GetBreakpointLocationCollection() {
141 void Dump(Stream *s) const override;
143 static lldb::BreakpointEventType
144 GetBreakpointEventTypeFromEvent(const lldb::EventSP &event_sp);
146 static lldb::BreakpointSP
147 GetBreakpointFromEvent(const lldb::EventSP &event_sp);
149 static lldb::BreakpointLocationSP
150 GetBreakpointLocationAtIndexFromEvent(const lldb::EventSP &event_sp,
154 GetNumBreakpointLocationsFromEvent(const lldb::EventSP &event_sp);
156 static const BreakpointEventData *
157 GetEventDataFromEvent(const Event *event_sp);
160 lldb::BreakpointEventType m_breakpoint_event;
161 lldb::BreakpointSP m_new_breakpoint_sp;
162 BreakpointLocationCollection m_locations;
164 DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
167 class BreakpointPrecondition {
169 virtual ~BreakpointPrecondition() = default;
171 virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
173 virtual Status ConfigurePrecondition(Args &options);
175 virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
178 typedef std::shared_ptr<BreakpointPrecondition> BreakpointPreconditionSP;
180 // Saving & restoring breakpoints:
181 static lldb::BreakpointSP CreateFromStructuredData(
182 Target &target, StructuredData::ObjectSP &data_object_sp, Status &error);
185 SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp,
186 std::vector<std::string> &names);
188 virtual StructuredData::ObjectSP SerializeToStructuredData();
190 static const char *GetSerializationKey() { return "Breakpoint"; }
191 //------------------------------------------------------------------
194 /// The destructor is not virtual since there should be no reason to subclass
195 /// breakpoints. The varieties of breakpoints are specified instead by
196 /// providing different resolvers & filters.
197 //------------------------------------------------------------------
198 ~Breakpoint() override;
200 //------------------------------------------------------------------
202 //------------------------------------------------------------------
204 //------------------------------------------------------------------
205 /// Tell whether this breakpoint is an "internal" breakpoint.
207 /// Returns \b true if this is an internal breakpoint, \b false otherwise.
208 //------------------------------------------------------------------
209 bool IsInternal() const;
211 //------------------------------------------------------------------
212 /// Standard "Dump" method. At present it does nothing.
213 //------------------------------------------------------------------
214 void Dump(Stream *s) override;
216 //------------------------------------------------------------------
217 // The next set of methods provide ways to tell the breakpoint to update
218 // it's location list - usually done when modules appear or disappear.
219 //------------------------------------------------------------------
221 //------------------------------------------------------------------
222 /// Tell this breakpoint to clear all its breakpoint sites. Done
223 /// when the process holding the breakpoint sites is destroyed.
224 //------------------------------------------------------------------
225 void ClearAllBreakpointSites();
227 //------------------------------------------------------------------
228 /// Tell this breakpoint to scan it's target's module list and resolve any
229 /// new locations that match the breakpoint's specifications.
230 //------------------------------------------------------------------
231 void ResolveBreakpoint();
233 //------------------------------------------------------------------
234 /// Tell this breakpoint to scan a given module list and resolve any
235 /// new locations that match the breakpoint's specifications.
237 /// @param[in] module_list
238 /// The list of modules to look in for new locations.
240 /// @param[in] send_event
241 /// If \b true, send a breakpoint location added event for non-internal
243 //------------------------------------------------------------------
244 void ResolveBreakpointInModules(ModuleList &module_list,
245 bool send_event = true);
247 //------------------------------------------------------------------
248 /// Tell this breakpoint to scan a given module list and resolve any
249 /// new locations that match the breakpoint's specifications.
251 /// @param[in] changed_modules
252 /// The list of modules to look in for new locations.
254 /// @param[in] new_locations
255 /// Fills new_locations with the new locations that were made.
256 //------------------------------------------------------------------
257 void ResolveBreakpointInModules(ModuleList &module_list,
258 BreakpointLocationCollection &new_locations);
260 //------------------------------------------------------------------
261 /// Like ResolveBreakpointInModules, but allows for "unload" events, in
262 /// which case we will remove any locations that are in modules that got
265 /// @param[in] changedModules
266 /// The list of modules to look in for new locations.
267 /// @param[in] load_event
268 /// If \b true then the modules were loaded, if \b false, unloaded.
269 /// @param[in] delete_locations
270 /// If \b true then the modules were unloaded delete any locations in the
272 //------------------------------------------------------------------
273 void ModulesChanged(ModuleList &changed_modules, bool load_event,
274 bool delete_locations = false);
276 //------------------------------------------------------------------
277 /// Tells the breakpoint the old module \a old_module_sp has been
278 /// replaced by new_module_sp (usually because the underlying file has been
279 /// rebuilt, and the old version is gone.)
281 /// @param[in] old_module_sp
282 /// The old module that is going away.
283 /// @param[in] new_module_sp
284 /// The new module that is replacing it.
285 //------------------------------------------------------------------
286 void ModuleReplaced(lldb::ModuleSP old_module_sp,
287 lldb::ModuleSP new_module_sp);
289 //------------------------------------------------------------------
290 // The next set of methods provide access to the breakpoint locations
291 // for this breakpoint.
292 //------------------------------------------------------------------
294 //------------------------------------------------------------------
295 /// Add a location to the breakpoint's location list. This is only meant
296 /// to be called by the breakpoint's resolver. FIXME: how do I ensure that?
299 /// The Address specifying the new location.
300 /// @param[out] new_location
301 /// Set to \b true if a new location was created, to \b false if there
302 /// already was a location at this Address.
304 /// Returns a pointer to the new location.
305 //------------------------------------------------------------------
306 lldb::BreakpointLocationSP AddLocation(const Address &addr,
307 bool *new_location = nullptr);
309 //------------------------------------------------------------------
310 /// Find a breakpoint location by Address.
313 /// The Address specifying the location.
315 /// Returns a shared pointer to the location at \a addr. The pointer
316 /// in the shared pointer will be nullptr if there is no location at that
318 //------------------------------------------------------------------
319 lldb::BreakpointLocationSP FindLocationByAddress(const Address &addr);
321 //------------------------------------------------------------------
322 /// Find a breakpoint location ID by Address.
325 /// The Address specifying the location.
327 /// Returns the UID of the location at \a addr, or \b LLDB_INVALID_ID if
328 /// there is no breakpoint location at that address.
329 //------------------------------------------------------------------
330 lldb::break_id_t FindLocationIDByAddress(const Address &addr);
332 //------------------------------------------------------------------
333 /// Find a breakpoint location for a given breakpoint location ID.
335 /// @param[in] bp_loc_id
336 /// The ID specifying the location.
338 /// Returns a shared pointer to the location with ID \a bp_loc_id. The
340 /// in the shared pointer will be nullptr if there is no location with that
342 //------------------------------------------------------------------
343 lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id);
345 //------------------------------------------------------------------
346 /// Get breakpoint locations by index.
349 /// The location index.
352 /// Returns a shared pointer to the location with index \a
353 /// index. The shared pointer might contain nullptr if \a index is
354 /// greater than then number of actual locations.
355 //------------------------------------------------------------------
356 lldb::BreakpointLocationSP GetLocationAtIndex(size_t index);
358 //------------------------------------------------------------------
359 /// Removes all invalid breakpoint locations.
361 /// Removes all breakpoint locations with architectures that aren't
362 /// compatible with \a arch. Also remove any breakpoint locations
363 /// with whose locations have address where the section has been
364 /// deleted (module and object files no longer exist).
366 /// This is typically used after the process calls exec, or anytime
367 /// the architecture of the target changes.
370 /// If valid, check the module in each breakpoint to make sure
371 /// they are compatible, otherwise, ignore architecture.
372 //------------------------------------------------------------------
373 void RemoveInvalidLocations(const ArchSpec &arch);
375 //------------------------------------------------------------------
376 // The next section deals with various breakpoint options.
377 //------------------------------------------------------------------
379 //------------------------------------------------------------------
380 /// If \a enable is \b true, enable the breakpoint, if \b false disable it.
381 //------------------------------------------------------------------
382 void SetEnabled(bool enable) override;
384 //------------------------------------------------------------------
385 /// Check the Enable/Disable state.
387 /// \b true if the breakpoint is enabled, \b false if disabled.
388 //------------------------------------------------------------------
389 bool IsEnabled() override;
391 //------------------------------------------------------------------
392 /// Set the breakpoint to ignore the next \a count breakpoint hits.
394 /// The number of breakpoint hits to ignore.
395 //------------------------------------------------------------------
396 void SetIgnoreCount(uint32_t count);
398 //------------------------------------------------------------------
399 /// Return the current ignore count/
401 /// The number of breakpoint hits to be ignored.
402 //------------------------------------------------------------------
403 uint32_t GetIgnoreCount() const;
405 //------------------------------------------------------------------
406 /// Return the current hit count for all locations.
408 /// The current hit count for all locations.
409 //------------------------------------------------------------------
410 uint32_t GetHitCount() const;
412 //------------------------------------------------------------------
413 /// If \a one_shot is \b true, breakpoint will be deleted on first hit.
414 //------------------------------------------------------------------
415 void SetOneShot(bool one_shot);
417 //------------------------------------------------------------------
418 /// Check the OneShot state.
420 /// \b true if the breakpoint is one shot, \b false otherwise.
421 //------------------------------------------------------------------
422 bool IsOneShot() const;
424 //------------------------------------------------------------------
425 /// If \a auto_continue is \b true, breakpoint will auto-continue when on hit.
426 //------------------------------------------------------------------
427 void SetAutoContinue(bool auto_continue);
429 //------------------------------------------------------------------
430 /// Check the AutoContinue state.
432 /// \b true if the breakpoint is set to auto-continue, \b false otherwise.
433 //------------------------------------------------------------------
434 bool IsAutoContinue() const;
436 //------------------------------------------------------------------
437 /// Set the valid thread to be checked when the breakpoint is hit.
438 /// @param[in] thread_id
439 /// If this thread hits the breakpoint, we stop, otherwise not.
440 //------------------------------------------------------------------
441 void SetThreadID(lldb::tid_t thread_id);
443 //------------------------------------------------------------------
444 /// Return the current stop thread value.
446 /// The thread id for which the breakpoint hit will stop,
447 /// LLDB_INVALID_THREAD_ID for all threads.
448 //------------------------------------------------------------------
449 lldb::tid_t GetThreadID() const;
451 void SetThreadIndex(uint32_t index);
453 uint32_t GetThreadIndex() const;
455 void SetThreadName(const char *thread_name);
457 const char *GetThreadName() const;
459 void SetQueueName(const char *queue_name);
461 const char *GetQueueName() const;
463 //------------------------------------------------------------------
464 /// Set the callback action invoked when the breakpoint is hit.
466 /// @param[in] callback
467 /// The method that will get called when the breakpoint is hit.
469 /// A void * pointer that will get passed back to the callback function.
470 /// @param[in] is_synchronous
471 /// If \b true the callback will be run on the private event thread
472 /// before the stop event gets reported. If false, the callback will get
473 /// handled on the public event thread after the stop has been posted.
476 /// \b true if the process should stop when you hit the breakpoint.
477 /// \b false if it should continue.
478 //------------------------------------------------------------------
479 void SetCallback(BreakpointHitCallback callback, void *baton,
480 bool is_synchronous = false);
482 void SetCallback(BreakpointHitCallback callback,
483 const lldb::BatonSP &callback_baton_sp,
484 bool is_synchronous = false);
486 void ClearCallback();
488 //------------------------------------------------------------------
489 /// Set the breakpoint's condition.
491 /// @param[in] condition
492 /// The condition expression to evaluate when the breakpoint is hit.
493 /// Pass in nullptr to clear the condition.
494 //------------------------------------------------------------------
495 void SetCondition(const char *condition);
497 //------------------------------------------------------------------
498 /// Return a pointer to the text of the condition expression.
501 /// A pointer to the condition expression text, or nullptr if no
502 // condition has been set.
503 //------------------------------------------------------------------
504 const char *GetConditionText() const;
506 //------------------------------------------------------------------
507 // The next section are various utility functions.
508 //------------------------------------------------------------------
510 //------------------------------------------------------------------
511 /// Return the number of breakpoint locations that have resolved to
512 /// actual breakpoint sites.
515 /// The number locations resolved breakpoint sites.
516 //------------------------------------------------------------------
517 size_t GetNumResolvedLocations() const;
519 //------------------------------------------------------------------
520 /// Return the number of breakpoint locations.
523 /// The number breakpoint locations.
524 //------------------------------------------------------------------
525 size_t GetNumLocations() const;
527 //------------------------------------------------------------------
528 /// Put a description of this breakpoint into the stream \a s.
531 /// Stream into which to dump the description.
534 /// The description level that indicates the detail level to
537 /// @see lldb::DescriptionLevel
538 //------------------------------------------------------------------
539 void GetDescription(Stream *s, lldb::DescriptionLevel level,
540 bool show_locations = false);
542 //------------------------------------------------------------------
543 /// Set the "kind" description for a breakpoint. If the breakpoint is hit
544 /// the stop info will show this "kind" description instead of the breakpoint
545 /// number. Mostly useful for internal breakpoints, where the breakpoint
547 /// doesn't have meaning to the user.
550 /// New "kind" description.
551 //------------------------------------------------------------------
552 void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); }
554 //------------------------------------------------------------------
555 /// Return the "kind" description for a breakpoint.
558 /// The breakpoint kind, or nullptr if none is set.
559 //------------------------------------------------------------------
560 const char *GetBreakpointKind() const { return m_kind_description.c_str(); }
562 //------------------------------------------------------------------
563 /// Accessor for the breakpoint Target.
565 /// This breakpoint's Target.
566 //------------------------------------------------------------------
567 Target &GetTarget() { return m_target; }
569 const Target &GetTarget() const { return m_target; }
571 const lldb::TargetSP GetTargetSP();
573 void GetResolverDescription(Stream *s);
575 //------------------------------------------------------------------
576 /// Find breakpoint locations which match the (filename, line_number)
578 /// The breakpoint location collection is to be filled with the matching
580 /// It should be initialized with 0 size by the API client.
583 /// True if there is a match
585 /// The locations which match the filename and line_number in loc_coll.
587 /// size is 0 and true is returned, it means the breakpoint fully matches
590 //------------------------------------------------------------------
591 bool GetMatchingFileLine(const ConstString &filename, uint32_t line_number,
592 BreakpointLocationCollection &loc_coll);
594 void GetFilterDescription(Stream *s);
596 //------------------------------------------------------------------
597 /// Returns the BreakpointOptions structure set at the breakpoint level.
599 /// Meant to be used by the BreakpointLocation class.
602 /// A pointer to this breakpoint's BreakpointOptions.
603 //------------------------------------------------------------------
604 BreakpointOptions *GetOptions();
606 //------------------------------------------------------------------
607 /// Returns the BreakpointOptions structure set at the breakpoint level.
609 /// Meant to be used by the BreakpointLocation class.
612 /// A pointer to this breakpoint's BreakpointOptions.
613 //------------------------------------------------------------------
614 const BreakpointOptions *GetOptions() const;
616 //------------------------------------------------------------------
617 /// Invoke the callback action when the breakpoint is hit.
619 /// Meant to be used by the BreakpointLocation class.
621 /// @param[in] context
622 /// Described the breakpoint event.
624 /// @param[in] bp_loc_id
625 /// Which breakpoint location hit this breakpoint.
628 /// \b true if the target should stop at this breakpoint and \b false not.
629 //------------------------------------------------------------------
630 bool InvokeCallback(StoppointCallbackContext *context,
631 lldb::break_id_t bp_loc_id);
633 bool IsHardware() const { return m_hardware; }
635 lldb::BreakpointResolverSP GetResolver() { return m_resolver_sp; }
637 lldb::SearchFilterSP GetSearchFilter() { return m_filter_sp; }
639 private: // The target needs to manage adding & removing names. It will do the
640 // checking for name validity as well.
641 bool AddName(llvm::StringRef new_name);
643 void RemoveName(const char *name_to_remove) {
645 m_name_list.erase(name_to_remove);
649 bool MatchesName(const char *name) {
650 return m_name_list.find(name) != m_name_list.end();
653 void GetNames(std::vector<std::string> &names) {
655 for (auto name : m_name_list) {
656 names.push_back(name);
660 //------------------------------------------------------------------
661 /// Set a pre-condition filter that overrides all user provided
662 /// filters/callbacks etc.
664 /// Used to define fancy breakpoints that can do dynamic hit detection without
665 /// taking up the condition slot -
666 /// which really belongs to the user anyway...
668 /// The Precondition should not continue the target, it should return true if
669 /// the condition says to stop and
672 //------------------------------------------------------------------
673 void SetPrecondition(BreakpointPreconditionSP precondition_sp) {
674 m_precondition_sp = precondition_sp;
677 bool EvaluatePrecondition(StoppointCallbackContext &context);
679 BreakpointPreconditionSP GetPrecondition() { return m_precondition_sp; }
681 // Produces the OR'ed values for all the names assigned to this breakpoint.
682 const BreakpointName::Permissions &GetPermissions() const {
683 return m_permissions;
686 BreakpointName::Permissions &GetPermissions() {
687 return m_permissions;
690 bool AllowList() const {
691 return GetPermissions().GetAllowList();
693 bool AllowDisable() const {
694 return GetPermissions().GetAllowDisable();
696 bool AllowDelete() const {
697 return GetPermissions().GetAllowDelete();
702 //------------------------------------------------------------------
704 //------------------------------------------------------------------
706 //------------------------------------------------------------------
707 /// Constructors and Destructors
708 /// Only the Target can make a breakpoint, and it owns the breakpoint
710 /// The constructor takes a filter and a resolver. Up in Target there are
712 /// variants that make breakpoints for some common cases.
714 /// @param[in] target
715 /// The target in which the breakpoint will be set.
717 /// @param[in] filter_sp
718 /// Shared pointer to the search filter that restricts the search domain of
721 /// @param[in] resolver_sp
722 /// Shared pointer to the resolver object that will determine breakpoint
726 /// If true, request a hardware breakpoint to be used to implement the
727 /// breakpoint locations.
729 /// @param resolve_indirect_symbols
730 /// If true, and the address of a given breakpoint location in this
731 /// breakpoint is set on an
732 /// indirect symbol (i.e. Symbol::IsIndirect returns true) then the actual
733 /// breakpoint site will
734 /// be set on the target of the indirect symbol.
735 //------------------------------------------------------------------
736 // This is the generic constructor
737 Breakpoint(Target &target, lldb::SearchFilterSP &filter_sp,
738 lldb::BreakpointResolverSP &resolver_sp, bool hardware,
739 bool resolve_indirect_symbols = true);
741 friend class BreakpointLocation; // To call the following two when determining
744 void DecrementIgnoreCount();
746 // BreakpointLocation::IgnoreCountShouldStop &
747 // Breakpoint::IgnoreCountShouldStop can only be called once per stop,
748 // and BreakpointLocation::IgnoreCountShouldStop should be tested first, and
749 // if it returns false we should
750 // continue, otherwise we should test Breakpoint::IgnoreCountShouldStop.
752 bool IgnoreCountShouldStop();
754 void IncrementHitCount() { m_hit_count++; }
756 void DecrementHitCount() {
757 assert(m_hit_count > 0);
762 // This one should only be used by Target to copy breakpoints from target to
763 // target - primarily from the dummy
764 // target to prime new targets.
765 Breakpoint(Target &new_target, Breakpoint &bp_to_copy_from);
767 //------------------------------------------------------------------
768 // For Breakpoint only
769 //------------------------------------------------------------------
770 bool m_being_created;
772 m_hardware; // If this breakpoint is required to use a hardware breakpoint
773 Target &m_target; // The target that holds this breakpoint.
774 std::unordered_set<std::string> m_name_list; // If not empty, this is the name
775 // of this breakpoint (many
776 // breakpoints can share the same
779 m_filter_sp; // The filter that constrains the breakpoint's domain.
780 lldb::BreakpointResolverSP
781 m_resolver_sp; // The resolver that defines this breakpoint.
782 BreakpointPreconditionSP m_precondition_sp; // The precondition is a
783 // breakpoint-level hit filter
785 // to skip certain breakpoint hits. For instance, exception breakpoints
786 // use this to limit the stop to certain exception classes, while leaving
787 // the condition & callback free for user specification.
788 std::unique_ptr<BreakpointOptions>
789 m_options_up; // Settable breakpoint options
790 BreakpointLocationList
791 m_locations; // The list of locations currently found for this breakpoint.
792 std::string m_kind_description;
793 bool m_resolve_indirect_symbols;
794 uint32_t m_hit_count; // Number of times this breakpoint/watchpoint has been
796 // separately from the locations hit counts, since locations can go away when
797 // their backing library gets unloaded, and we would lose hit counts.
798 BreakpointName::Permissions m_permissions;
800 void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
802 void SendBreakpointChangedEvent(BreakpointEventData *data);
804 DISALLOW_COPY_AND_ASSIGN(Breakpoint);
807 } // namespace lldb_private
809 #endif // liblldb_Breakpoint_h_