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" Class that
37 /// 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
45 /// finally a set of options for the breakpoint.
48 /// This is an object derived from SearchFilter. It manages the search for
49 /// breakpoint location matches through the symbols in the module list of the
50 /// target that owns it. It also filters out locations based on whatever
54 /// This is an object derived from BreakpointResolver. It provides a callback
55 /// to the filter that will find breakpoint locations. How it does this is
56 /// determined by what kind of resolver it is.
58 /// The Breakpoint class also provides constructors for the common breakpoint
59 /// cases which make the appropriate filter and resolver for you.
62 /// This stores the breakpoint locations that have been determined to date.
63 /// For a given breakpoint, there will be only one location with a given
64 /// address. Adding a location at an already taken address will just return
65 /// the location already at that address. Locations can be looked up by ID,
70 /// \b Enabled/Disabled
74 /// Note, these options can be set on the breakpoint, and they can also be set
75 /// on the individual locations. The options set on the breakpoint take
76 /// precedence over the options set on the individual location. So for
77 /// instance disabling the breakpoint will cause NONE of the locations to get
78 /// hit. But if the breakpoint is enabled, then the location's enabled state
79 /// will be checked to determine whether to insert that breakpoint location.
80 /// Similarly, if the breakpoint condition says "stop", we won't check the
81 /// location's condition. But if the breakpoint condition says "continue",
82 /// then we will check the location for whether to actually stop or not. One
83 /// subtle point worth observing here is that you don't actually stop at a
84 /// Breakpoint, you always stop at one of its locations. So the "should stop"
85 /// tests are done by the location, not by the breakpoint.
86 //----------------------------------------------------------------------
87 class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
90 static const ConstString &GetEventIdentifier();
92 //------------------------------------------------------------------
93 /// An enum specifying the match style for breakpoint settings. At present
94 /// only used for function name style breakpoints.
95 //------------------------------------------------------------------
96 typedef enum { Exact, Regexp, Glob } MatchType;
99 enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName };
102 *g_option_names[static_cast<uint32_t>(OptionNames::LastOptionName)];
104 static const char *GetKey(OptionNames enum_value) {
105 return g_option_names[static_cast<uint32_t>(enum_value)];
109 class BreakpointEventData : public EventData {
111 BreakpointEventData(lldb::BreakpointEventType sub_type,
112 const lldb::BreakpointSP &new_breakpoint_sp);
114 ~BreakpointEventData() override;
116 static const ConstString &GetFlavorString();
118 const ConstString &GetFlavor() const override;
120 lldb::BreakpointEventType GetBreakpointEventType() const;
122 lldb::BreakpointSP &GetBreakpoint();
124 BreakpointLocationCollection &GetBreakpointLocationCollection() {
128 void Dump(Stream *s) const override;
130 static lldb::BreakpointEventType
131 GetBreakpointEventTypeFromEvent(const lldb::EventSP &event_sp);
133 static lldb::BreakpointSP
134 GetBreakpointFromEvent(const lldb::EventSP &event_sp);
136 static lldb::BreakpointLocationSP
137 GetBreakpointLocationAtIndexFromEvent(const lldb::EventSP &event_sp,
141 GetNumBreakpointLocationsFromEvent(const lldb::EventSP &event_sp);
143 static const BreakpointEventData *
144 GetEventDataFromEvent(const Event *event_sp);
147 lldb::BreakpointEventType m_breakpoint_event;
148 lldb::BreakpointSP m_new_breakpoint_sp;
149 BreakpointLocationCollection m_locations;
151 DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
154 class BreakpointPrecondition {
156 virtual ~BreakpointPrecondition() = default;
158 virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
160 virtual Status ConfigurePrecondition(Args &options);
162 virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
165 typedef std::shared_ptr<BreakpointPrecondition> BreakpointPreconditionSP;
167 // Saving & restoring breakpoints:
168 static lldb::BreakpointSP CreateFromStructuredData(
169 Target &target, StructuredData::ObjectSP &data_object_sp, Status &error);
172 SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp,
173 std::vector<std::string> &names);
175 virtual StructuredData::ObjectSP SerializeToStructuredData();
177 static const char *GetSerializationKey() { return "Breakpoint"; }
178 //------------------------------------------------------------------
181 /// The destructor is not virtual since there should be no reason to
182 /// subclass breakpoints. The varieties of breakpoints are specified
183 /// instead by providing different resolvers & filters.
184 //------------------------------------------------------------------
185 ~Breakpoint() override;
187 //------------------------------------------------------------------
189 //------------------------------------------------------------------
191 //------------------------------------------------------------------
192 /// Tell whether this breakpoint is an "internal" breakpoint. @return
193 /// Returns \b true if this is an internal breakpoint, \b false otherwise.
194 //------------------------------------------------------------------
195 bool IsInternal() const;
197 //------------------------------------------------------------------
198 /// Standard "Dump" method. At present it does nothing.
199 //------------------------------------------------------------------
200 void Dump(Stream *s) override;
202 //------------------------------------------------------------------
203 // The next set of methods provide ways to tell the breakpoint to update it's
204 // location list - usually done when modules appear or disappear.
205 //------------------------------------------------------------------
207 //------------------------------------------------------------------
208 /// Tell this breakpoint to clear all its breakpoint sites. Done when the
209 /// process holding the breakpoint sites is destroyed.
210 //------------------------------------------------------------------
211 void ClearAllBreakpointSites();
213 //------------------------------------------------------------------
214 /// Tell this breakpoint to scan it's target's module list and resolve any
215 /// new locations that match the breakpoint's specifications.
216 //------------------------------------------------------------------
217 void ResolveBreakpoint();
219 //------------------------------------------------------------------
220 /// Tell this breakpoint to scan a given module list and resolve any new
221 /// locations that match the breakpoint's specifications.
223 /// @param[in] module_list
224 /// The list of modules to look in for new locations.
226 /// @param[in] send_event
227 /// If \b true, send a breakpoint location added event for non-internal
229 //------------------------------------------------------------------
230 void ResolveBreakpointInModules(ModuleList &module_list,
231 bool send_event = true);
233 //------------------------------------------------------------------
234 /// Tell this breakpoint to scan a given module list and resolve any new
235 /// locations that match the breakpoint's specifications.
237 /// @param[in] changed_modules
238 /// The list of modules to look in for new locations.
240 /// @param[in] new_locations
241 /// Fills new_locations with the new locations that were made.
242 //------------------------------------------------------------------
243 void ResolveBreakpointInModules(ModuleList &module_list,
244 BreakpointLocationCollection &new_locations);
246 //------------------------------------------------------------------
247 /// Like ResolveBreakpointInModules, but allows for "unload" events, in
248 /// which case we will remove any locations that are in modules that got
251 /// @param[in] changedModules
252 /// The list of modules to look in for new locations.
253 /// @param[in] load_event
254 /// If \b true then the modules were loaded, if \b false, unloaded.
255 /// @param[in] delete_locations
256 /// If \b true then the modules were unloaded delete any locations in the
258 //------------------------------------------------------------------
259 void ModulesChanged(ModuleList &changed_modules, bool load_event,
260 bool delete_locations = false);
262 //------------------------------------------------------------------
263 /// Tells the breakpoint the old module \a old_module_sp has been replaced
264 /// by new_module_sp (usually because the underlying file has been rebuilt,
265 /// and the old version is gone.)
267 /// @param[in] old_module_sp
268 /// The old module that is going away.
269 /// @param[in] new_module_sp
270 /// The new module that is replacing it.
271 //------------------------------------------------------------------
272 void ModuleReplaced(lldb::ModuleSP old_module_sp,
273 lldb::ModuleSP new_module_sp);
275 //------------------------------------------------------------------
276 // The next set of methods provide access to the breakpoint locations for
278 //------------------------------------------------------------------
280 //------------------------------------------------------------------
281 /// Add a location to the breakpoint's location list. This is only meant to
282 /// be called by the breakpoint's resolver. FIXME: how do I ensure that?
285 /// The Address specifying the new location.
286 /// @param[out] new_location
287 /// Set to \b true if a new location was created, to \b false if there
288 /// already was a location at this Address.
290 /// Returns a pointer to the new location.
291 //------------------------------------------------------------------
292 lldb::BreakpointLocationSP AddLocation(const Address &addr,
293 bool *new_location = nullptr);
295 //------------------------------------------------------------------
296 /// Find a breakpoint location by Address.
299 /// The Address specifying the location.
301 /// Returns a shared pointer to the location at \a addr. The pointer
302 /// in the shared pointer will be nullptr if there is no location at that
304 //------------------------------------------------------------------
305 lldb::BreakpointLocationSP FindLocationByAddress(const Address &addr);
307 //------------------------------------------------------------------
308 /// Find a breakpoint location ID by Address.
311 /// The Address specifying the location.
313 /// Returns the UID of the location at \a addr, or \b LLDB_INVALID_ID if
314 /// there is no breakpoint location at that address.
315 //------------------------------------------------------------------
316 lldb::break_id_t FindLocationIDByAddress(const Address &addr);
318 //------------------------------------------------------------------
319 /// Find a breakpoint location for a given breakpoint location ID.
321 /// @param[in] bp_loc_id
322 /// The ID specifying the location.
324 /// Returns a shared pointer to the location with ID \a bp_loc_id. The
326 /// in the shared pointer will be nullptr if there is no location with that
328 //------------------------------------------------------------------
329 lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id);
331 //------------------------------------------------------------------
332 /// Get breakpoint locations by index.
335 /// The location index.
338 /// Returns a shared pointer to the location with index \a
339 /// index. The shared pointer might contain nullptr if \a index is
340 /// greater than then number of actual locations.
341 //------------------------------------------------------------------
342 lldb::BreakpointLocationSP GetLocationAtIndex(size_t index);
344 //------------------------------------------------------------------
345 /// Removes all invalid breakpoint locations.
347 /// Removes all breakpoint locations with architectures that aren't
348 /// compatible with \a arch. Also remove any breakpoint locations with whose
349 /// locations have address where the section has been deleted (module and
350 /// object files no longer exist).
352 /// This is typically used after the process calls exec, or anytime the
353 /// architecture of the target changes.
356 /// If valid, check the module in each breakpoint to make sure
357 /// they are compatible, otherwise, ignore architecture.
358 //------------------------------------------------------------------
359 void RemoveInvalidLocations(const ArchSpec &arch);
361 //------------------------------------------------------------------
362 // The next section deals with various breakpoint options.
363 //------------------------------------------------------------------
365 //------------------------------------------------------------------
366 /// If \a enable is \b true, enable the breakpoint, if \b false disable it.
367 //------------------------------------------------------------------
368 void SetEnabled(bool enable) override;
370 //------------------------------------------------------------------
371 /// Check the Enable/Disable state.
373 /// \b true if the breakpoint is enabled, \b false if disabled.
374 //------------------------------------------------------------------
375 bool IsEnabled() override;
377 //------------------------------------------------------------------
378 /// Set the breakpoint to ignore the next \a count breakpoint hits.
380 /// The number of breakpoint hits to ignore.
381 //------------------------------------------------------------------
382 void SetIgnoreCount(uint32_t count);
384 //------------------------------------------------------------------
385 /// Return the current ignore count/
387 /// The number of breakpoint hits to be ignored.
388 //------------------------------------------------------------------
389 uint32_t GetIgnoreCount() const;
391 //------------------------------------------------------------------
392 /// Return the current hit count for all locations. @return
393 /// The current hit count for all locations.
394 //------------------------------------------------------------------
395 uint32_t GetHitCount() const;
397 //------------------------------------------------------------------
398 /// If \a one_shot is \b true, breakpoint will be deleted on first hit.
399 //------------------------------------------------------------------
400 void SetOneShot(bool one_shot);
402 //------------------------------------------------------------------
403 /// Check the OneShot state.
405 /// \b true if the breakpoint is one shot, \b false otherwise.
406 //------------------------------------------------------------------
407 bool IsOneShot() const;
409 //------------------------------------------------------------------
410 /// If \a auto_continue is \b true, breakpoint will auto-continue when on
412 //------------------------------------------------------------------
413 void SetAutoContinue(bool auto_continue);
415 //------------------------------------------------------------------
416 /// Check the AutoContinue state.
418 /// \b true if the breakpoint is set to auto-continue, \b false otherwise.
419 //------------------------------------------------------------------
420 bool IsAutoContinue() const;
422 //------------------------------------------------------------------
423 /// Set the valid thread to be checked when the breakpoint is hit.
424 /// @param[in] thread_id
425 /// If this thread hits the breakpoint, we stop, otherwise not.
426 //------------------------------------------------------------------
427 void SetThreadID(lldb::tid_t thread_id);
429 //------------------------------------------------------------------
430 /// Return the current stop thread value.
432 /// The thread id for which the breakpoint hit will stop,
433 /// LLDB_INVALID_THREAD_ID for all threads.
434 //------------------------------------------------------------------
435 lldb::tid_t GetThreadID() const;
437 void SetThreadIndex(uint32_t index);
439 uint32_t GetThreadIndex() const;
441 void SetThreadName(const char *thread_name);
443 const char *GetThreadName() const;
445 void SetQueueName(const char *queue_name);
447 const char *GetQueueName() const;
449 //------------------------------------------------------------------
450 /// Set the callback action invoked when the breakpoint is hit.
452 /// @param[in] callback
453 /// The method that will get called when the breakpoint is hit.
455 /// A void * pointer that will get passed back to the callback function.
456 /// @param[in] is_synchronous
457 /// If \b true the callback will be run on the private event thread
458 /// before the stop event gets reported. If false, the callback will get
459 /// handled on the public event thread after the stop has been posted.
462 /// \b true if the process should stop when you hit the breakpoint.
463 /// \b false if it should continue.
464 //------------------------------------------------------------------
465 void SetCallback(BreakpointHitCallback callback, void *baton,
466 bool is_synchronous = false);
468 void SetCallback(BreakpointHitCallback callback,
469 const lldb::BatonSP &callback_baton_sp,
470 bool is_synchronous = false);
472 void ClearCallback();
474 //------------------------------------------------------------------
475 /// Set the breakpoint's condition.
477 /// @param[in] condition
478 /// The condition expression to evaluate when the breakpoint is hit.
479 /// Pass in nullptr to clear the condition.
480 //------------------------------------------------------------------
481 void SetCondition(const char *condition);
483 //------------------------------------------------------------------
484 /// Return a pointer to the text of the condition expression.
487 /// A pointer to the condition expression text, or nullptr if no
488 // condition has been set.
489 //------------------------------------------------------------------
490 const char *GetConditionText() const;
492 //------------------------------------------------------------------
493 // The next section are various utility functions.
494 //------------------------------------------------------------------
496 //------------------------------------------------------------------
497 /// Return the number of breakpoint locations that have resolved to actual
498 /// breakpoint sites.
501 /// The number locations resolved breakpoint sites.
502 //------------------------------------------------------------------
503 size_t GetNumResolvedLocations() const;
505 //------------------------------------------------------------------
506 /// Return the number of breakpoint locations.
509 /// The number breakpoint locations.
510 //------------------------------------------------------------------
511 size_t GetNumLocations() const;
513 //------------------------------------------------------------------
514 /// Put a description of this breakpoint into the stream \a s.
517 /// Stream into which to dump the description.
520 /// The description level that indicates the detail level to
523 /// @see lldb::DescriptionLevel
524 //------------------------------------------------------------------
525 void GetDescription(Stream *s, lldb::DescriptionLevel level,
526 bool show_locations = false);
528 //------------------------------------------------------------------
529 /// Set the "kind" description for a breakpoint. If the breakpoint is hit
530 /// the stop info will show this "kind" description instead of the
531 /// breakpoint number. Mostly useful for internal breakpoints, where the
532 /// breakpoint number doesn't have meaning to the user.
535 /// New "kind" description.
536 //------------------------------------------------------------------
537 void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); }
539 //------------------------------------------------------------------
540 /// Return the "kind" description for a breakpoint.
543 /// The breakpoint kind, or nullptr if none is set.
544 //------------------------------------------------------------------
545 const char *GetBreakpointKind() const { return m_kind_description.c_str(); }
547 //------------------------------------------------------------------
548 /// Accessor for the breakpoint Target.
550 /// This breakpoint's Target.
551 //------------------------------------------------------------------
552 Target &GetTarget() { return m_target; }
554 const Target &GetTarget() const { return m_target; }
556 const lldb::TargetSP GetTargetSP();
558 void GetResolverDescription(Stream *s);
560 //------------------------------------------------------------------
561 /// Find breakpoint locations which match the (filename, line_number)
562 /// description. The breakpoint location collection is to be filled with the
563 /// matching locations. It should be initialized with 0 size by the API
567 /// True if there is a match
569 /// The locations which match the filename and line_number in loc_coll.
571 /// size is 0 and true is returned, it means the breakpoint fully matches
574 //------------------------------------------------------------------
575 bool GetMatchingFileLine(const ConstString &filename, uint32_t line_number,
576 BreakpointLocationCollection &loc_coll);
578 void GetFilterDescription(Stream *s);
580 //------------------------------------------------------------------
581 /// Returns the BreakpointOptions structure set at the breakpoint level.
583 /// Meant to be used by the BreakpointLocation class.
586 /// A pointer to this breakpoint's BreakpointOptions.
587 //------------------------------------------------------------------
588 BreakpointOptions *GetOptions();
590 //------------------------------------------------------------------
591 /// Returns the BreakpointOptions structure set at the breakpoint level.
593 /// Meant to be used by the BreakpointLocation class.
596 /// A pointer to this breakpoint's BreakpointOptions.
597 //------------------------------------------------------------------
598 const BreakpointOptions *GetOptions() const;
600 //------------------------------------------------------------------
601 /// Invoke the callback action when the breakpoint is hit.
603 /// Meant to be used by the BreakpointLocation class.
605 /// @param[in] context
606 /// Described the breakpoint event.
608 /// @param[in] bp_loc_id
609 /// Which breakpoint location hit this breakpoint.
612 /// \b true if the target should stop at this breakpoint and \b false not.
613 //------------------------------------------------------------------
614 bool InvokeCallback(StoppointCallbackContext *context,
615 lldb::break_id_t bp_loc_id);
617 bool IsHardware() const { return m_hardware; }
619 lldb::BreakpointResolverSP GetResolver() { return m_resolver_sp; }
621 lldb::SearchFilterSP GetSearchFilter() { return m_filter_sp; }
623 private: // The target needs to manage adding & removing names. It will do the
624 // checking for name validity as well.
625 bool AddName(llvm::StringRef new_name);
627 void RemoveName(const char *name_to_remove) {
629 m_name_list.erase(name_to_remove);
633 bool MatchesName(const char *name) {
634 return m_name_list.find(name) != m_name_list.end();
637 void GetNames(std::vector<std::string> &names) {
639 for (auto name : m_name_list) {
640 names.push_back(name);
644 //------------------------------------------------------------------
645 /// Set a pre-condition filter that overrides all user provided
646 /// filters/callbacks etc.
648 /// Used to define fancy breakpoints that can do dynamic hit detection
649 /// without taking up the condition slot - which really belongs to the user
652 /// The Precondition should not continue the target, it should return true
653 /// if the condition says to stop and false otherwise.
655 //------------------------------------------------------------------
656 void SetPrecondition(BreakpointPreconditionSP precondition_sp) {
657 m_precondition_sp = precondition_sp;
660 bool EvaluatePrecondition(StoppointCallbackContext &context);
662 BreakpointPreconditionSP GetPrecondition() { return m_precondition_sp; }
664 // Produces the OR'ed values for all the names assigned to this breakpoint.
665 const BreakpointName::Permissions &GetPermissions() const {
666 return m_permissions;
669 BreakpointName::Permissions &GetPermissions() {
670 return m_permissions;
673 bool AllowList() const {
674 return GetPermissions().GetAllowList();
676 bool AllowDisable() const {
677 return GetPermissions().GetAllowDisable();
679 bool AllowDelete() const {
680 return GetPermissions().GetAllowDelete();
685 //------------------------------------------------------------------
687 //------------------------------------------------------------------
689 //------------------------------------------------------------------
690 /// Constructors and Destructors
691 /// Only the Target can make a breakpoint, and it owns the breakpoint
692 /// lifespans. The constructor takes a filter and a resolver. Up in Target
693 /// there are convenience variants that make breakpoints for some common
696 /// @param[in] target
697 /// The target in which the breakpoint will be set.
699 /// @param[in] filter_sp
700 /// Shared pointer to the search filter that restricts the search domain of
703 /// @param[in] resolver_sp
704 /// Shared pointer to the resolver object that will determine breakpoint
708 /// If true, request a hardware breakpoint to be used to implement the
709 /// breakpoint locations.
711 /// @param resolve_indirect_symbols
712 /// If true, and the address of a given breakpoint location in this
713 /// breakpoint is set on an
714 /// indirect symbol (i.e. Symbol::IsIndirect returns true) then the actual
715 /// breakpoint site will
716 /// be set on the target of the indirect symbol.
717 //------------------------------------------------------------------
718 // This is the generic constructor
719 Breakpoint(Target &target, lldb::SearchFilterSP &filter_sp,
720 lldb::BreakpointResolverSP &resolver_sp, bool hardware,
721 bool resolve_indirect_symbols = true);
723 friend class BreakpointLocation; // To call the following two when determining
726 void DecrementIgnoreCount();
728 // BreakpointLocation::IgnoreCountShouldStop &
729 // Breakpoint::IgnoreCountShouldStop can only be called once per stop, and
730 // BreakpointLocation::IgnoreCountShouldStop should be tested first, and if
731 // it returns false we should continue, otherwise we should test
732 // Breakpoint::IgnoreCountShouldStop.
734 bool IgnoreCountShouldStop();
736 void IncrementHitCount() { m_hit_count++; }
738 void DecrementHitCount() {
739 assert(m_hit_count > 0);
744 // This one should only be used by Target to copy breakpoints from target to
745 // target - primarily from the dummy target to prime new targets.
746 Breakpoint(Target &new_target, Breakpoint &bp_to_copy_from);
748 //------------------------------------------------------------------
749 // For Breakpoint only
750 //------------------------------------------------------------------
751 bool m_being_created;
753 m_hardware; // If this breakpoint is required to use a hardware breakpoint
754 Target &m_target; // The target that holds this breakpoint.
755 std::unordered_set<std::string> m_name_list; // If not empty, this is the name
756 // of this breakpoint (many
757 // breakpoints can share the same
760 m_filter_sp; // The filter that constrains the breakpoint's domain.
761 lldb::BreakpointResolverSP
762 m_resolver_sp; // The resolver that defines this breakpoint.
763 BreakpointPreconditionSP m_precondition_sp; // The precondition is a
764 // breakpoint-level hit filter
766 // to skip certain breakpoint hits. For instance, exception breakpoints use
767 // this to limit the stop to certain exception classes, while leaving the
768 // condition & callback free for user specification.
769 std::unique_ptr<BreakpointOptions>
770 m_options_up; // Settable breakpoint options
771 BreakpointLocationList
772 m_locations; // The list of locations currently found for this breakpoint.
773 std::string m_kind_description;
774 bool m_resolve_indirect_symbols;
775 uint32_t m_hit_count; // Number of times this breakpoint/watchpoint has been
777 // separately from the locations hit counts, since locations can go away when
778 // their backing library gets unloaded, and we would lose hit counts.
779 BreakpointName::Permissions m_permissions;
781 void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
783 void SendBreakpointChangedEvent(BreakpointEventData *data);
785 DISALLOW_COPY_AND_ASSIGN(Breakpoint);
788 } // namespace lldb_private
790 #endif // liblldb_Breakpoint_h_