LLDB  mainline
SBBreakpointLocation.cpp
Go to the documentation of this file.
1 //===-- SBBreakpointLocation.cpp ------------------------------------------===//
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 #include "lldb/API/SBBreakpointLocation.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBAddress.h"
12 #include "lldb/API/SBDebugger.h"
13 #include "lldb/API/SBDefines.h"
14 #include "lldb/API/SBStream.h"
15 #include "lldb/API/SBStructuredData.h"
16 #include "lldb/API/SBStringList.h"
17 
18 #include "lldb/Breakpoint/Breakpoint.h"
19 #include "lldb/Breakpoint/BreakpointLocation.h"
20 #include "lldb/Core/Debugger.h"
21 #include "lldb/Core/StreamFile.h"
22 #include "lldb/Core/StructuredDataImpl.h"
23 #include "lldb/Interpreter/CommandInterpreter.h"
24 #include "lldb/Interpreter/ScriptInterpreter.h"
25 #include "lldb/Target/Target.h"
26 #include "lldb/Target/ThreadSpec.h"
27 #include "lldb/Utility/Stream.h"
28 #include "lldb/lldb-defines.h"
29 #include "lldb/lldb-types.h"
30 
31 using namespace lldb;
32 using namespace lldb_private;
33 
34 SBBreakpointLocation::SBBreakpointLocation() {
35  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBreakpointLocation);
36 }
37 
38 SBBreakpointLocation::SBBreakpointLocation(
39  const lldb::BreakpointLocationSP &break_loc_sp)
40  : m_opaque_wp(break_loc_sp) {
41  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
42  (const lldb::BreakpointLocationSP &), break_loc_sp);
43 }
44 
45 SBBreakpointLocation::SBBreakpointLocation(const SBBreakpointLocation &rhs)
46  : m_opaque_wp(rhs.m_opaque_wp) {
47  LLDB_RECORD_CONSTRUCTOR(SBBreakpointLocation,
48  (const lldb::SBBreakpointLocation &), rhs);
49 }
50 
51 const SBBreakpointLocation &SBBreakpointLocation::
52 operator=(const SBBreakpointLocation &rhs) {
53  LLDB_RECORD_METHOD(
54  const lldb::SBBreakpointLocation &,
55  SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &),
56  rhs);
57 
58  m_opaque_wp = rhs.m_opaque_wp;
59  return LLDB_RECORD_RESULT(*this);
60 }
61 
62 SBBreakpointLocation::~SBBreakpointLocation() = default;
63 
64 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
65  return m_opaque_wp.lock();
66 }
67 
68 bool SBBreakpointLocation::IsValid() const {
69  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
70  return this->operator bool();
71 }
72 SBBreakpointLocation::operator bool() const {
73  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
74 
75  return bool(GetSP());
76 }
77 
78 SBAddress SBBreakpointLocation::GetAddress() {
79  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
80 
81  BreakpointLocationSP loc_sp = GetSP();
82  if (loc_sp) {
83  return LLDB_RECORD_RESULT(SBAddress(loc_sp->GetAddress()));
84  }
85 
86  return LLDB_RECORD_RESULT(SBAddress());
87 }
88 
89 addr_t SBBreakpointLocation::GetLoadAddress() {
90  LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBBreakpointLocation,
91  GetLoadAddress);
92 
93  addr_t ret_addr = LLDB_INVALID_ADDRESS;
94  BreakpointLocationSP loc_sp = GetSP();
95 
96  if (loc_sp) {
97  std::lock_guard<std::recursive_mutex> guard(
98  loc_sp->GetTarget().GetAPIMutex());
99  ret_addr = loc_sp->GetLoadAddress();
100  }
101 
102  return ret_addr;
103 }
104 
105 void SBBreakpointLocation::SetEnabled(bool enabled) {
106  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetEnabled, (bool), enabled);
107 
108  BreakpointLocationSP loc_sp = GetSP();
109  if (loc_sp) {
110  std::lock_guard<std::recursive_mutex> guard(
111  loc_sp->GetTarget().GetAPIMutex());
112  loc_sp->SetEnabled(enabled);
113  }
114 }
115 
116 bool SBBreakpointLocation::IsEnabled() {
117  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsEnabled);
118 
119  BreakpointLocationSP loc_sp = GetSP();
120  if (loc_sp) {
121  std::lock_guard<std::recursive_mutex> guard(
122  loc_sp->GetTarget().GetAPIMutex());
123  return loc_sp->IsEnabled();
124  } else
125  return false;
126 }
127 
128 uint32_t SBBreakpointLocation::GetHitCount() {
129  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetHitCount);
130 
131  BreakpointLocationSP loc_sp = GetSP();
132  if (loc_sp) {
133  std::lock_guard<std::recursive_mutex> guard(
134  loc_sp->GetTarget().GetAPIMutex());
135  return loc_sp->GetHitCount();
136  } else
137  return 0;
138 }
139 
140 uint32_t SBBreakpointLocation::GetIgnoreCount() {
141  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBBreakpointLocation, GetIgnoreCount);
142 
143  BreakpointLocationSP loc_sp = GetSP();
144  if (loc_sp) {
145  std::lock_guard<std::recursive_mutex> guard(
146  loc_sp->GetTarget().GetAPIMutex());
147  return loc_sp->GetIgnoreCount();
148  } else
149  return 0;
150 }
151 
152 void SBBreakpointLocation::SetIgnoreCount(uint32_t n) {
153  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetIgnoreCount, (uint32_t), n);
154 
155  BreakpointLocationSP loc_sp = GetSP();
156  if (loc_sp) {
157  std::lock_guard<std::recursive_mutex> guard(
158  loc_sp->GetTarget().GetAPIMutex());
159  loc_sp->SetIgnoreCount(n);
160  }
161 }
162 
163 void SBBreakpointLocation::SetCondition(const char *condition) {
164  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCondition, (const char *),
165  condition);
166 
167  BreakpointLocationSP loc_sp = GetSP();
168  if (loc_sp) {
169  std::lock_guard<std::recursive_mutex> guard(
170  loc_sp->GetTarget().GetAPIMutex());
171  loc_sp->SetCondition(condition);
172  }
173 }
174 
175 const char *SBBreakpointLocation::GetCondition() {
176  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBBreakpointLocation, GetCondition);
177 
178  BreakpointLocationSP loc_sp = GetSP();
179  if (loc_sp) {
180  std::lock_guard<std::recursive_mutex> guard(
181  loc_sp->GetTarget().GetAPIMutex());
182  return loc_sp->GetConditionText();
183  }
184  return nullptr;
185 }
186 
187 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
188  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool),
189  auto_continue);
190 
191  BreakpointLocationSP loc_sp = GetSP();
192  if (loc_sp) {
193  std::lock_guard<std::recursive_mutex> guard(
194  loc_sp->GetTarget().GetAPIMutex());
195  loc_sp->SetAutoContinue(auto_continue);
196  }
197 }
198 
199 bool SBBreakpointLocation::GetAutoContinue() {
200  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, GetAutoContinue);
201 
202  BreakpointLocationSP loc_sp = GetSP();
203  if (loc_sp) {
204  std::lock_guard<std::recursive_mutex> guard(
205  loc_sp->GetTarget().GetAPIMutex());
206  return loc_sp->IsAutoContinue();
207  }
208  return false;
209 }
210 
211 void SBBreakpointLocation::SetScriptCallbackFunction(
212  const char *callback_function_name) {
213 LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
214  (const char *), callback_function_name);
215 }
216 
217 SBError SBBreakpointLocation::SetScriptCallbackFunction(
218  const char *callback_function_name,
219  SBStructuredData &extra_args) {
220  LLDB_RECORD_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
221  (const char *, SBStructuredData &), callback_function_name,
222  extra_args);
223  SBError sb_error;
224  BreakpointLocationSP loc_sp = GetSP();
225 
226  if (loc_sp) {
227  Status error;
228  std::lock_guard<std::recursive_mutex> guard(
229  loc_sp->GetTarget().GetAPIMutex());
230  BreakpointOptions &bp_options = loc_sp->GetLocationOptions();
231  error = loc_sp->GetBreakpoint()
232  .GetTarget()
233  .GetDebugger()
234  .GetScriptInterpreter()
235  ->SetBreakpointCommandCallbackFunction(bp_options,
236  callback_function_name,
237  extra_args.m_impl_up
238  ->GetObjectSP());
239  sb_error.SetError(error);
240  } else
241  sb_error.SetErrorString("invalid breakpoint");
242 
243  return LLDB_RECORD_RESULT(sb_error);
244 }
245 
246 SBError
247 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
248  LLDB_RECORD_METHOD(lldb::SBError, SBBreakpointLocation, SetScriptCallbackBody,
249  (const char *), callback_body_text);
250 
251  BreakpointLocationSP loc_sp = GetSP();
252 
253  SBError sb_error;
254  if (loc_sp) {
255  std::lock_guard<std::recursive_mutex> guard(
256  loc_sp->GetTarget().GetAPIMutex());
257  BreakpointOptions &bp_options = loc_sp->GetLocationOptions();
258  Status error =
259  loc_sp->GetBreakpoint()
260  .GetTarget()
261  .GetDebugger()
262  .GetScriptInterpreter()
263  ->SetBreakpointCommandCallback(bp_options, callback_body_text);
264  sb_error.SetError(error);
265  } else
266  sb_error.SetErrorString("invalid breakpoint");
267 
268  return LLDB_RECORD_RESULT(sb_error);
269 }
270 
271 void SBBreakpointLocation::SetCommandLineCommands(SBStringList &commands) {
272  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
273  (lldb::SBStringList &), commands);
274 
275  BreakpointLocationSP loc_sp = GetSP();
276  if (!loc_sp)
277  return;
278  if (commands.GetSize() == 0)
279  return;
280 
281  std::lock_guard<std::recursive_mutex> guard(
282  loc_sp->GetTarget().GetAPIMutex());
283  std::unique_ptr<BreakpointOptions::CommandData> cmd_data_up(
284  new BreakpointOptions::CommandData(*commands, eScriptLanguageNone));
285 
286  loc_sp->GetLocationOptions().SetCommandDataCallback(cmd_data_up);
287 }
288 
289 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
290  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
291  (lldb::SBStringList &), commands);
292 
293  BreakpointLocationSP loc_sp = GetSP();
294  if (!loc_sp)
295  return false;
296  StringList command_list;
297  bool has_commands =
298  loc_sp->GetLocationOptions().GetCommandLineCallbacks(command_list);
299  if (has_commands)
300  commands.AppendList(command_list);
301  return has_commands;
302 }
303 
304 void SBBreakpointLocation::SetThreadID(tid_t thread_id) {
305  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadID, (lldb::tid_t),
306  thread_id);
307 
308  BreakpointLocationSP loc_sp = GetSP();
309  if (loc_sp) {
310  std::lock_guard<std::recursive_mutex> guard(
311  loc_sp->GetTarget().GetAPIMutex());
312  loc_sp->SetThreadID(thread_id);
313  }
314 }
315 
316 tid_t SBBreakpointLocation::GetThreadID() {
317  LLDB_RECORD_METHOD_NO_ARGS(lldb::tid_t, SBBreakpointLocation, GetThreadID);
318 
319  tid_t tid = LLDB_INVALID_THREAD_ID;
320  BreakpointLocationSP loc_sp = GetSP();
321  if (loc_sp) {
322  std::lock_guard<std::recursive_mutex> guard(
323  loc_sp->GetTarget().GetAPIMutex());
324  return loc_sp->GetThreadID();
325  }
326  return tid;
327 }
328 
329 void SBBreakpointLocation::SetThreadIndex(uint32_t index) {
330  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadIndex, (uint32_t),
331  index);
332 
333  BreakpointLocationSP loc_sp = GetSP();
334  if (loc_sp) {
335  std::lock_guard<std::recursive_mutex> guard(
336  loc_sp->GetTarget().GetAPIMutex());
337  loc_sp->SetThreadIndex(index);
338  }
339 }
340 
341 uint32_t SBBreakpointLocation::GetThreadIndex() const {
342  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBreakpointLocation,
343  GetThreadIndex);
344 
345  uint32_t thread_idx = UINT32_MAX;
346  BreakpointLocationSP loc_sp = GetSP();
347  if (loc_sp) {
348  std::lock_guard<std::recursive_mutex> guard(
349  loc_sp->GetTarget().GetAPIMutex());
350  return loc_sp->GetThreadIndex();
351  }
352  return thread_idx;
353 }
354 
355 void SBBreakpointLocation::SetThreadName(const char *thread_name) {
356  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetThreadName, (const char *),
357  thread_name);
358 
359  BreakpointLocationSP loc_sp = GetSP();
360  if (loc_sp) {
361  std::lock_guard<std::recursive_mutex> guard(
362  loc_sp->GetTarget().GetAPIMutex());
363  loc_sp->SetThreadName(thread_name);
364  }
365 }
366 
367 const char *SBBreakpointLocation::GetThreadName() const {
368  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
369  GetThreadName);
370 
371  BreakpointLocationSP loc_sp = GetSP();
372  if (loc_sp) {
373  std::lock_guard<std::recursive_mutex> guard(
374  loc_sp->GetTarget().GetAPIMutex());
375  return loc_sp->GetThreadName();
376  }
377  return nullptr;
378 }
379 
380 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
381  LLDB_RECORD_METHOD(void, SBBreakpointLocation, SetQueueName, (const char *),
382  queue_name);
383 
384  BreakpointLocationSP loc_sp = GetSP();
385  if (loc_sp) {
386  std::lock_guard<std::recursive_mutex> guard(
387  loc_sp->GetTarget().GetAPIMutex());
388  loc_sp->SetQueueName(queue_name);
389  }
390 }
391 
392 const char *SBBreakpointLocation::GetQueueName() const {
393  LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointLocation,
394  GetQueueName);
395 
396  BreakpointLocationSP loc_sp = GetSP();
397  if (loc_sp) {
398  std::lock_guard<std::recursive_mutex> guard(
399  loc_sp->GetTarget().GetAPIMutex());
400  loc_sp->GetQueueName();
401  }
402  return nullptr;
403 }
404 
405 bool SBBreakpointLocation::IsResolved() {
406  LLDB_RECORD_METHOD_NO_ARGS(bool, SBBreakpointLocation, IsResolved);
407 
408  BreakpointLocationSP loc_sp = GetSP();
409  if (loc_sp) {
410  std::lock_guard<std::recursive_mutex> guard(
411  loc_sp->GetTarget().GetAPIMutex());
412  return loc_sp->IsResolved();
413  }
414  return false;
415 }
416 
417 void SBBreakpointLocation::SetLocation(
418  const lldb::BreakpointLocationSP &break_loc_sp) {
419  // Uninstall the callbacks?
420  m_opaque_wp = break_loc_sp;
421 }
422 
423 bool SBBreakpointLocation::GetDescription(SBStream &description,
424  DescriptionLevel level) {
425  LLDB_RECORD_METHOD(bool, SBBreakpointLocation, GetDescription,
426  (lldb::SBStream &, lldb::DescriptionLevel), description,
427  level);
428 
429  Stream &strm = description.ref();
430  BreakpointLocationSP loc_sp = GetSP();
431 
432  if (loc_sp) {
433  std::lock_guard<std::recursive_mutex> guard(
434  loc_sp->GetTarget().GetAPIMutex());
435  loc_sp->GetDescription(&strm, level);
436  strm.EOL();
437  } else
438  strm.PutCString("No value");
439 
440  return true;
441 }
442 
443 break_id_t SBBreakpointLocation::GetID() {
444  LLDB_RECORD_METHOD_NO_ARGS(lldb::break_id_t, SBBreakpointLocation, GetID);
445 
446  BreakpointLocationSP loc_sp = GetSP();
447  if (loc_sp) {
448  std::lock_guard<std::recursive_mutex> guard(
449  loc_sp->GetTarget().GetAPIMutex());
450  return loc_sp->GetID();
451  } else
452  return LLDB_INVALID_BREAK_ID;
453 }
454 
455 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {
456  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBreakpoint, SBBreakpointLocation,
457  GetBreakpoint);
458 
459  BreakpointLocationSP loc_sp = GetSP();
460 
461  SBBreakpoint sb_bp;
462  if (loc_sp) {
463  std::lock_guard<std::recursive_mutex> guard(
464  loc_sp->GetTarget().GetAPIMutex());
465  sb_bp = loc_sp->GetBreakpoint().shared_from_this();
466  }
467 
468  return LLDB_RECORD_RESULT(sb_bp);
469 }
470 
471 namespace lldb_private {
472 namespace repro {
473 
474 template <>
475 void RegisterMethods<SBBreakpointLocation>(Registry &R) {
476  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation, ());
477  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
478  (const lldb::BreakpointLocationSP &));
479  LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
480  (const lldb::SBBreakpointLocation &));
481  LLDB_REGISTER_METHOD(
482  const lldb::SBBreakpointLocation &,
483  SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
484  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
485  LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
486  LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
487  LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
488  ());
489  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
490  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
491  LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
492  LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
493  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
494  (uint32_t));
495  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCondition,
496  (const char *));
497  LLDB_REGISTER_METHOD(const char *, SBBreakpointLocation, GetCondition, ());
498  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetAutoContinue, (bool));
499  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetAutoContinue, ());
500  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetScriptCallbackFunction,
501  (const char *));
502  LLDB_REGISTER_METHOD(SBError, SBBreakpointLocation, SetScriptCallbackFunction,
503  (const char *, SBStructuredData &));
504  LLDB_REGISTER_METHOD(lldb::SBError, SBBreakpointLocation,
505  SetScriptCallbackBody, (const char *));
506  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetCommandLineCommands,
507  (lldb::SBStringList &));
508  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetCommandLineCommands,
509  (lldb::SBStringList &));
510  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadID,
511  (lldb::tid_t));
512  LLDB_REGISTER_METHOD(lldb::tid_t, SBBreakpointLocation, GetThreadID, ());
513  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadIndex,
514  (uint32_t));
515  LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointLocation, GetThreadIndex,
516  ());
517  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetThreadName,
518  (const char *));
519  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation,
520  GetThreadName, ());
521  LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetQueueName,
522  (const char *));
523  LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointLocation, GetQueueName,
524  ());
525  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsResolved, ());
526  LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, GetDescription,
527  (lldb::SBStream &, lldb::DescriptionLevel));
528  LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpointLocation, GetID, ());
529  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBBreakpointLocation,
530  GetBreakpoint, ());
531 }
532 
533 }
534 }
lldb::SBBreakpointLocation
Definition: SBBreakpointLocation.h:17
lldb::SBStringList
Definition: SBStringList.h:16
lldb::SBBreakpointLocation::GetThreadName
const char * GetThreadName() const
Definition: SBBreakpointLocation.cpp:367
lldb::SBBreakpointLocation::GetID
break_id_t GetID()
Definition: SBBreakpointLocation.cpp:443
lldb::SBStream::ref
lldb_private::Stream & ref()
Definition: SBStream.cpp:178
lldb::SBStringList::GetSize
uint32_t GetSize() const
Definition: SBStringList.cpp:102
lldb::SBBreakpointLocation::SetQueueName
void SetQueueName(const char *queue_name)
Definition: SBBreakpointLocation.cpp:380
lldb::SBBreakpointLocation::~SBBreakpointLocation
~SBBreakpointLocation()
lldb_private::BreakpointOptions::CommandData
Definition: BreakpointOptions.h:45
SBDefines.h
lldb::SBBreakpointLocation::GetThreadIndex
uint32_t GetThreadIndex() const
Definition: SBBreakpointLocation.cpp:341
lldb::SBBreakpointLocation::IsEnabled
bool IsEnabled()
Definition: SBBreakpointLocation.cpp:116
lldb::SBBreakpointLocation::GetDescription
bool GetDescription(lldb::SBStream &description, DescriptionLevel level)
Definition: SBBreakpointLocation.cpp:423
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb::SBError
Definition: SBError.h:20
lldb-defines.h
lldb::SBBreakpointLocation::IsResolved
bool IsResolved()
Definition: SBBreakpointLocation.cpp:405
SBStringList.h
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb_private::repro::RegisterMethods< SBBreakpointLocation >
void RegisterMethods< SBBreakpointLocation >(Registry &R)
Definition: SBBreakpointLocation.cpp:475
BreakpointLocation.h
lldb::SBBreakpointLocation::SetThreadName
void SetThreadName(const char *thread_name)
Definition: SBBreakpointLocation.cpp:355
LLDB_RECORD_CONSTRUCTOR_NO_ARGS
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
Definition: ReproducerInstrumentation.h:136
lldb::SBBreakpointLocation::SetThreadIndex
void SetThreadIndex(uint32_t index)
Definition: SBBreakpointLocation.cpp:329
lldb::SBBreakpointLocation::SetScriptCallbackBody
SBError SetScriptCallbackBody(const char *script_body_text)
Definition: SBBreakpointLocation.cpp:247
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb::SBBreakpointLocation::GetThreadID
lldb::tid_t GetThreadID()
Definition: SBBreakpointLocation.cpp:316
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
SBReproducerPrivate.h
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb::SBBreakpointLocation::operator=
const lldb::SBBreakpointLocation & operator=(const lldb::SBBreakpointLocation &rhs)
Definition: SBBreakpointLocation.cpp:52
Debugger.h
lldb::SBBreakpointLocation::SetScriptCallbackFunction
void SetScriptCallbackFunction(const char *callback_function_name)
Definition: SBBreakpointLocation.cpp:211
lldb::SBBreakpointLocation::GetBreakpoint
SBBreakpoint GetBreakpoint()
Definition: SBBreakpointLocation.cpp:455
lldb::SBStructuredData::m_impl_up
StructuredDataImplUP m_impl_up
Definition: SBStructuredData.h:104
lldb::eScriptLanguageNone
@ eScriptLanguageNone
Definition: lldb-enumerations.h:217
Target.h
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::SBBreakpointLocation::GetHitCount
uint32_t GetHitCount()
Definition: SBBreakpointLocation.cpp:128
SBStream.h
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb::SBBreakpointLocation::GetLoadAddress
lldb::addr_t GetLoadAddress()
Definition: SBBreakpointLocation.cpp:89
ThreadSpec.h
lldb::SBBreakpointLocation::GetSP
BreakpointLocationSP GetSP() const
Definition: SBBreakpointLocation.cpp:64
lldb::SBBreakpointLocation::GetAddress
lldb::SBAddress GetAddress()
Definition: SBBreakpointLocation.cpp:78
lldb::SBBreakpointLocation::SetIgnoreCount
void SetIgnoreCount(uint32_t n)
Definition: SBBreakpointLocation.cpp:152
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
lldb::SBBreakpointLocation::SetCondition
void SetCondition(const char *condition)
Definition: SBBreakpointLocation.cpp:163
lldb_private::StringList
Definition: StringList.h:25
lldb::SBBreakpointLocation::GetCommandLineCommands
bool GetCommandLineCommands(lldb::SBStringList &commands)
Definition: SBBreakpointLocation.cpp:289
lldb::SBError::SetErrorString
void SetErrorString(const char *err_str)
Definition: SBError.cpp:124
lldb_private::BreakpointOptions
Definition: BreakpointOptions.h:27
lldb::SBBreakpointLocation::m_opaque_wp
lldb::BreakpointLocationWP m_opaque_wp
Definition: SBBreakpointLocation.h:98
SBDebugger.h
lldb::SBBreakpointLocation::GetIgnoreCount
uint32_t GetIgnoreCount()
Definition: SBBreakpointLocation.cpp:140
lldb::SBError::SetError
void SetError(uint32_t err, lldb::ErrorType type)
Definition: SBError.cpp:97
lldb::SBBreakpointLocation::GetAutoContinue
bool GetAutoContinue()
Definition: SBBreakpointLocation.cpp:199
SBAddress.h
lldb::SBBreakpointLocation::GetCondition
const char * GetCondition()
Definition: SBBreakpointLocation.cpp:175
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
lldb-types.h
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
StreamFile.h
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb_private::Status
Definition: Status.h:44
uint32_t
lldb::SBStructuredData
Definition: SBStructuredData.h:17
lldb::SBBreakpoint
Definition: SBBreakpoint.h:18
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
SBBreakpointLocation.h
lldb::SBBreakpointLocation::GetQueueName
const char * GetQueueName() const
Definition: SBBreakpointLocation.cpp:392
lldb::SBBreakpointLocation::IsValid
bool IsValid() const
Definition: SBBreakpointLocation.cpp:68
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::SBBreakpointLocation::SetThreadID
void SetThreadID(lldb::tid_t sb_thread_id)
Definition: SBBreakpointLocation.cpp:304
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
SBStructuredData.h
StructuredDataImpl.h
lldb::SBAddress
Definition: SBAddress.h:17
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::SBBreakpointLocation::SetAutoContinue
void SetAutoContinue(bool auto_continue)
Definition: SBBreakpointLocation.cpp:187
Breakpoint.h
lldb::SBBreakpointLocation::SetEnabled
void SetEnabled(bool enabled)
Definition: SBBreakpointLocation.cpp:105
CommandInterpreter.h
lldb::SBBreakpointLocation::SetLocation
void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp)
Definition: SBBreakpointLocation.cpp:417
LLDB_INVALID_THREAD_ID
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:94
Stream.h
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb::SBStream
Definition: SBStream.h:18
lldb::SBAddress
class LLDB_API SBAddress
Definition: SBDefines.h:21
lldb::SBBreakpointLocation::SBBreakpointLocation
SBBreakpointLocation()
Definition: SBBreakpointLocation.cpp:34
ScriptInterpreter.h
lldb
Definition: SBAddress.h:15
lldb::SBBreakpointLocation::SetCommandLineCommands
void SetCommandLineCommands(lldb::SBStringList &commands)
Definition: SBBreakpointLocation.cpp:271
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::SBStringList::AppendList
void AppendList(const char **strv, int strc)
Definition: SBStringList.cpp:73
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93
Generated on Fri Oct 22 2021 05:42:31 for LLDB by   doxygen 1.8.17