LLDB  mainline
BreakpointOptions.cpp
Go to the documentation of this file.
1 //===-- BreakpointOptions.cpp -----------------------------------*- 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 
10 
12 #include "lldb/Core/Value.h"
15 #include "lldb/Target/Process.h"
16 #include "lldb/Target/Target.h"
17 #include "lldb/Target/ThreadSpec.h"
18 #include "lldb/Utility/Stream.h"
20 
21 #include "llvm/ADT/STLExtras.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 const char
27  *BreakpointOptions::CommandData::g_option_names[static_cast<uint32_t>(
28  BreakpointOptions::CommandData::OptionNames::LastOptionName)]{
29  "UserSource", "ScriptSource", "StopOnError"};
30 
32 BreakpointOptions::CommandData::SerializeToStructuredData() {
33  size_t num_strings = user_source.GetSize();
34  if (num_strings == 0 && script_source.empty()) {
35  // We shouldn't serialize commands if there aren't any, return an empty sp
36  // to indicate this.
37  return StructuredData::ObjectSP();
38  }
39 
40  StructuredData::DictionarySP options_dict_sp(
42  options_dict_sp->AddBooleanItem(GetKey(OptionNames::StopOnError),
43  stop_on_error);
44 
45  StructuredData::ArraySP user_source_sp(new StructuredData::Array());
46  for (size_t i = 0; i < num_strings; i++) {
48  new StructuredData::String(user_source[i]));
49  user_source_sp->AddItem(item_sp);
50  options_dict_sp->AddItem(GetKey(OptionNames::UserSource), user_source_sp);
51  }
52 
53  options_dict_sp->AddStringItem(
54  GetKey(OptionNames::Interpreter),
55  ScriptInterpreter::LanguageToString(interpreter));
56  return options_dict_sp;
57 }
58 
59 std::unique_ptr<BreakpointOptions::CommandData>
60 BreakpointOptions::CommandData::CreateFromStructuredData(
61  const StructuredData::Dictionary &options_dict, Status &error) {
62  std::unique_ptr<CommandData> data_up(new CommandData());
63  bool found_something = false;
64 
65  bool success = options_dict.GetValueForKeyAsBoolean(
66  GetKey(OptionNames::StopOnError), data_up->stop_on_error);
67 
68  if (success)
69  found_something = true;
70 
71  llvm::StringRef interpreter_str;
72  ScriptLanguage interp_language;
73  success = options_dict.GetValueForKeyAsString(
74  GetKey(OptionNames::Interpreter), interpreter_str);
75 
76  if (!success) {
77  error.SetErrorString("Missing command language value.");
78  return data_up;
79  }
80 
81  found_something = true;
82  interp_language = ScriptInterpreter::StringToLanguage(interpreter_str);
83  if (interp_language == eScriptLanguageUnknown) {
84  error.SetErrorStringWithFormatv("Unknown breakpoint command language: {0}.",
85  interpreter_str);
86  return data_up;
87  }
88  data_up->interpreter = interp_language;
89 
90  StructuredData::Array *user_source;
91  success = options_dict.GetValueForKeyAsArray(GetKey(OptionNames::UserSource),
92  user_source);
93  if (success) {
94  found_something = true;
95  size_t num_elems = user_source->GetSize();
96  for (size_t i = 0; i < num_elems; i++) {
97  llvm::StringRef elem_string;
98  success = user_source->GetItemAtIndexAsString(i, elem_string);
99  if (success)
100  data_up->user_source.AppendString(elem_string);
101  }
102  }
103 
104  if (found_something)
105  return data_up;
106  else
107  return std::unique_ptr<BreakpointOptions::CommandData>();
108 }
109 
110 const char *BreakpointOptions::g_option_names[(
111  size_t)BreakpointOptions::OptionNames::LastOptionName]{
112  "ConditionText", "IgnoreCount",
113  "EnabledState", "OneShotState", "AutoContinue"};
114 
115 bool BreakpointOptions::NullCallback(void *baton,
116  StoppointCallbackContext *context,
117  lldb::user_id_t break_id,
118  lldb::user_id_t break_loc_id) {
119  return true;
120 }
121 
122 // BreakpointOptions constructor
123 BreakpointOptions::BreakpointOptions(bool all_flags_set)
124  : m_callback(BreakpointOptions::NullCallback), m_callback_baton_sp(),
125  m_baton_is_command_baton(false), m_callback_is_synchronous(false),
126  m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_up(),
127  m_condition_text(), m_condition_text_hash(0), m_auto_continue(false),
128  m_set_flags(0) {
129  if (all_flags_set)
130  m_set_flags.Set(~((Flags::ValueType)0));
131 }
132 
133 BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
134  int32_t ignore, bool one_shot,
135  bool auto_continue)
136  : m_callback(nullptr), m_baton_is_command_baton(false),
137  m_callback_is_synchronous(false), m_enabled(enabled),
138  m_one_shot(one_shot), m_ignore_count(ignore),
139  m_condition_text_hash(0), m_auto_continue(auto_continue)
140 {
141  m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot
142  | eAutoContinue);
143  if (condition && *condition != '\0') {
144  SetCondition(condition);
145  }
146 }
147 
148 // BreakpointOptions copy constructor
150  : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
151  m_baton_is_command_baton(rhs.m_baton_is_command_baton),
152  m_callback_is_synchronous(rhs.m_callback_is_synchronous),
153  m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot),
154  m_ignore_count(rhs.m_ignore_count), m_thread_spec_up(),
155  m_auto_continue(rhs.m_auto_continue), m_set_flags(rhs.m_set_flags) {
156  if (rhs.m_thread_spec_up != nullptr)
157  m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
158  m_condition_text = rhs.m_condition_text;
159  m_condition_text_hash = rhs.m_condition_text_hash;
160 }
161 
162 // BreakpointOptions assignment operator
165  m_callback = rhs.m_callback;
166  m_callback_baton_sp = rhs.m_callback_baton_sp;
167  m_baton_is_command_baton = rhs.m_baton_is_command_baton;
168  m_callback_is_synchronous = rhs.m_callback_is_synchronous;
169  m_enabled = rhs.m_enabled;
170  m_one_shot = rhs.m_one_shot;
171  m_ignore_count = rhs.m_ignore_count;
172  if (rhs.m_thread_spec_up != nullptr)
173  m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
174  m_condition_text = rhs.m_condition_text;
175  m_condition_text_hash = rhs.m_condition_text_hash;
176  m_auto_continue = rhs.m_auto_continue;
177  m_set_flags = rhs.m_set_flags;
178  return *this;
179 }
180 
182 {
183  if (incoming.m_set_flags.Test(eEnabled))
184  {
185  m_enabled = incoming.m_enabled;
186  m_set_flags.Set(eEnabled);
187  }
188  if (incoming.m_set_flags.Test(eOneShot))
189  {
190  m_one_shot = incoming.m_one_shot;
191  m_set_flags.Set(eOneShot);
192  }
193  if (incoming.m_set_flags.Test(eCallback))
194  {
195  m_callback = incoming.m_callback;
196  m_callback_baton_sp = incoming.m_callback_baton_sp;
197  m_callback_is_synchronous = incoming.m_callback_is_synchronous;
198  m_baton_is_command_baton = incoming.m_baton_is_command_baton;
199  m_set_flags.Set(eCallback);
200  }
201  if (incoming.m_set_flags.Test(eIgnoreCount))
202  {
203  m_ignore_count = incoming.m_ignore_count;
204  m_set_flags.Set(eIgnoreCount);
205  }
206  if (incoming.m_set_flags.Test(eCondition))
207  {
208  // If we're copying over an empty condition, mark it as unset.
209  if (incoming.m_condition_text.empty()) {
210  m_condition_text.clear();
211  m_condition_text_hash = 0;
212  m_set_flags.Clear(eCondition);
213  } else {
214  m_condition_text = incoming.m_condition_text;
215  m_condition_text_hash = incoming.m_condition_text_hash;
216  m_set_flags.Set(eCondition);
217  }
218  }
219  if (incoming.m_set_flags.Test(eAutoContinue))
220  {
221  m_auto_continue = incoming.m_auto_continue;
222  m_set_flags.Set(eAutoContinue);
223  }
224  if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_up) {
225  if (!m_thread_spec_up)
226  m_thread_spec_up.reset(new ThreadSpec(*incoming.m_thread_spec_up));
227  else
228  *m_thread_spec_up = *incoming.m_thread_spec_up;
229  m_set_flags.Set(eThreadSpec);
230  }
231 }
232 
233 // Destructor
235 
236 std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
237  Target &target, const StructuredData::Dictionary &options_dict,
238  Status &error) {
239  bool enabled = true;
240  bool one_shot = false;
241  bool auto_continue = false;
242  int32_t ignore_count = 0;
243  llvm::StringRef condition_ref("");
244  Flags set_options;
245 
246  const char *key = GetKey(OptionNames::EnabledState);
247  bool success;
248  if (key && options_dict.HasKey(key)) {
249  success = options_dict.GetValueForKeyAsBoolean(key, enabled);
250  if (!success) {
251  error.SetErrorStringWithFormat("%s key is not a boolean.", key);
252  return nullptr;
253  }
254  set_options.Set(eEnabled);
255  }
256 
258  if (key && options_dict.HasKey(key)) {
259  success = options_dict.GetValueForKeyAsBoolean(key, one_shot);
260  if (!success) {
261  error.SetErrorStringWithFormat("%s key is not a boolean.", key);
262  return nullptr;
263  }
264  set_options.Set(eOneShot);
265  }
266 
268  if (key && options_dict.HasKey(key)) {
269  success = options_dict.GetValueForKeyAsBoolean(key, auto_continue);
270  if (!success) {
271  error.SetErrorStringWithFormat("%s key is not a boolean.", key);
272  return nullptr;
273  }
274  set_options.Set(eAutoContinue);
275  }
276 
278  if (key && options_dict.HasKey(key)) {
279  success = options_dict.GetValueForKeyAsInteger(key, ignore_count);
280  if (!success) {
281  error.SetErrorStringWithFormat("%s key is not an integer.", key);
282  return nullptr;
283  }
284  set_options.Set(eIgnoreCount);
285  }
286 
288  if (key && options_dict.HasKey(key)) {
289  success = options_dict.GetValueForKeyAsString(key, condition_ref);
290  if (!success) {
291  error.SetErrorStringWithFormat("%s key is not an string.", key);
292  return nullptr;
293  }
294  set_options.Set(eCondition);
295  }
296 
297  std::unique_ptr<CommandData> cmd_data_up;
298  StructuredData::Dictionary *cmds_dict;
299  success = options_dict.GetValueForKeyAsDictionary(
300  CommandData::GetSerializationKey(), cmds_dict);
301  if (success && cmds_dict) {
302  Status cmds_error;
303  cmd_data_up = CommandData::CreateFromStructuredData(*cmds_dict, cmds_error);
304  if (cmds_error.Fail()) {
306  "Failed to deserialize breakpoint command options: %s.",
307  cmds_error.AsCString());
308  return nullptr;
309  }
310  }
311 
312  auto bp_options = llvm::make_unique<BreakpointOptions>(
313  condition_ref.str().c_str(), enabled,
314  ignore_count, one_shot, auto_continue);
315  if (cmd_data_up) {
316  if (cmd_data_up->interpreter == eScriptLanguageNone)
317  bp_options->SetCommandDataCallback(cmd_data_up);
318  else {
320  if (!interp) {
322  "Can't set script commands - no script interpreter");
323  return nullptr;
324  }
325  if (interp->GetLanguage() != cmd_data_up->interpreter) {
327  "Current script language doesn't match breakpoint's language: %s",
328  ScriptInterpreter::LanguageToString(cmd_data_up->interpreter)
329  .c_str());
330  return nullptr;
331  }
332  Status script_error;
333  script_error =
334  interp->SetBreakpointCommandCallback(bp_options.get(), cmd_data_up);
335  if (script_error.Fail()) {
336  error.SetErrorStringWithFormat("Error generating script callback: %s.",
337  error.AsCString());
338  return nullptr;
339  }
340  }
341  }
342 
343  StructuredData::Dictionary *thread_spec_dict;
344  success = options_dict.GetValueForKeyAsDictionary(
345  ThreadSpec::GetSerializationKey(), thread_spec_dict);
346  if (success) {
347  Status thread_spec_error;
348  std::unique_ptr<ThreadSpec> thread_spec_up =
349  ThreadSpec::CreateFromStructuredData(*thread_spec_dict,
350  thread_spec_error);
351  if (thread_spec_error.Fail()) {
353  "Failed to deserialize breakpoint thread spec options: %s.",
354  thread_spec_error.AsCString());
355  return nullptr;
356  }
357  bp_options->SetThreadSpec(thread_spec_up);
358  }
359  return bp_options;
360 }
361 
363  StructuredData::DictionarySP options_dict_sp(
365  if (m_set_flags.Test(eEnabled))
366  options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
367  m_enabled);
368  if (m_set_flags.Test(eOneShot))
369  options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
370  m_one_shot);
371  if (m_set_flags.Test(eAutoContinue))
372  options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
373  m_auto_continue);
374  if (m_set_flags.Test(eIgnoreCount))
375  options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
376  m_ignore_count);
377  if (m_set_flags.Test(eCondition))
378  options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
379  m_condition_text);
380 
381  if (m_set_flags.Test(eCallback) && m_baton_is_command_baton) {
382  auto cmd_baton =
383  std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
384  StructuredData::ObjectSP commands_sp =
385  cmd_baton->getItem()->SerializeToStructuredData();
386  if (commands_sp) {
387  options_dict_sp->AddItem(
389  }
390  }
391  if (m_set_flags.Test(eThreadSpec) && m_thread_spec_up) {
392  StructuredData::ObjectSP thread_spec_sp =
393  m_thread_spec_up->SerializeToStructuredData();
394  options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
395  }
396 
397  return options_dict_sp;
398 }
399 
400 // Callbacks
401 void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
402  const lldb::BatonSP &callback_baton_sp,
403  bool callback_is_synchronous) {
404  // FIXME: This seems unsafe. If BatonSP actually *is* a CommandBaton, but
405  // in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>, then we will
406  // set m_baton_is_command_baton to false, which is incorrect. One possible
407  // solution is to make the base Baton class provide a method such as:
408  // virtual StringRef getBatonId() const { return ""; }
409  // and have CommandBaton override this to return something unique, and then
410  // check for it here. Another option might be to make Baton using the llvm
411  // casting infrastructure, so that we could write something like:
412  // if (llvm::isa<CommandBaton>(callback_baton_sp))
413  // at relevant callsites instead of storing a boolean.
414  m_callback_is_synchronous = callback_is_synchronous;
415  m_callback = callback;
416  m_callback_baton_sp = callback_baton_sp;
417  m_baton_is_command_baton = false;
418  m_set_flags.Set(eCallback);
419 }
420 
422  BreakpointHitCallback callback,
423  const BreakpointOptions::CommandBatonSP &callback_baton_sp,
424  bool callback_is_synchronous) {
425  m_callback_is_synchronous = callback_is_synchronous;
426  m_callback = callback;
427  m_callback_baton_sp = callback_baton_sp;
428  m_baton_is_command_baton = true;
429  m_set_flags.Set(eCallback);
430 }
431 
433  m_callback = BreakpointOptions::NullCallback;
434  m_callback_is_synchronous = false;
435  m_callback_baton_sp.reset();
436  m_baton_is_command_baton = false;
437  m_set_flags.Clear(eCallback);
438 }
439 
440 Baton *BreakpointOptions::GetBaton() { return m_callback_baton_sp.get(); }
441 
443  return m_callback_baton_sp.get();
444 }
445 
447  lldb::user_id_t break_id,
448  lldb::user_id_t break_loc_id) {
449  if (m_callback) {
450  if (context->is_synchronous == IsCallbackSynchronous()) {
451  return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
452  : nullptr,
453  context, break_id, break_loc_id);
454  } else if (IsCallbackSynchronous()) {
455  // If a synchronous callback is called at async time, it should not say
456  // to stop.
457  return false;
458  }
459  }
460  return true;
461 }
462 
464  return m_callback != BreakpointOptions::NullCallback;
465 }
466 
468  if (!HasCallback())
469  return false;
470  if (!m_baton_is_command_baton)
471  return false;
472 
473  auto cmd_baton = std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
474  CommandData *data = cmd_baton->getItem();
475  if (!data)
476  return false;
477  command_list = data->user_source;
478  return true;
479 }
480 
481 void BreakpointOptions::SetCondition(const char *condition) {
482  if (!condition || condition[0] == '\0') {
483  condition = "";
484  m_set_flags.Clear(eCondition);
485  }
486  else
487  m_set_flags.Set(eCondition);
488 
489  m_condition_text.assign(condition);
490  std::hash<std::string> hasher;
491  m_condition_text_hash = hasher(m_condition_text);
492 }
493 
494 const char *BreakpointOptions::GetConditionText(size_t *hash) const {
495  if (!m_condition_text.empty()) {
496  if (hash)
497  *hash = m_condition_text_hash;
498 
499  return m_condition_text.c_str();
500  } else {
501  return nullptr;
502  }
503 }
504 
506  return m_thread_spec_up.get();
507 }
508 
510  if (m_thread_spec_up == nullptr) {
511  m_set_flags.Set(eThreadSpec);
512  m_thread_spec_up.reset(new ThreadSpec());
513  }
514 
515  return m_thread_spec_up.get();
516 }
517 
519  GetThreadSpec()->SetTID(thread_id);
520  m_set_flags.Set(eThreadSpec);
521 }
522 
524  std::unique_ptr<ThreadSpec> &thread_spec_up) {
525  m_thread_spec_up = std::move(thread_spec_up);
526  m_set_flags.Set(eThreadSpec);
527 }
528 
530  lldb::DescriptionLevel level) const {
531  // Figure out if there are any options not at their default value, and only
532  // print anything if there are:
533 
534  if (m_ignore_count != 0 || !m_enabled || m_one_shot || m_auto_continue ||
535  (GetThreadSpecNoCreate() != nullptr &&
536  GetThreadSpecNoCreate()->HasSpecification())) {
537  if (level == lldb::eDescriptionLevelVerbose) {
538  s->EOL();
539  s->IndentMore();
540  s->Indent();
541  s->PutCString("Breakpoint Options:\n");
542  s->IndentMore();
543  s->Indent();
544  } else
545  s->PutCString(" Options: ");
546 
547  if (m_ignore_count > 0)
548  s->Printf("ignore: %d ", m_ignore_count);
549  s->Printf("%sabled ", m_enabled ? "en" : "dis");
550 
551  if (m_one_shot)
552  s->Printf("one-shot ");
553 
554  if (m_auto_continue)
555  s->Printf("auto-continue ");
556 
557  if (m_thread_spec_up)
558  m_thread_spec_up->GetDescription(s, level);
559 
560  if (level == lldb::eDescriptionLevelFull) {
561  s->IndentLess();
562  s->IndentMore();
563  }
564  }
565 
566  if (m_callback_baton_sp.get()) {
567  if (level != eDescriptionLevelBrief) {
568  s->EOL();
569  m_callback_baton_sp->GetDescription(s, level);
570  }
571  }
572  if (!m_condition_text.empty()) {
573  if (level != eDescriptionLevelBrief) {
574  s->EOL();
575  s->Printf("Condition: %s\n", m_condition_text.c_str());
576  }
577  }
578 }
579 
581  Stream *s, lldb::DescriptionLevel level) const {
582  const CommandData *data = getItem();
583 
584  if (level == eDescriptionLevelBrief) {
585  s->Printf(", commands = %s",
586  (data && data->user_source.GetSize() > 0) ? "yes" : "no");
587  return;
588  }
589 
590  s->IndentMore();
591  s->Indent("Breakpoint commands");
592  if (data->interpreter != eScriptLanguageNone)
593  s->Printf(" (%s):\n",
595  else
596  s->PutCString(":\n");
597 
598  s->IndentMore();
599  if (data && data->user_source.GetSize() > 0) {
600  const size_t num_strings = data->user_source.GetSize();
601  for (size_t i = 0; i < num_strings; ++i) {
602  s->Indent(data->user_source.GetStringAtIndex(i));
603  s->EOL();
604  }
605  } else {
606  s->PutCString("No commands.\n");
607  }
608  s->IndentLess();
609  s->IndentLess();
610 }
611 
613  std::unique_ptr<CommandData> &cmd_data) {
614  cmd_data->interpreter = eScriptLanguageNone;
615  auto baton_sp = std::make_shared<CommandBaton>(std::move(cmd_data));
617  m_set_flags.Set(eCallback);
618 }
619 
621  void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
622  lldb::user_id_t break_loc_id) {
623  bool ret_value = true;
624  if (baton == nullptr)
625  return true;
626 
627  CommandData *data = (CommandData *)baton;
628  StringList &commands = data->user_source;
629 
630  if (commands.GetSize() > 0) {
631  ExecutionContext exe_ctx(context->exe_ctx_ref);
632  Target *target = exe_ctx.GetTargetPtr();
633  if (target) {
634  CommandReturnObject result;
635  Debugger &debugger = target->GetDebugger();
636  // Rig up the results secondary output stream to the debugger's, so the
637  // output will come out synchronously if the debugger is set up that way.
638 
639  StreamSP output_stream(debugger.GetAsyncOutputStream());
640  StreamSP error_stream(debugger.GetAsyncErrorStream());
641  result.SetImmediateOutputStream(output_stream);
642  result.SetImmediateErrorStream(error_stream);
643 
645  options.SetStopOnContinue(true);
646  options.SetStopOnError(data->stop_on_error);
647  options.SetEchoCommands(true);
648  options.SetPrintResults(true);
649  options.SetAddToHistory(false);
650 
651  debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
652  options, result);
653  result.GetImmediateOutputStream()->Flush();
654  result.GetImmediateErrorStream()->Flush();
655  }
656  }
657  return ret_value;
658 }
659 
661 {
662  m_set_flags.Clear();
663  m_thread_spec_up.release();
664  m_one_shot = false;
665  m_ignore_count = 0;
666  m_auto_continue = false;
667  m_callback = nullptr;
668  m_callback_baton_sp.reset();
669  m_baton_is_command_baton = false;
670  m_callback_is_synchronous = false;
671  m_enabled = false;
672  m_condition_text.clear();
673 }
A class to manage flag bits.
Definition: Debugger.h:82
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
static const char * GetSerializationKey()
Definition: ThreadSpec.h:47
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
CommandInterpreter & GetCommandInterpreter()
Definition: Debugger.h:152
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
std::shared_ptr< Array > ArraySP
static std::unique_ptr< CommandData > CreateFromStructuredData(const StructuredData::Dictionary &options_dict, Status &error)
void ClearCallback()
Remove the callback from this option set.
void SetImmediateErrorStream(const lldb::StreamSP &stream_sp)
void SetCommandDataCallback(std::unique_ptr< CommandData > &cmd_data)
Set a callback based on BreakpointOptions::CommandData.
Baton * GetBaton()
Fetch the baton from the callback.
bool HasCallback() const
Returns true if the breakpoint option has a callback set.
void GetDescription(Stream *s, lldb::DescriptionLevel level) const
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
lldb::StreamSP GetAsyncErrorStream()
Definition: Debugger.cpp:1153
bool GetValueForKeyAsDictionary(llvm::StringRef key, Dictionary *&result) const
std::shared_ptr< Dictionary > DictionarySP
ValueType Clear(ValueType mask=~(ValueType) 0)
Clear one or more flags.
Definition: Flags.h:72
static std::unique_ptr< ThreadSpec > CreateFromStructuredData(const StructuredData::Dictionary &data_dict, Status &error)
Definition: ThreadSpec.cpp:36
static std::string LanguageToString(lldb::ScriptLanguage language)
void SetThreadSpec(std::unique_ptr< ThreadSpec > &thread_spec_up)
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const
Target * GetTargetPtr() const
Returns a pointer to the target object.
void GetDescription(Stream *s, lldb::DescriptionLevel level) const override
lldb::StreamSP GetAsyncOutputStream()
Definition: Debugger.cpp:1149
uint64_t user_id_t
Definition: lldb-types.h:84
void SetCondition(const char *condition)
Set the breakpoint option&#39;s condition.
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:107
const char * GetStringAtIndex(size_t idx) const
Definition: StringList.cpp:82
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
BreakpointOptions(const char *condition, bool enabled=true, int32_t ignore=0, bool one_shot=false, bool auto_continue=false)
This constructor allows you to specify all the breakpoint options except the callback.
virtual StructuredData::ObjectSP SerializeToStructuredData()
uint64_t tid_t
Definition: lldb-types.h:86
void SetImmediateOutputStream(const lldb::StreamSP &stream_sp)
static const char * GetKey(OptionNames enum_value)
const ThreadSpec * GetThreadSpecNoCreate() const
Return the current thread spec for this option.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
void CopyOverSetOptions(const BreakpointOptions &rhs)
Copy over only the options set in the incoming BreakpointOptions.
std::shared_ptr< CommandBaton > CommandBatonSP
void IndentLess(int amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:221
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
ThreadSpec * GetThreadSpec()
Returns a pointer to the ThreadSpec for this option, creating it.
ValueType Set(ValueType mask)
Set one or more flags by logical OR&#39;ing mask with the current flags.
Definition: Flags.h:84
bool HasKey(llvm::StringRef key) const
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const
const BreakpointOptions & operator=(const BreakpointOptions &rhs)
bool InvokeCallback(StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
Use this function to invoke the callback for a specific stop.
std::shared_ptr< String > StringSP
lldb::ScriptLanguage GetLanguage()
size_t GetSize() const
Definition: StringList.cpp:70
Status SetBreakpointCommandCallback(std::vector< BreakpointOptions *> &bp_options_vec, const char *callback_text)
Set the specified text as the callback for the breakpoint.
void HandleCommands(const StringList &commands, ExecutionContext *context, CommandInterpreterRunOptions &options, CommandReturnObject &result)
Execute a list of commands in sequence.
A class to manage flags.
Definition: Flags.h:22
bool GetCommandLineCallbacks(StringList &command_list)
Returns the command line commands for the callback on this breakpoint.
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
ScriptInterpreter * GetScriptInterpreter(bool can_create=true)
Definition: Debugger.cpp:1289
bool IsCallbackSynchronous() const
Used in InvokeCallback to tell whether it is the right time to run this kind of callback.
const char * GetConditionText(size_t *hash=nullptr) const
Return a pointer to the text of the condition expression.
void SetTID(lldb::tid_t tid)
Definition: ThreadSpec.h:51
void SetStopOnContinue(bool stop_on_continue)
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
static std::unique_ptr< BreakpointOptions > CreateFromStructuredData(Target &target, const StructuredData::Dictionary &data_dict, Status &error)
"lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a breakpoint or breakpoint lo...
Definition: SBAddress.h:15
static bool BreakpointOptionsCallbackFunction(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
size_t Indent(const char *s=nullptr)
Indent the current line in the stream.
Definition: Stream.cpp:131
SharingPtr< T > static_pointer_cast(const SharingPtr< U > &r)
Definition: SharingPtr.h:355
std::shared_ptr< Object > ObjectSP
bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const
static bool NullCallback(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
This is the default empty callback.
void SetThreadID(lldb::tid_t thread_id)
void SetErrorStringWithFormatv(const char *format, Args &&... args)
Definition: Status.h:185
A class designed to wrap callback batons so they can cleanup any acquired resources.
Definition: Baton.h:33
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
void SetCallback(BreakpointHitCallback callback, const lldb::BatonSP &baton_sp, bool synchronous=false)
Adds a callback to the breakpoint option set.
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
void IndentMore(int amount=2)
Increment the current indentation level.
Definition: Stream.cpp:218
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:130
StructuredData::ObjectSP SerializeToStructuredData()
Debugger & GetDebugger()
Definition: Target.h:974
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
An error handling class.
Definition: Status.h:44