LLDB  mainline
BreakpointLocation.h
Go to the documentation of this file.
1 //===-- BreakpointLocation.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_BREAKPOINTLOCATION_H
10 #define LLDB_BREAKPOINT_BREAKPOINTLOCATION_H
11 
12 #include <memory>
13 #include <mutex>
14 
17 #include "lldb/Core/Address.h"
18 #include "lldb/Utility/UserID.h"
19 #include "lldb/lldb-private.h"
20 
21 namespace lldb_private {
22 
23 /// \class BreakpointLocation BreakpointLocation.h
24 /// "lldb/Breakpoint/BreakpointLocation.h" Class that manages one unique (by
25 /// address) instance of a logical breakpoint.
26 
27 /// General Outline:
28 /// A breakpoint location is defined by the breakpoint that produces it,
29 /// and the address that resulted in this particular instantiation. Each
30 /// breakpoint location also may have a breakpoint site if its address has
31 /// been loaded into the program. Finally it has a settable options object.
32 ///
33 /// FIXME: Should we also store some fingerprint for the location, so
34 /// we can map one location to the "equivalent location" on rerun? This would
35 /// be useful if you've set options on the locations.
36 
38  : public std::enable_shared_from_this<BreakpointLocation> {
39 public:
41 
42  /// Gets the load address for this breakpoint location \return
43  /// Returns breakpoint location load address, \b
44  /// LLDB_INVALID_ADDRESS if not yet set.
46 
47  /// Gets the Address for this breakpoint location \return
48  /// Returns breakpoint location Address.
50  /// Gets the Breakpoint that created this breakpoint location \return
51  /// Returns the owning breakpoint.
53 
54  Target &GetTarget();
55 
56  /// Determines whether we should stop due to a hit at this breakpoint
57  /// location.
58  ///
59  /// Side Effects: This may evaluate the breakpoint condition, and run the
60  /// callback. So this command may do a considerable amount of work.
61  ///
62  /// \return
63  /// \b true if this breakpoint location thinks we should stop,
64  /// \b false otherwise.
65  bool ShouldStop(StoppointCallbackContext *context);
66 
67  // The next section deals with various breakpoint options.
68 
69  /// If \a enabled is \b true, enable the breakpoint, if \b false disable it.
70  void SetEnabled(bool enabled);
71 
72  /// Check the Enable/Disable state.
73  ///
74  /// \return
75  /// \b true if the breakpoint is enabled, \b false if disabled.
76  bool IsEnabled() const;
77 
78  /// If \a auto_continue is \b true, set the breakpoint to continue when hit.
79  void SetAutoContinue(bool auto_continue);
80 
81  /// Check the AutoContinue state.
82  ///
83  /// \return
84  /// \b true if the breakpoint is set to auto-continue, \b false if not.
85  bool IsAutoContinue() const;
86 
87  /// Return the current Hit Count.
89 
90  /// Return the current Ignore Count.
91  ///
92  /// \return
93  /// The number of breakpoint hits to be ignored.
94  uint32_t GetIgnoreCount() const;
95 
96  /// Set the breakpoint to ignore the next \a count breakpoint hits.
97  ///
98  /// \param[in] n
99  /// The number of breakpoint hits to ignore.
100  void SetIgnoreCount(uint32_t n);
101 
102  /// Set the callback action invoked when the breakpoint is hit.
103  ///
104  /// The callback will return a bool indicating whether the target should
105  /// stop at this breakpoint or not.
106  ///
107  /// \param[in] callback
108  /// The method that will get called when the breakpoint is hit.
109  ///
110  /// \param[in] callback_baton_sp
111  /// A shared pointer to a Baton that provides the void * needed
112  /// for the callback.
113  ///
114  /// \see lldb_private::Baton
115  void SetCallback(BreakpointHitCallback callback,
116  const lldb::BatonSP &callback_baton_sp, bool is_synchronous);
117 
118  void SetCallback(BreakpointHitCallback callback, void *baton,
119  bool is_synchronous);
120 
121  void ClearCallback();
122 
123  /// Set the breakpoint location's condition.
124  ///
125  /// \param[in] condition
126  /// The condition expression to evaluate when the breakpoint is hit.
127  void SetCondition(const char *condition);
128 
129  /// Return a pointer to the text of the condition expression.
130  ///
131  /// \return
132  /// A pointer to the condition expression text, or nullptr if no
133  // condition has been set.
134  const char *GetConditionText(size_t *hash = nullptr) const;
135 
137 
138  /// Set the valid thread to be checked when the breakpoint is hit.
139  ///
140  /// \param[in] thread_id
141  /// If this thread hits the breakpoint, we stop, otherwise not.
142  void SetThreadID(lldb::tid_t thread_id);
143 
145 
146  void SetThreadIndex(uint32_t index);
147 
148  uint32_t GetThreadIndex() const;
149 
150  void SetThreadName(const char *thread_name);
151 
152  const char *GetThreadName() const;
153 
154  void SetQueueName(const char *queue_name);
155 
156  const char *GetQueueName() const;
157 
158  // The next section deals with this location's breakpoint sites.
159 
160  /// Try to resolve the breakpoint site for this location.
161  ///
162  /// \return
163  /// \b true if we were successful at setting a breakpoint site,
164  /// \b false otherwise.
165  bool ResolveBreakpointSite();
166 
167  /// Clear this breakpoint location's breakpoint site - for instance when
168  /// disabling the breakpoint.
169  ///
170  /// \return
171  /// \b true if there was a breakpoint site to be cleared, \b false
172  /// otherwise.
173  bool ClearBreakpointSite();
174 
175  /// Return whether this breakpoint location has a breakpoint site. \return
176  /// \b true if there was a breakpoint site for this breakpoint
177  /// location, \b false otherwise.
178  bool IsResolved() const;
179 
180  lldb::BreakpointSiteSP GetBreakpointSite() const;
181 
182  // The next section are generic report functions.
183 
184  /// Print a description of this breakpoint location to the stream \a s.
185  ///
186  /// \param[in] s
187  /// The stream to which to print the description.
188  ///
189  /// \param[in] level
190  /// The description level that indicates the detail level to
191  /// provide.
192  ///
193  /// \see lldb::DescriptionLevel
195 
196  /// Standard "Dump" method. At present it does nothing.
197  void Dump(Stream *s) const;
198 
199  /// Use this to set location specific breakpoint options.
200  ///
201  /// It will create a copy of the containing breakpoint's options if that
202  /// hasn't been done already
203  ///
204  /// \return
205  /// A reference to the breakpoint options.
207 
208  /// Use this to access breakpoint options from this breakpoint location.
209  /// This will return the options that have a setting for the specified
210  /// BreakpointOptions kind.
211  ///
212  /// \param[in] kind
213  /// The particular option you are looking up.
214  /// \return
215  /// A pointer to the containing breakpoint's options if this
216  /// location doesn't have its own copy.
217  const BreakpointOptions &
219 
220  bool ValidForThisThread(Thread &thread);
221 
222  /// Invoke the callback action when the breakpoint is hit.
223  ///
224  /// Meant to be used by the BreakpointLocation class.
225  ///
226  /// \param[in] context
227  /// Described the breakpoint event.
228  ///
229  /// \return
230  /// \b true if the target should stop at this breakpoint and \b
231  /// false not.
233 
234  /// Report whether the callback for this location is synchronous or not.
235  ///
236  /// \return
237  /// \b true if the callback is synchronous and \b false if not.
238  bool IsCallbackSynchronous();
239 
240  /// Returns whether we should resolve Indirect functions in setting the
241  /// breakpoint site for this location.
242  ///
243  /// \return
244  /// \b true if the breakpoint SITE for this location should be set on the
245  /// resolved location for Indirect functions.
248  }
249 
250  /// Returns whether the address set in the breakpoint site for this location
251  /// was found by resolving an indirect symbol.
252  ///
253  /// \return
254  /// \b true or \b false as given in the description above.
255  bool IsIndirect() { return m_is_indirect; }
256 
257  void SetIsIndirect(bool is_indirect) { m_is_indirect = is_indirect; }
258 
259  /// Returns whether the address set in the breakpoint location was re-routed
260  /// to the target of a re-exported symbol.
261  ///
262  /// \return
263  /// \b true or \b false as given in the description above.
264  bool IsReExported() { return m_is_reexported; }
265 
266  void SetIsReExported(bool is_reexported) { m_is_reexported = is_reexported; }
267 
268  /// Returns whether the two breakpoint locations might represent "equivalent
269  /// locations". This is used when modules changed to determine if a Location
270  /// in the old module might be the "same as" the input location.
271  ///
272  /// \param[in] location
273  /// The location to compare against.
274  ///
275  /// \return
276  /// \b true or \b false as given in the description above.
278 
279  /// Returns the breakpoint location ID.
280  lldb::break_id_t GetID() const { return m_loc_id; }
281 
282 protected:
283  friend class BreakpointSite;
285  friend class Process;
286  friend class StopInfoBreakpoint;
287 
288  /// Set the breakpoint site for this location to \a bp_site_sp.
289  ///
290  /// \param[in] bp_site_sp
291  /// The breakpoint site we are setting for this location.
292  ///
293  /// \return
294  /// \b true if we were successful at setting the breakpoint site,
295  /// \b false otherwise.
296  bool SetBreakpointSite(lldb::BreakpointSiteSP &bp_site_sp);
297 
298  void DecrementIgnoreCount();
299 
300  /// BreakpointLocation::IgnoreCountShouldStop can only be called once
301  /// per stop. This method checks first against the loc and then the owner.
302  /// It also takes care of decrementing the ignore counters.
303  /// If it returns false we should continue, otherwise stop.
304  bool IgnoreCountShouldStop();
305 
306 private:
307  void SwapLocation(lldb::BreakpointLocationSP swap_from);
308 
309  void BumpHitCount();
310 
311  void UndoBumpHitCount();
312 
313  // Constructors and Destructors
314  //
315  // Only the Breakpoint can make breakpoint locations, and it owns them.
316 
317  /// Constructor.
318  ///
319  /// \param[in] owner
320  /// A back pointer to the breakpoint that owns this location.
321  ///
322  /// \param[in] addr
323  /// The Address defining this location.
324  ///
325  /// \param[in] tid
326  /// The thread for which this breakpoint location is valid, or
327  /// LLDB_INVALID_THREAD_ID if it is valid for all threads.
328  ///
329  /// \param[in] hardware
330  /// \b true if a hardware breakpoint is requested.
331 
333  const Address &addr, lldb::tid_t tid, bool hardware,
334  bool check_for_resolver = true);
335 
336  // Data members:
341  Address m_address; ///< The address defining this location.
342  Breakpoint &m_owner; ///< The breakpoint that produced this object.
343  std::unique_ptr<BreakpointOptions> m_options_up; ///< Breakpoint options
344  /// pointer, nullptr if we're
345  /// using our breakpoint's
346  /// options.
347  lldb::BreakpointSiteSP m_bp_site_sp; ///< Our breakpoint site (it may be
348  ///shared by more than one location.)
349  lldb::UserExpressionSP m_user_expression_sp; ///< The compiled expression to
350  ///use in testing our condition.
351  std::mutex m_condition_mutex; ///< Guards parsing and evaluation of the
352  ///condition, which could be evaluated by
353  /// multiple processes.
354  size_t m_condition_hash; ///< For testing whether the condition source code
355  ///changed.
356  lldb::break_id_t m_loc_id; ///< Breakpoint location ID.
357  StoppointHitCounter m_hit_counter; ///< Number of times this breakpoint
358  /// location has been hit.
359 
360  void SetShouldResolveIndirectFunctions(bool do_resolve) {
362  }
363 
364  void SendBreakpointLocationChangedEvent(lldb::BreakpointEventType eventKind);
365 
366  BreakpointLocation(const BreakpointLocation &) = delete;
367  const BreakpointLocation &operator=(const BreakpointLocation &) = delete;
368 };
369 
370 } // namespace lldb_private
371 
372 #endif // LLDB_BREAKPOINT_BREAKPOINTLOCATION_H
lldb_private::BreakpointLocation::GetConditionText
const char * GetConditionText(size_t *hash=nullptr) const
Return a pointer to the text of the condition expression.
Definition: BreakpointLocation.cpp:229
lldb_private::BreakpointLocation::SetThreadID
void SetThreadID(lldb::tid_t thread_id)
Set the valid thread to be checked when the breakpoint is hit.
Definition: BreakpointLocation.cpp:102
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::BreakpointLocation::~BreakpointLocation
~BreakpointLocation()
Definition: BreakpointLocation.cpp:49
lldb_private::StoppointCallbackContext
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
Definition: StoppointCallbackContext.h:26
lldb_private::BreakpointLocation::m_bp_site_sp
lldb::BreakpointSiteSP m_bp_site_sp
Our breakpoint site (it may be shared by more than one location.)
Definition: BreakpointLocation.h:347
lldb_private::BreakpointLocation::InvokeCallback
bool InvokeCallback(StoppointCallbackContext *context)
Invoke the callback action when the breakpoint is hit.
Definition: BreakpointLocation.cpp:190
lldb_private::BreakpointLocation::IsCallbackSynchronous
bool IsCallbackSynchronous()
Report whether the callback for this location is synchronous or not.
Definition: BreakpointLocation.cpp:197
lldb_private::BreakpointLocation::GetLoadAddress
lldb::addr_t GetLoadAddress() const
Gets the load address for this breakpoint location.
Definition: BreakpointLocation.cpp:51
lldb_private::BreakpointLocation::GetThreadIndex
uint32_t GetThreadIndex() const
Definition: BreakpointLocation.cpp:136
lldb_private::BreakpointLocation::DecrementIgnoreCount
void DecrementIgnoreCount()
Definition: BreakpointLocation.cpp:350
lldb_private::StopInfoBreakpoint
Definition: StopInfo.cpp:84
lldb_private::BreakpointLocation::m_is_reexported
bool m_is_reexported
Definition: BreakpointLocation.h:339
lldb_private::BreakpointLocation::SwapLocation
void SwapLocation(lldb::BreakpointLocationSP swap_from)
Definition: BreakpointLocation.cpp:662
lldb_private::Process
Definition: Process.h:342
lldb_private::BreakpointLocation::ClearBreakpointSite
bool ClearBreakpointSite()
Clear this breakpoint location's breakpoint site - for instance when disabling the breakpoint.
Definition: BreakpointLocation.cpp:468
lldb_private::BreakpointLocation::SetThreadName
void SetThreadName(const char *thread_name)
Definition: BreakpointLocation.cpp:146
lldb_private::BreakpointLocation::m_loc_id
lldb::break_id_t m_loc_id
Breakpoint location ID.
Definition: BreakpointLocation.h:356
lldb_private::BreakpointLocation::SetCondition
void SetCondition(const char *condition)
Set the breakpoint location's condition.
Definition: BreakpointLocation.cpp:224
lldb_private::BreakpointLocation::m_condition_hash
size_t m_condition_hash
For testing whether the condition source code changed.
Definition: BreakpointLocation.h:354
lldb_private::BreakpointLocation::SendBreakpointLocationChangedEvent
void SendBreakpointLocationChangedEvent(lldb::BreakpointEventType eventKind)
Definition: BreakpointLocation.cpp:649
lldb_private::BreakpointLocation::SetShouldResolveIndirectFunctions
void SetShouldResolveIndirectFunctions(bool do_resolve)
Definition: BreakpointLocation.h:360
lldb_private::BreakpointLocation::ClearCallback
void ClearCallback()
Definition: BreakpointLocation.cpp:220
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::BreakpointLocation::GetOptionsSpecifyingKind
const BreakpointOptions & GetOptionsSpecifyingKind(BreakpointOptions::OptionKind kind) const
Use this to access breakpoint options from this breakpoint location.
Definition: BreakpointLocation.cpp:55
lldb_private::Target
Definition: Target.h:454
lldb_private::BreakpointLocation::SetAutoContinue
void SetAutoContinue(bool auto_continue)
If auto_continue is true, set the breakpoint to continue when hit.
Definition: BreakpointLocation.cpp:97
lldb_private::StoppointHitCounter::GetValue
uint32_t GetValue() const
Definition: StoppointHitCounter.h:22
lldb_private::BreakpointLocation::SetBreakpointSite
bool SetBreakpointSite(lldb::BreakpointSiteSP &bp_site_sp)
Set the breakpoint site for this location to bp_site_sp.
Definition: BreakpointLocation.cpp:462
lldb_private::BreakpointLocation
General Outline: A breakpoint location is defined by the breakpoint that produces it,...
Definition: BreakpointLocation.h:37
lldb_private::BreakpointLocation::GetTarget
Target & GetTarget()
Definition: BreakpointLocation.cpp:67
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::BreakpointLocation::GetLocationOptions
BreakpointOptions & GetLocationOptions()
Use this to set location specific breakpoint options.
Definition: BreakpointLocation.cpp:373
lldb_private::BreakpointLocation::UndoBumpHitCount
void UndoBumpHitCount()
Definition: BreakpointLocation.cpp:425
lldb_private::BreakpointSite
Definition: BreakpointSite.h:35
lldb_private::BreakpointLocation::GetAddress
Address & GetAddress()
Gets the Address for this breakpoint location.
Definition: BreakpointLocation.cpp:63
lldb_private::BreakpointLocation::m_user_expression_sp
lldb::UserExpressionSP m_user_expression_sp
The compiled expression to use in testing our condition.
Definition: BreakpointLocation.h:349
lldb_private::BreakpointLocation::SetThreadIndex
void SetThreadIndex(uint32_t index)
Definition: BreakpointLocation.cpp:124
lldb_private::BreakpointLocation::SetIsIndirect
void SetIsIndirect(bool is_indirect)
Definition: BreakpointLocation.h:257
lldb_private::StoppointHitCounter
Definition: StoppointHitCounter.h:20
lldb_private::BreakpointLocation::m_hit_counter
StoppointHitCounter m_hit_counter
Number of times this breakpoint location has been hit.
Definition: BreakpointLocation.h:357
lldb_private::Thread
Definition: Thread.h:62
lldb_private::BreakpointLocation::SetIsReExported
void SetIsReExported(bool is_reexported)
Definition: BreakpointLocation.h:266
lldb_private::BreakpointLocation::BumpHitCount
void BumpHitCount()
Definition: BreakpointLocation.cpp:417
lldb_private::BreakpointLocation::GetID
lldb::break_id_t GetID() const
Returns the breakpoint location ID.
Definition: BreakpointLocation.h:280
lldb_private::BreakpointLocation::GetThreadID
lldb::tid_t GetThreadID()
Definition: BreakpointLocation.cpp:114
lldb_private::BreakpointLocation::IsAutoContinue
bool IsAutoContinue() const
Check the AutoContinue state.
Definition: BreakpointLocation.cpp:89
lldb_private::BreakpointLocation::SetIgnoreCount
void SetIgnoreCount(uint32_t n)
Set the breakpoint to ignore the next count breakpoint hits.
Definition: BreakpointLocation.cpp:345
lldb_private::BreakpointLocation::m_should_resolve_indirect_functions
bool m_should_resolve_indirect_functions
Definition: BreakpointLocation.h:338
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
lldb_private::BreakpointOptions
Definition: BreakpointOptions.h:27
lldb_private::BreakpointLocation::IsEnabled
bool IsEnabled() const
Check the Enable/Disable state.
Definition: BreakpointLocation.cpp:69
lldb_private::BreakpointLocation::SetEnabled
void SetEnabled(bool enabled)
If enabled is true, enable the breakpoint, if false disable it.
Definition: BreakpointLocation.cpp:78
lldb_private::BreakpointOptions::OptionKind
OptionKind
Definition: BreakpointOptions.h:34
lldb_private::BreakpointLocation::ValidForThisThread
bool ValidForThisThread(Thread &thread)
Definition: BreakpointLocation.cpp:383
lldb_private::BreakpointLocation::m_owner
Breakpoint & m_owner
The breakpoint that produced this object.
Definition: BreakpointLocation.h:342
lldb_private::BreakpointLocation::IsIndirect
bool IsIndirect()
Returns whether the address set in the breakpoint site for this location was found by resolving an in...
Definition: BreakpointLocation.h:255
lldb_private::BreakpointLocation::ShouldResolveIndirectFunctions
bool ShouldResolveIndirectFunctions()
Returns whether we should resolve Indirect functions in setting the breakpoint site for this location...
Definition: BreakpointLocation.h:246
Address.h
lldb_private::BreakpointLocation::SetCallback
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &callback_baton_sp, bool is_synchronous)
Set the callback action invoked when the breakpoint is hit.
UserID.h
BreakpointOptions.h
lldb-private.h
lldb_private::BreakpointLocation::GetBreakpointSite
lldb::BreakpointSiteSP GetBreakpointSite() const
Definition: BreakpointLocation.cpp:437
lldb_private::BreakpointLocation::SetQueueName
void SetQueueName(const char *queue_name)
Definition: BreakpointLocation.cpp:168
lldb_private::BreakpointLocation::GetHitCount
uint32_t GetHitCount() const
Return the current Hit Count.
Definition: BreakpointLocation.h:88
lldb_private::BreakpointLocation::ShouldStop
bool ShouldStop(StoppointCallbackContext *context)
Determines whether we should stop due to a hit at this breakpoint location.
Definition: BreakpointLocation.cpp:394
lldb_private::BreakpointLocation::IgnoreCountShouldStop
bool IgnoreCountShouldStop()
BreakpointLocation::IgnoreCountShouldStop can only be called once per stop.
Definition: BreakpointLocation.cpp:358
StoppointHitCounter.h
lldb_private::Status
Definition: Status.h:44
lldb_private::BreakpointLocation::EquivalentToLocation
bool EquivalentToLocation(BreakpointLocation &location)
Returns whether the two breakpoint locations might represent "equivalent locations".
lldb_private::BreakpointLocation::GetBreakpoint
Breakpoint & GetBreakpoint()
Gets the Breakpoint that created this breakpoint location.
Definition: BreakpointLocation.cpp:65
lldb_private::BreakpointLocation::IsResolved
bool IsResolved() const
Return whether this breakpoint location has a breakpoint site.
Definition: BreakpointLocation.cpp:433
uint32_t
lldb_private::BreakpointLocation::ConditionSaysStop
bool ConditionSaysStop(ExecutionContext &exe_ctx, Status &error)
Definition: BreakpointLocation.cpp:234
lldb_private::BreakpointLocation::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level)
Print a description of this breakpoint location to the stream s.
Definition: BreakpointLocation.cpp:486
lldb_private::Address
Definition: Address.h:59
lldb_private::BreakpointLocation::Dump
void Dump(Stream *s) const
Standard "Dump" method. At present it does nothing.
Definition: BreakpointLocation.cpp:623
lldb_private::BreakpointLocation::operator=
const BreakpointLocation & operator=(const BreakpointLocation &)=delete
lldb_private::BreakpointLocation::GetThreadName
const char * GetThreadName() const
Definition: BreakpointLocation.cpp:158
lldb_private::BreakpointLocation::m_is_indirect
bool m_is_indirect
Definition: BreakpointLocation.h:340
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::BreakpointLocationList
Definition: BreakpointLocationList.h:26
lldb_private::BreakpointLocation::IsReExported
bool IsReExported()
Returns whether the address set in the breakpoint location was re-routed to the target of a re-export...
Definition: BreakpointLocation.h:264
lldb_private::BreakpointLocation::BreakpointLocation
BreakpointLocation(lldb::break_id_t bid, Breakpoint &owner, const Address &addr, lldb::tid_t tid, bool hardware, bool check_for_resolver=true)
Constructor.
Definition: BreakpointLocation.cpp:31
lldb_private::BreakpointLocation::ResolveBreakpointSite
bool ResolveBreakpointSite()
Try to resolve the breakpoint site for this location.
Definition: BreakpointLocation.cpp:441
lldb_private::BreakpointLocation::m_options_up
std::unique_ptr< BreakpointOptions > m_options_up
Breakpoint options pointer, nullptr if we're using our breakpoint's options.
Definition: BreakpointLocation.h:343
lldb_private::BreakpointLocation::m_being_created
bool m_being_created
Definition: BreakpointLocation.h:337
lldb_private::BreakpointLocation::m_address
Address m_address
The address defining this location.
Definition: BreakpointLocation.h:341
lldb_private::BreakpointLocation::GetQueueName
const char * GetQueueName() const
Definition: BreakpointLocation.cpp:180
lldb_private::BreakpointLocation::m_condition_mutex
std::mutex m_condition_mutex
Guards parsing and evaluation of the condition, which could be evaluated by multiple processes.
Definition: BreakpointLocation.h:351
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::Breakpoint
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:79
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::BreakpointLocation::GetIgnoreCount
uint32_t GetIgnoreCount() const
Return the current Ignore Count.
Definition: BreakpointLocation.cpp:340