LLDB mainline
Breakpoint.h
Go to the documentation of this file.
1//===-- Breakpoint.h --------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_BREAKPOINT_BREAKPOINT_H
10#define LLDB_BREAKPOINT_BREAKPOINT_H
11
12#include <memory>
13#include <string>
14#include <unordered_set>
15#include <vector>
16
26#include "lldb/Utility/Event.h"
29
30namespace lldb_private {
31
32/// \class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that
33/// manages logical breakpoint setting.
34
35/// General Outline:
36/// A breakpoint has four main parts, a filter, a resolver, the list of
37/// breakpoint
38/// locations that have been determined for the filter/resolver pair, and
39/// finally a set of options for the breakpoint.
40///
41/// \b Filter:
42/// This is an object derived from SearchFilter. It manages the search for
43/// breakpoint location matches through the symbols in the module list of the
44/// target that owns it. It also filters out locations based on whatever
45/// logic it wants.
46///
47/// \b Resolver:
48/// This is an object derived from BreakpointResolver. It provides a callback
49/// to the filter that will find breakpoint locations. How it does this is
50/// determined by what kind of resolver it is.
51///
52/// The Breakpoint class also provides constructors for the common breakpoint
53/// cases which make the appropriate filter and resolver for you.
54///
55/// \b Location List:
56/// This stores the breakpoint locations that have been determined to date.
57/// For a given breakpoint, there will be only one location with a given
58/// address. Adding a location at an already taken address will just return
59/// the location already at that address. Locations can be looked up by ID,
60/// or by address.
61///
62/// \b Options:
63/// This includes:
64/// \b Enabled/Disabled
65/// \b Ignore Count
66/// \b Callback
67/// \b Condition
68/// Note, these options can be set on the breakpoint, and they can also be set
69/// on the individual locations. The options set on the breakpoint take
70/// precedence over the options set on the individual location. So for
71/// instance disabling the breakpoint will cause NONE of the locations to get
72/// hit. But if the breakpoint is enabled, then the location's enabled state
73/// will be checked to determine whether to insert that breakpoint location.
74/// Similarly, if the breakpoint condition says "stop", we won't check the
75/// location's condition. But if the breakpoint condition says "continue",
76/// then we will check the location for whether to actually stop or not. One
77/// subtle point worth observing here is that you don't actually stop at a
78/// Breakpoint, you always stop at one of its locations. So the "should stop"
79/// tests are done by the location, not by the breakpoint.
80class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
81 public Stoppoint {
82public:
83 static const char *
84 BreakpointEventTypeAsCString(lldb::BreakpointEventType type);
85
86 /// An enum specifying the match style for breakpoint settings. At present
87 /// only used for function name style breakpoints.
89
90private:
91 enum class OptionNames : uint32_t { Names = 0, Hardware, LastOptionName };
92
93 static const char
95
96 static const char *GetKey(OptionNames enum_value) {
97 return g_option_names[static_cast<uint32_t>(enum_value)];
98 }
99
100public:
102 public:
103 BreakpointEventData(lldb::BreakpointEventType sub_type,
104 const lldb::BreakpointSP &new_breakpoint_sp);
105
107
108 static llvm::StringRef GetFlavorString();
109
110 Log *GetLogChannel() override;
111
112 llvm::StringRef GetFlavor() const override;
113
114 lldb::BreakpointEventType GetBreakpointEventType() const;
115
117
119 return m_locations;
120 }
121
122 void Dump(Stream *s) const override;
123
124 static lldb::BreakpointEventType
126
127 static lldb::BreakpointSP
128 GetBreakpointFromEvent(const lldb::EventSP &event_sp);
129
132 uint32_t loc_idx);
133
134 static size_t
136
137 static const BreakpointEventData *
138 GetEventDataFromEvent(const Event *event_sp);
139
140 private:
141 lldb::BreakpointEventType m_breakpoint_event;
144
147 };
148
149 // Saving & restoring breakpoints:
151 lldb::TargetSP target_sp, StructuredData::ObjectSP &data_object_sp,
152 Status &error);
153
154 static bool
156 std::vector<std::string> &names);
157
159
160 static const char *GetSerializationKey() { return "Breakpoint"; }
161 /// Destructor.
162 ///
163 /// The destructor is not virtual since there should be no reason to
164 /// subclass breakpoints. The varieties of breakpoints are specified
165 /// instead by providing different resolvers & filters.
166 ~Breakpoint() override;
167
168 // Methods
169
170 /// Tell whether this breakpoint is an "internal" breakpoint. \return
171 /// Returns \b true if this is an internal breakpoint, \b false otherwise.
172 bool IsInternal() const;
173
174 /// Standard "Dump" method. At present it does nothing.
175 void Dump(Stream *s) override;
176
177 // The next set of methods provide ways to tell the breakpoint to update it's
178 // location list - usually done when modules appear or disappear.
179
180 /// Tell this breakpoint to clear all its breakpoint sites. Done when the
181 /// process holding the breakpoint sites is destroyed.
183
184 /// Tell this breakpoint to scan it's target's module list and resolve any
185 /// new locations that match the breakpoint's specifications.
186 void ResolveBreakpoint();
187
188 /// Tell this breakpoint to scan a given module list and resolve any new
189 /// locations that match the breakpoint's specifications.
190 ///
191 /// \param[in] module_list
192 /// The list of modules to look in for new locations.
193 ///
194 /// \param[in] send_event
195 /// If \b true, send a breakpoint location added event for non-internal
196 /// breakpoints.
197 void ResolveBreakpointInModules(ModuleList &module_list,
198 bool send_event = true);
199
200 /// Tell this breakpoint to scan a given module list and resolve any new
201 /// locations that match the breakpoint's specifications.
202 ///
203 /// \param[in] module_list
204 /// The list of modules to look in for new locations.
205 ///
206 /// \param[in] new_locations
207 /// Fills new_locations with the new locations that were made.
208 void ResolveBreakpointInModules(ModuleList &module_list,
209 BreakpointLocationCollection &new_locations);
210
211 /// Like ResolveBreakpointInModules, but allows for "unload" events, in
212 /// which case we will remove any locations that are in modules that got
213 /// unloaded.
214 ///
215 /// \param[in] changed_modules
216 /// The list of modules to look in for new locations.
217 /// \param[in] load_event
218 /// If \b true then the modules were loaded, if \b false, unloaded.
219 /// \param[in] delete_locations
220 /// If \b true then the modules were unloaded delete any locations in the
221 /// changed modules.
222 void ModulesChanged(ModuleList &changed_modules, bool load_event,
223 bool delete_locations = false);
224
225 /// Tells the breakpoint the old module \a old_module_sp has been replaced
226 /// by new_module_sp (usually because the underlying file has been rebuilt,
227 /// and the old version is gone.)
228 ///
229 /// \param[in] old_module_sp
230 /// The old module that is going away.
231 /// \param[in] new_module_sp
232 /// The new module that is replacing it.
233 void ModuleReplaced(lldb::ModuleSP old_module_sp,
234 lldb::ModuleSP new_module_sp);
235
236 // The next set of methods provide access to the breakpoint locations for
237 // this breakpoint.
238
239 /// Add a location to the breakpoint's location list. This is only meant to
240 /// be called by the breakpoint's resolver. FIXME: how do I ensure that?
241 ///
242 /// \param[in] addr
243 /// The Address specifying the new location.
244 /// \param[out] new_location
245 /// Set to \b true if a new location was created, to \b false if there
246 /// already was a location at this Address.
247 /// \return
248 /// Returns a pointer to the new location.
250 bool *new_location = nullptr);
251
252 /// Find a breakpoint location by Address.
253 ///
254 /// \param[in] addr
255 /// The Address specifying the location.
256 /// \return
257 /// Returns a shared pointer to the location at \a addr. The pointer
258 /// in the shared pointer will be nullptr if there is no location at that
259 /// address.
261
262 /// Find a breakpoint location ID by Address.
263 ///
264 /// \param[in] addr
265 /// The Address specifying the location.
266 /// \return
267 /// Returns the UID of the location at \a addr, or \b LLDB_INVALID_ID if
268 /// there is no breakpoint location at that address.
270
271 /// Find a breakpoint location for a given breakpoint location ID.
272 ///
273 /// \param[in] bp_loc_id
274 /// The ID specifying the location.
275 /// \return
276 /// Returns a shared pointer to the location with ID \a bp_loc_id. The
277 /// pointer
278 /// in the shared pointer will be nullptr if there is no location with that
279 /// ID.
281
282 /// Get breakpoint locations by index.
283 ///
284 /// \param[in] index
285 /// The location index.
286 ///
287 /// \return
288 /// Returns a shared pointer to the location with index \a
289 /// index. The shared pointer might contain nullptr if \a index is
290 /// greater than then number of actual locations.
292
293 /// Removes all invalid breakpoint locations.
294 ///
295 /// Removes all breakpoint locations with architectures that aren't
296 /// compatible with \a arch. Also remove any breakpoint locations with whose
297 /// locations have address where the section has been deleted (module and
298 /// object files no longer exist).
299 ///
300 /// This is typically used after the process calls exec, or anytime the
301 /// architecture of the target changes.
302 ///
303 /// \param[in] arch
304 /// If valid, check the module in each breakpoint to make sure
305 /// they are compatible, otherwise, ignore architecture.
306 void RemoveInvalidLocations(const ArchSpec &arch);
307
308 // The next section deals with various breakpoint options.
309
310 /// If \a enable is \b true, enable the breakpoint, if \b false disable it.
311 void SetEnabled(bool enable) override;
312
313 /// Check the Enable/Disable state.
314 /// \return
315 /// \b true if the breakpoint is enabled, \b false if disabled.
316 bool IsEnabled() override;
317
318 /// Set the breakpoint to ignore the next \a count breakpoint hits.
319 /// \param[in] count
320 /// The number of breakpoint hits to ignore.
321 void SetIgnoreCount(uint32_t count);
322
323 /// Return the current ignore count/
324 /// \return
325 /// The number of breakpoint hits to be ignored.
326 uint32_t GetIgnoreCount() const;
327
328 /// Return the current hit count for all locations. \return
329 /// The current hit count for all locations.
330 uint32_t GetHitCount() const;
331
332 /// Resets the current hit count for all locations.
333 void ResetHitCount();
334
335 /// If \a one_shot is \b true, breakpoint will be deleted on first hit.
336 void SetOneShot(bool one_shot);
337
338 /// Check the OneShot state.
339 /// \return
340 /// \b true if the breakpoint is one shot, \b false otherwise.
341 bool IsOneShot() const;
342
343 /// If \a auto_continue is \b true, breakpoint will auto-continue when on
344 /// hit.
345 void SetAutoContinue(bool auto_continue);
346
347 /// Check the AutoContinue state.
348 /// \return
349 /// \b true if the breakpoint is set to auto-continue, \b false otherwise.
350 bool IsAutoContinue() const;
351
352 /// Set the valid thread to be checked when the breakpoint is hit.
353 /// \param[in] thread_id
354 /// If this thread hits the breakpoint, we stop, otherwise not.
355 void SetThreadID(lldb::tid_t thread_id);
356
357 /// Return the current stop thread value.
358 /// \return
359 /// The thread id for which the breakpoint hit will stop,
360 /// LLDB_INVALID_THREAD_ID for all threads.
361 lldb::tid_t GetThreadID() const;
362
363 void SetThreadIndex(uint32_t index);
364
365 uint32_t GetThreadIndex() const;
366
367 void SetThreadName(const char *thread_name);
368
369 const char *GetThreadName() const;
370
371 void SetQueueName(const char *queue_name);
372
373 const char *GetQueueName() const;
374
375 /// Set the callback action invoked when the breakpoint is hit.
376 ///
377 /// \param[in] callback
378 /// The method that will get called when the breakpoint is hit.
379 /// \param[in] baton
380 /// A void * pointer that will get passed back to the callback function.
381 /// \param[in] is_synchronous
382 /// If \b true the callback will be run on the private event thread
383 /// before the stop event gets reported. If false, the callback will get
384 /// handled on the public event thread while the stop event is being
385 /// pulled off the event queue.
386 /// Note: synchronous callbacks cannot cause the target to run, in
387 /// particular, they should not try to run the expression evaluator.
388 void SetCallback(BreakpointHitCallback callback, void *baton,
389 bool is_synchronous = false);
390
392 const lldb::BatonSP &callback_baton_sp,
393 bool is_synchronous = false);
394
395 void ClearCallback();
396
397 /// Set the breakpoint's condition.
398 ///
399 /// \param[in] condition
400 /// The condition expression to evaluate when the breakpoint is hit.
401 /// Pass in nullptr to clear the condition.
402 void SetCondition(const char *condition);
403
404 /// Return a pointer to the text of the condition expression.
405 ///
406 /// \return
407 /// A pointer to the condition expression text, or nullptr if no
408 // condition has been set.
409 const char *GetConditionText() const;
410
411 // The next section are various utility functions.
412
413 /// Return the number of breakpoint locations that have resolved to actual
414 /// breakpoint sites.
415 ///
416 /// \return
417 /// The number locations resolved breakpoint sites.
418 size_t GetNumResolvedLocations() const;
419
420 /// Return whether this breakpoint has any resolved locations.
421 ///
422 /// \return
423 /// True if GetNumResolvedLocations > 0
424 bool HasResolvedLocations() const;
425
426 /// Return the number of breakpoint locations.
427 ///
428 /// \return
429 /// The number breakpoint locations.
430 size_t GetNumLocations() const;
431
432 /// Put a description of this breakpoint into the stream \a s.
433 ///
434 /// \param[in] s
435 /// Stream into which to dump the description.
436 ///
437 /// \param[in] level
438 /// The description level that indicates the detail level to
439 /// provide.
440 ///
441 /// \see lldb::DescriptionLevel
443 bool show_locations = false);
444
445 /// Set the "kind" description for a breakpoint. If the breakpoint is hit
446 /// the stop info will show this "kind" description instead of the
447 /// breakpoint number. Mostly useful for internal breakpoints, where the
448 /// breakpoint number doesn't have meaning to the user.
449 ///
450 /// \param[in] kind
451 /// New "kind" description.
452 void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); }
453
454 /// Return the "kind" description for a breakpoint.
455 ///
456 /// \return
457 /// The breakpoint kind, or nullptr if none is set.
458 const char *GetBreakpointKind() const { return m_kind_description.c_str(); }
459
460 /// Accessor for the breakpoint Target.
461 /// \return
462 /// This breakpoint's Target.
463 Target &GetTarget() { return m_target; }
464
465 const Target &GetTarget() const { return m_target; }
466
468
470
471 /// Find breakpoint locations which match the (filename, line_number)
472 /// description. The breakpoint location collection is to be filled with the
473 /// matching locations. It should be initialized with 0 size by the API
474 /// client.
475 ///
476 /// \return
477 /// True if there is a match
478 ///
479 /// The locations which match the filename and line_number in loc_coll.
480 /// If its
481 /// size is 0 and true is returned, it means the breakpoint fully matches
482 /// the
483 /// description.
484 bool GetMatchingFileLine(ConstString filename, uint32_t line_number,
486
488
489 /// Returns the BreakpointOptions structure set at the breakpoint level.
490 ///
491 /// Meant to be used by the BreakpointLocation class.
492 ///
493 /// \return
494 /// A reference to this breakpoint's BreakpointOptions.
496
497 /// Returns the BreakpointOptions structure set at the breakpoint level.
498 ///
499 /// Meant to be used by the BreakpointLocation class.
500 ///
501 /// \return
502 /// A reference to this breakpoint's BreakpointOptions.
503 const BreakpointOptions &GetOptions() const;
504
505 /// Invoke the callback action when the breakpoint is hit.
506 ///
507 /// Meant to be used by the BreakpointLocation class.
508 ///
509 /// \param[in] context
510 /// Described the breakpoint event.
511 ///
512 /// \param[in] bp_loc_id
513 /// Which breakpoint location hit this breakpoint.
514 ///
515 /// \return
516 /// \b true if the target should stop at this breakpoint and \b false not.
518 lldb::break_id_t bp_loc_id);
519
520 bool IsHardware() const { return m_hardware; }
521
523
525
526private:
527 void AddName(llvm::StringRef new_name);
528
529 void RemoveName(const char *name_to_remove) {
530 if (name_to_remove)
531 m_name_list.erase(name_to_remove);
532 }
533
534public:
535 bool MatchesName(const char *name) {
536 return m_name_list.find(name) != m_name_list.end();
537 }
538
539 void GetNames(std::vector<std::string> &names) {
540 names.clear();
541 for (auto name : m_name_list) {
542 names.push_back(name);
543 }
544 }
545
546 /// Set a pre-condition filter that overrides all user provided
547 /// filters/callbacks etc.
548 ///
549 /// Used to define fancy breakpoints that can do dynamic hit detection
550 /// without taking up the condition slot - which really belongs to the user
551 /// anyway...
552 ///
553 /// The Precondition should not continue the target, it should return true
554 /// if the condition says to stop and false otherwise.
555 ///
557 m_precondition_sp = std::move(precondition_sp);
558 }
559
561
563
564 // Produces the OR'ed values for all the names assigned to this breakpoint.
566 return m_permissions;
567 }
568
570 return m_permissions;
571 }
572
573 bool AllowList() const {
574 return GetPermissions().GetAllowList();
575 }
576 bool AllowDisable() const {
578 }
579 bool AllowDelete() const {
581 }
582
583 // This one should only be used by Target to copy breakpoints from target to
584 // target - primarily from the dummy target to prime new targets.
586 const Breakpoint &bp_to_copy_from);
587
588 /// Get statistics associated with this breakpoint in JSON format.
589 llvm::json::Value GetStatistics();
590
591 /// Get the time it took to resolve all locations in this breakpoint.
593
594protected:
595 friend class Target;
596 // Protected Methods
597
598 /// Constructors and Destructors
599 /// Only the Target can make a breakpoint, and it owns the breakpoint
600 /// lifespans. The constructor takes a filter and a resolver. Up in Target
601 /// there are convenience variants that make breakpoints for some common
602 /// cases.
603 ///
604 /// \param[in] target
605 /// The target in which the breakpoint will be set.
606 ///
607 /// \param[in] filter_sp
608 /// Shared pointer to the search filter that restricts the search domain of
609 /// the breakpoint.
610 ///
611 /// \param[in] resolver_sp
612 /// Shared pointer to the resolver object that will determine breakpoint
613 /// matches.
614 ///
615 /// \param hardware
616 /// If true, request a hardware breakpoint to be used to implement the
617 /// breakpoint locations.
618 ///
619 /// \param resolve_indirect_symbols
620 /// If true, and the address of a given breakpoint location in this
621 /// breakpoint is set on an
622 /// indirect symbol (i.e. Symbol::IsIndirect returns true) then the actual
623 /// breakpoint site will
624 /// be set on the target of the indirect symbol.
625 // This is the generic constructor
626 Breakpoint(Target &target, lldb::SearchFilterSP &filter_sp,
627 lldb::BreakpointResolverSP &resolver_sp, bool hardware,
628 bool resolve_indirect_symbols = true);
629
630 friend class BreakpointLocation; // To call the following two when determining
631 // whether to stop.
632
634
635private:
636 // To call from CopyFromBreakpoint.
637 Breakpoint(Target &new_target, const Breakpoint &bp_to_copy_from);
638
639 // For Breakpoint only
640 bool
641 m_hardware; // If this breakpoint is required to use a hardware breakpoint
642 Target &m_target; // The target that holds this breakpoint.
643 std::unordered_set<std::string> m_name_list; // If not empty, this is the name
644 // of this breakpoint (many
645 // breakpoints can share the same
646 // name.)
648 m_filter_sp; // The filter that constrains the breakpoint's domain.
650 m_resolver_sp; // The resolver that defines this breakpoint.
652 // breakpoint-level hit
653 // filter that can be used
654 // to skip certain breakpoint hits. For instance, exception breakpoints use
655 // this to limit the stop to certain exception classes, while leaving the
656 // condition & callback free for user specification.
657 BreakpointOptions m_options; // Settable breakpoint options
659 m_locations; // The list of locations currently found for this breakpoint.
662
663 /// Number of times this breakpoint has been hit. This is kept separately
664 /// from the locations hit counts, since locations can go away when their
665 /// backing library gets unloaded, and we would lose hit counts.
667
669
671
672 void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
673
674 void SendBreakpointChangedEvent(const lldb::EventDataSP &breakpoint_data_sp);
675
676 Breakpoint(const Breakpoint &) = delete;
677 const Breakpoint &operator=(const Breakpoint &) = delete;
678};
679
680} // namespace lldb_private
681
682#endif // LLDB_BREAKPOINT_BREAKPOINT_H
static llvm::raw_ostream & error(Stream &strm)
A section + offset based address class.
Definition: Address.h:62
An architecture specification class.
Definition: ArchSpec.h:31
"lldb/Breakpoint/BreakpointLocationList.h" This class is used by Breakpoint to manage a list of break...
General Outline: A breakpoint location is defined by the breakpoint that produces it,...
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
BreakpointEventData(lldb::BreakpointEventType sub_type, const lldb::BreakpointSP &new_breakpoint_sp)
void Dump(Stream *s) const override
BreakpointLocationCollection m_locations
Definition: Breakpoint.h:143
static lldb::BreakpointEventType GetBreakpointEventTypeFromEvent(const lldb::EventSP &event_sp)
lldb::BreakpointEventType m_breakpoint_event
Definition: Breakpoint.h:141
BreakpointLocationCollection & GetBreakpointLocationCollection()
Definition: Breakpoint.h:118
static lldb::BreakpointLocationSP GetBreakpointLocationAtIndexFromEvent(const lldb::EventSP &event_sp, uint32_t loc_idx)
const BreakpointEventData & operator=(const BreakpointEventData &)=delete
static lldb::BreakpointSP GetBreakpointFromEvent(const lldb::EventSP &event_sp)
llvm::StringRef GetFlavor() const override
lldb::BreakpointEventType GetBreakpointEventType() const
static const BreakpointEventData * GetEventDataFromEvent(const Event *event_sp)
static size_t GetNumBreakpointLocationsFromEvent(const lldb::EventSP &event_sp)
BreakpointEventData(const BreakpointEventData &)=delete
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:81
void RemoveInvalidLocations(const ArchSpec &arch)
Removes all invalid breakpoint locations.
Definition: Breakpoint.cpp:273
virtual StructuredData::ObjectSP SerializeToStructuredData()
Definition: Breakpoint.cpp:74
lldb::BreakpointLocationSP AddLocation(const Address &addr, bool *new_location=nullptr)
Add a location to the breakpoint's location list.
Definition: Breakpoint.cpp:251
bool AllowDelete() const
Definition: Breakpoint.h:579
uint32_t GetThreadIndex() const
Definition: Breakpoint.cpp:359
StatsDuration m_resolve_time
Definition: Breakpoint.h:670
bool IsAutoContinue() const
Check the AutoContinue state.
Definition: Breakpoint.cpp:330
void SetOneShot(bool one_shot)
If one_shot is true, breakpoint will be deleted on first hit.
Definition: Breakpoint.cpp:328
void ModuleReplaced(lldb::ModuleSP old_module_sp, lldb::ModuleSP new_module_sp)
Tells the breakpoint the old module old_module_sp has been replaced by new_module_sp (usually because...
Definition: Breakpoint.cpp:637
~Breakpoint() override
Destructor.
lldb::tid_t GetThreadID() const
Return the current stop thread value.
Definition: Breakpoint.cpp:344
llvm::json::Value GetStatistics()
Get statistics associated with this breakpoint in JSON format.
void SetAutoContinue(bool auto_continue)
If auto_continue is true, breakpoint will auto-continue when on hit.
Definition: Breakpoint.cpp:332
bool InvokeCallback(StoppointCallbackContext *context, lldb::break_id_t bp_loc_id)
Invoke the callback action when the breakpoint is hit.
Definition: Breakpoint.cpp:428
StoppointHitCounter m_hit_counter
Number of times this breakpoint has been hit.
Definition: Breakpoint.h:666
static const char * GetKey(OptionNames enum_value)
Definition: Breakpoint.h:96
uint32_t GetIgnoreCount() const
Return the current ignore count/.
Definition: Breakpoint.cpp:315
const Breakpoint & operator=(const Breakpoint &)=delete
void RemoveName(const char *name_to_remove)
Definition: Breakpoint.h:529
bool EvaluatePrecondition(StoppointCallbackContext &context)
Definition: Breakpoint.cpp:970
void SetThreadIndex(uint32_t index)
Definition: Breakpoint.cpp:351
const char * GetConditionText() const
Return a pointer to the text of the condition expression.
Definition: Breakpoint.cpp:403
const BreakpointName::Permissions & GetPermissions() const
Definition: Breakpoint.h:565
const char * GetQueueName() const
Definition: Breakpoint.cpp:391
lldb::BreakpointPreconditionSP GetPrecondition()
Definition: Breakpoint.h:562
const lldb::TargetSP GetTargetSP()
Definition: Breakpoint.cpp:245
static lldb::BreakpointSP CreateFromStructuredData(lldb::TargetSP target_sp, StructuredData::ObjectSP &data_object_sp, Status &error)
Definition: Breakpoint.cpp:122
lldb::SearchFilterSP GetSearchFilter()
Definition: Breakpoint.h:524
void ResetHitCount()
Resets the current hit count for all locations.
Definition: Breakpoint.cpp:321
BreakpointLocationList m_locations
Definition: Breakpoint.h:659
Breakpoint(const Breakpoint &)=delete
const char * GetBreakpointKind() const
Return the "kind" description for a breakpoint.
Definition: Breakpoint.h:458
const Target & GetTarget() const
Definition: Breakpoint.h:465
bool IsEnabled() override
Check the Enable/Disable state.
Definition: Breakpoint.cpp:299
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_locations=false)
Put a description of this breakpoint into the stream s.
Definition: Breakpoint.cpp:836
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:452
void ClearAllBreakpointSites()
Tell this breakpoint to clear all its breakpoint sites.
Definition: Breakpoint.cpp:474
BreakpointOptions & GetOptions()
Returns the BreakpointOptions structure set at the breakpoint level.
Definition: Breakpoint.cpp:433
bool AllowList() const
Definition: Breakpoint.h:573
void SetQueueName(const char *queue_name)
Definition: Breakpoint.cpp:382
void SetPrecondition(lldb::BreakpointPreconditionSP precondition_sp)
Set a pre-condition filter that overrides all user provided filters/callbacks etc.
Definition: Breakpoint.h:556
lldb::BreakpointResolverSP GetResolver()
Definition: Breakpoint.h:522
lldb::break_id_t FindLocationIDByAddress(const Address &addr)
Find a breakpoint location ID by Address.
Definition: Breakpoint.cpp:261
void ResolveBreakpointInModules(ModuleList &module_list, bool send_event=true)
Tell this breakpoint to scan a given module list and resolve any new locations that match the breakpo...
Definition: Breakpoint.cpp:454
static lldb::BreakpointSP CopyFromBreakpoint(lldb::TargetSP new_target, const Breakpoint &bp_to_copy_from)
Definition: Breakpoint.cpp:61
bool HasResolvedLocations() const
Return whether this breakpoint has any resolved locations.
Definition: Breakpoint.cpp:826
void AddName(llvm::StringRef new_name)
Definition: Breakpoint.cpp:832
bool IsHardware() const
Definition: Breakpoint.h:520
lldb::BreakpointLocationSP FindLocationByAddress(const Address &addr)
Find a breakpoint location by Address.
Definition: Breakpoint.cpp:257
static const char * g_option_names[static_cast< uint32_t >(OptionNames::LastOptionName)]
Definition: Breakpoint.h:94
BreakpointName::Permissions & GetPermissions()
Definition: Breakpoint.h:569
void GetResolverDescription(Stream *s)
Definition: Breakpoint.cpp:938
static const char * GetSerializationKey()
Definition: Breakpoint.h:160
void ModulesChanged(ModuleList &changed_modules, bool load_event, bool delete_locations=false)
Like ResolveBreakpointInModules, but allows for "unload" events, in which case we will remove any loc...
Definition: Breakpoint.cpp:480
static bool SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp, std::vector< std::string > &names)
Definition: Breakpoint.cpp:214
std::unordered_set< std::string > m_name_list
Definition: Breakpoint.h:643
BreakpointName::Permissions m_permissions
Definition: Breakpoint.h:668
const char * GetThreadName() const
Definition: Breakpoint.cpp:375
bool GetMatchingFileLine(ConstString filename, uint32_t line_number, BreakpointLocationCollection &loc_coll)
Find breakpoint locations which match the (filename, line_number) description.
Definition: Breakpoint.cpp:943
lldb::BreakpointLocationSP FindLocationByID(lldb::break_id_t bp_loc_id)
Find a breakpoint location for a given breakpoint location ID.
Definition: Breakpoint.cpp:265
void SetCondition(const char *condition)
Set the breakpoint's condition.
Definition: Breakpoint.cpp:398
void SetThreadID(lldb::tid_t thread_id)
Set the valid thread to be checked when the breakpoint is hit.
Definition: Breakpoint.cpp:336
void GetFilterDescription(Stream *s)
Definition: Breakpoint.cpp:966
void GetNames(std::vector< std::string > &names)
Definition: Breakpoint.h:539
void ResolveBreakpoint()
Tell this breakpoint to scan it's target's module list and resolve any new locations that match the b...
Definition: Breakpoint.cpp:437
lldb::BreakpointLocationSP GetLocationAtIndex(size_t index)
Get breakpoint locations by index.
Definition: Breakpoint.cpp:269
lldb::BreakpointPreconditionSP m_precondition_sp
Definition: Breakpoint.h:651
BreakpointOptions m_options
Definition: Breakpoint.h:657
MatchType
An enum specifying the match style for breakpoint settings.
Definition: Breakpoint.h:88
Target & GetTarget()
Accessor for the breakpoint Target.
Definition: Breakpoint.h:463
size_t GetNumLocations() const
Return the number of breakpoint locations.
Definition: Breakpoint.cpp:830
void SetIgnoreCount(uint32_t count)
Set the breakpoint to ignore the next count breakpoint hits.
Definition: Breakpoint.cpp:301
bool IsOneShot() const
Check the OneShot state.
Definition: Breakpoint.cpp:326
uint32_t GetHitCount() const
Return the current hit count for all locations.
Definition: Breakpoint.cpp:319
static const char * BreakpointEventTypeAsCString(lldb::BreakpointEventType type)
Definition: Breakpoint.cpp:999
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:408
StatsDuration::Duration GetResolveTime() const
Get the time it took to resolve all locations in this breakpoint.
Definition: Breakpoint.h:592
void SetEnabled(bool enable) override
If enable is true, enable the breakpoint, if false disable it.
Definition: Breakpoint.cpp:285
lldb::BreakpointResolverSP m_resolver_sp
Definition: Breakpoint.h:650
void Dump(Stream *s) override
Standard "Dump" method. At present it does nothing.
Definition: Breakpoint.cpp:818
bool IsInternal() const
Tell whether this breakpoint is an "internal" breakpoint.
Definition: Breakpoint.cpp:249
lldb::SearchFilterSP m_filter_sp
Definition: Breakpoint.h:648
bool MatchesName(const char *name)
Definition: Breakpoint.h:535
void SetThreadName(const char *thread_name)
Definition: Breakpoint.cpp:366
size_t GetNumResolvedLocations() const
Return the number of breakpoint locations that have resolved to actual breakpoint sites.
Definition: Breakpoint.cpp:820
bool AllowDisable() const
Definition: Breakpoint.h:576
std::string m_kind_description
Definition: Breakpoint.h:660
void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind)
Definition: Breakpoint.cpp:977
A uniqued constant string class.
Definition: ConstString.h:40
A collection class for Module objects.
Definition: ModuleList.h:103
std::chrono::duration< double > Duration
Definition: Statistics.h:31
An error handling class.
Definition: Status.h:44
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
std::shared_ptr< Object > ObjectSP
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
bool(* BreakpointHitCallback)(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
std::shared_ptr< lldb_private::SearchFilter > SearchFilterSP
Definition: lldb-forward.h:410
std::shared_ptr< lldb_private::BreakpointResolver > BreakpointResolverSP
Definition: lldb-forward.h:320
std::shared_ptr< lldb_private::BreakpointLocation > BreakpointLocationSP
Definition: lldb-forward.h:316
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
Definition: lldb-forward.h:313
int32_t break_id_t
Definition: lldb-types.h:86
std::shared_ptr< lldb_private::Baton > BatonSP
Definition: lldb-forward.h:311
std::shared_ptr< lldb_private::BreakpointPrecondition > BreakpointPreconditionSP
Definition: lldb-forward.h:319
std::shared_ptr< lldb_private::Event > EventSP
Definition: lldb-forward.h:337
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
uint64_t tid_t
Definition: lldb-types.h:84
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
std::shared_ptr< lldb_private::EventData > EventDataSP
Definition: lldb-forward.h:338