Coverage Report

Created: 2022-01-25 06:29

/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/include/lldb/Breakpoint/BreakpointLocation.h
Line
Count
Source
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
15
#include "lldb/Breakpoint/BreakpointOptions.h"
16
#include "lldb/Breakpoint/StoppointHitCounter.h"
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
37
class BreakpointLocation
38
    : public std::enable_shared_from_this<BreakpointLocation> {
39
public:
40
  ~BreakpointLocation();
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.
45
  lldb::addr_t GetLoadAddress() const;
46
47
  /// Gets the Address for this breakpoint location \return
48
  ///     Returns breakpoint location Address.
49
  Address &GetAddress();
50
  /// Gets the Breakpoint that created this breakpoint location \return
51
  ///     Returns the owning breakpoint.
52
  Breakpoint &GetBreakpoint();
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.
88
299
  uint32_t GetHitCount() const { return m_hit_counter.GetValue(); }
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
136
  bool ConditionSaysStop(ExecutionContext &exe_ctx, Status &error);
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
144
  lldb::tid_t GetThreadID();
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
194
  void GetDescription(Stream *s, lldb::DescriptionLevel level);
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.
206
  BreakpointOptions &GetLocationOptions();
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 &
218
  GetOptionsSpecifyingKind(BreakpointOptions::OptionKind kind) const;
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.
232
  bool InvokeCallback(StoppointCallbackContext *context);
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.
246
30.2k
  bool ShouldResolveIndirectFunctions() {
247
30.2k
    return m_should_resolve_indirect_functions;
248
30.2k
  }
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
1.44k
  bool IsIndirect() { return m_is_indirect; }
256
257
30.2k
  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
1.42k
  bool IsReExported() { return m_is_reexported; }
265
266
9.95k
  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.
277
  bool EquivalentToLocation(BreakpointLocation &location);
278
279
  /// Returns the breakpoint location ID.
280
115k
  lldb::break_id_t GetID() const { return m_loc_id; }
281
282
protected:
283
  friend class BreakpointSite;
284
  friend class BreakpointLocationList;
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
332
  BreakpointLocation(lldb::break_id_t bid, Breakpoint &owner,
333
                     const Address &addr, lldb::tid_t tid, bool hardware,
334
                     bool check_for_resolver = true);
335
336
  // Data members:
337
  bool m_being_created;
338
  bool m_should_resolve_indirect_functions;
339
  bool m_is_reexported;
340
  bool m_is_indirect;
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
6
  void SetShouldResolveIndirectFunctions(bool do_resolve) {
361
6
    m_should_resolve_indirect_functions = do_resolve;
362
6
  }
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