lldb/source/Breakpoint/BreakpointOptions.cpp

   1 //===-- BreakpointOptions.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/Breakpoint/BreakpointOptions.h"
  10
  11 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  12 #include "lldb/Core/Value.h"
  13 #include "lldb/Interpreter/CommandInterpreter.h"
  14 #include "lldb/Interpreter/CommandReturnObject.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"
  19 #include "lldb/Utility/StringList.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
  31 StructuredData::ObjectSP
  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(
  41       new StructuredData::Dictionary());
  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++) {
  47     StructuredData::StringSP item_sp(
  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
  64   bool success = options_dict.GetValueForKeyAsBoolean(
  65       GetKey(OptionNames::StopOnError), data_up->stop_on_error);
  66
  67   llvm::StringRef interpreter_str;
  68   ScriptLanguage interp_language;
  69   success = options_dict.GetValueForKeyAsString(
  70       GetKey(OptionNames::Interpreter), interpreter_str);
  71
  72   if (!success) {
  73     error.SetErrorString("Missing command language value.");
  74     return data_up;
  75   }
  76
  77   interp_language = ScriptInterpreter::StringToLanguage(interpreter_str);
  78   if (interp_language == eScriptLanguageUnknown) {
  79     error.SetErrorStringWithFormatv("Unknown breakpoint command language: {0}.",
  80                                     interpreter_str);
  81     return data_up;
  82   }
  83   data_up->interpreter = interp_language;
  84
  85   StructuredData::Array *user_source;
  86   success = options_dict.GetValueForKeyAsArray(GetKey(OptionNames::UserSource),
  87                                                user_source);
  88   if (success) {
  89     size_t num_elems = user_source->GetSize();
  90     for (size_t i = 0; i < num_elems; i++) {
  91       llvm::StringRef elem_string;
  92       success = user_source->GetItemAtIndexAsString(i, elem_string);
  93       if (success)
  94         data_up->user_source.AppendString(elem_string);
  95     }
  96   }
  97
  98   return data_up;
  99 }
 100
 101 const char *BreakpointOptions::g_option_names[(
 102     size_t)BreakpointOptions::OptionNames::LastOptionName]{
 103     "ConditionText", "IgnoreCount",
 104     "EnabledState", "OneShotState", "AutoContinue"};
 105
 106 bool BreakpointOptions::NullCallback(void *baton,
 107                                      StoppointCallbackContext *context,
 108                                      lldb::user_id_t break_id,
 109                                      lldb::user_id_t break_loc_id) {
 110   return true;
 111 }
 112
 113 // BreakpointOptions constructor
 114 BreakpointOptions::BreakpointOptions(bool all_flags_set)
 115     : m_callback(BreakpointOptions::NullCallback),
 116       m_baton_is_command_baton(false), m_callback_is_synchronous(false),
 117       m_enabled(true), m_one_shot(false), m_ignore_count(0),
 118       m_condition_text_hash(0), m_inject_condition(false),
 119       m_auto_continue(false), m_set_flags(0) {
 120   if (all_flags_set)
 121     m_set_flags.Set(~((Flags::ValueType)0));
 122 }
 123
 124 BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
 125                                      int32_t ignore, bool one_shot,
 126                                      bool auto_continue)
 127     : m_callback(nullptr), m_baton_is_command_baton(false),
 128       m_callback_is_synchronous(false), m_enabled(enabled),
 129       m_one_shot(one_shot), m_ignore_count(ignore), m_condition_text_hash(0),
 130       m_inject_condition(false), m_auto_continue(auto_continue) {
 131   m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot | eAutoContinue);
 132     if (condition && *condition != '\0') {
 133       SetCondition(condition);
 134     }
 135 }
 136
 137 // BreakpointOptions copy constructor
 138 BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs)
 139     : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
 140       m_baton_is_command_baton(rhs.m_baton_is_command_baton),
 141       m_callback_is_synchronous(rhs.m_callback_is_synchronous),
 142       m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot),
 143       m_ignore_count(rhs.m_ignore_count), m_inject_condition(false),
 144       m_auto_continue(rhs.m_auto_continue), m_set_flags(rhs.m_set_flags) {
 145   if (rhs.m_thread_spec_up != nullptr)
 146     m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up);
 147   m_condition_text = rhs.m_condition_text;
 148   m_condition_text_hash = rhs.m_condition_text_hash;
 149 }
 150
 151 // BreakpointOptions assignment operator
 152 const BreakpointOptions &BreakpointOptions::
 153 operator=(const BreakpointOptions &rhs) {
 154   m_callback = rhs.m_callback;
 155   m_callback_baton_sp = rhs.m_callback_baton_sp;
 156   m_baton_is_command_baton = rhs.m_baton_is_command_baton;
 157   m_callback_is_synchronous = rhs.m_callback_is_synchronous;
 158   m_enabled = rhs.m_enabled;
 159   m_one_shot = rhs.m_one_shot;
 160   m_ignore_count = rhs.m_ignore_count;
 161   if (rhs.m_thread_spec_up != nullptr)
 162     m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up);
 163   m_condition_text = rhs.m_condition_text;
 164   m_condition_text_hash = rhs.m_condition_text_hash;
 165   m_inject_condition = rhs.m_inject_condition;
 166   m_auto_continue = rhs.m_auto_continue;
 167   m_set_flags = rhs.m_set_flags;
 168   return *this;
 169 }
 170
 171 void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
 172 {
 173   if (incoming.m_set_flags.Test(eEnabled))
 174   {
 175     m_enabled = incoming.m_enabled;
 176     m_set_flags.Set(eEnabled);
 177   }
 178   if (incoming.m_set_flags.Test(eOneShot))
 179   {
 180     m_one_shot = incoming.m_one_shot;
 181     m_set_flags.Set(eOneShot);
 182   }
 183   if (incoming.m_set_flags.Test(eCallback))
 184   {
 185     m_callback = incoming.m_callback;
 186     m_callback_baton_sp = incoming.m_callback_baton_sp;
 187     m_callback_is_synchronous = incoming.m_callback_is_synchronous;
 188     m_baton_is_command_baton = incoming.m_baton_is_command_baton;
 189     m_set_flags.Set(eCallback);
 190   }
 191   if (incoming.m_set_flags.Test(eIgnoreCount))
 192   {
 193     m_ignore_count = incoming.m_ignore_count;
 194     m_set_flags.Set(eIgnoreCount);
 195   }
 196   if (incoming.m_set_flags.Test(eCondition))
 197   {
 198     // If we're copying over an empty condition, mark it as unset.
 199     if (incoming.m_condition_text.empty()) {
 200       m_condition_text.clear();
 201       m_condition_text_hash = 0;
 202       m_set_flags.Clear(eCondition);
 203     } else {
 204       m_condition_text = incoming.m_condition_text;
 205       m_condition_text_hash = incoming.m_condition_text_hash;
 206       m_set_flags.Set(eCondition);
 207     }
 208   }
 209   if (incoming.m_set_flags.Test(eAutoContinue))
 210   {
 211     m_auto_continue = incoming.m_auto_continue;
 212     m_set_flags.Set(eAutoContinue);
 213   }
 214   if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_up) {
 215     if (!m_thread_spec_up)
 216       m_thread_spec_up =
 217           std::make_unique<ThreadSpec>(*incoming.m_thread_spec_up);
 218     else
 219       *m_thread_spec_up = *incoming.m_thread_spec_up;
 220     m_set_flags.Set(eThreadSpec);
 221   }
 222 }
 223
 224 // Destructor
 225 BreakpointOptions::~BreakpointOptions() = default;
 226
 227 std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
 228     Target &target, const StructuredData::Dictionary &options_dict,
 229     Status &error) {
 230   bool enabled = true;
 231   bool one_shot = false;
 232   bool auto_continue = false;
 233   uint32_t ignore_count = 0;
 234   llvm::StringRef condition_ref("");
 235   Flags set_options;
 236
 237   const char *key = GetKey(OptionNames::EnabledState);
 238   bool success;
 239   if (key && options_dict.HasKey(key)) {
 240     success = options_dict.GetValueForKeyAsBoolean(key, enabled);
 241     if (!success) {
 242       error.SetErrorStringWithFormat("%s key is not a boolean.", key);
 243       return nullptr;
 244     }
 245     set_options.Set(eEnabled);
 246   }
 247
 248   key = GetKey(OptionNames::OneShotState);
 249   if (key && options_dict.HasKey(key)) {
 250     success = options_dict.GetValueForKeyAsBoolean(key, one_shot);
 251     if (!success) {
 252       error.SetErrorStringWithFormat("%s key is not a boolean.", key);
 253       return nullptr;
 254       }
 255       set_options.Set(eOneShot);
 256   }
 257
 258   key = GetKey(OptionNames::AutoContinue);
 259   if (key && options_dict.HasKey(key)) {
 260     success = options_dict.GetValueForKeyAsBoolean(key, auto_continue);
 261     if (!success) {
 262       error.SetErrorStringWithFormat("%s key is not a boolean.", key);
 263       return nullptr;
 264       }
 265       set_options.Set(eAutoContinue);
 266   }
 267
 268   key = GetKey(OptionNames::IgnoreCount);
 269   if (key && options_dict.HasKey(key)) {
 270     success = options_dict.GetValueForKeyAsInteger(key, ignore_count);
 271     if (!success) {
 272       error.SetErrorStringWithFormat("%s key is not an integer.", key);
 273       return nullptr;
 274     }
 275     set_options.Set(eIgnoreCount);
 276   }
 277
 278   key = GetKey(OptionNames::ConditionText);
 279   if (key && options_dict.HasKey(key)) {
 280     success = options_dict.GetValueForKeyAsString(key, condition_ref);
 281     if (!success) {
 282       error.SetErrorStringWithFormat("%s key is not an string.", key);
 283       return nullptr;
 284     }
 285     set_options.Set(eCondition);
 286   }
 287
 288   std::unique_ptr<CommandData> cmd_data_up;
 289   StructuredData::Dictionary *cmds_dict;
 290   success = options_dict.GetValueForKeyAsDictionary(
 291       CommandData::GetSerializationKey(), cmds_dict);
 292   if (success && cmds_dict) {
 293     Status cmds_error;
 294     cmd_data_up = CommandData::CreateFromStructuredData(*cmds_dict, cmds_error);
 295     if (cmds_error.Fail()) {
 296       error.SetErrorStringWithFormat(
 297           "Failed to deserialize breakpoint command options: %s.",
 298           cmds_error.AsCString());
 299       return nullptr;
 300     }
 301   }
 302
 303   auto bp_options = std::make_unique<BreakpointOptions>(
 304       condition_ref.str().c_str(), enabled,
 305       ignore_count, one_shot, auto_continue);
 306   if (cmd_data_up) {
 307     if (cmd_data_up->interpreter == eScriptLanguageNone)
 308       bp_options->SetCommandDataCallback(cmd_data_up);
 309     else {
 310       ScriptInterpreter *interp = target.GetDebugger().GetScriptInterpreter();
 311       if (!interp) {
 312         error.SetErrorString(
 313             "Can't set script commands - no script interpreter");
 314         return nullptr;
 315       }
 316       if (interp->GetLanguage() != cmd_data_up->interpreter) {
 317         error.SetErrorStringWithFormat(
 318             "Current script language doesn't match breakpoint's language: %s",
 319             ScriptInterpreter::LanguageToString(cmd_data_up->interpreter)
 320                 .c_str());
 321         return nullptr;
 322       }
 323       Status script_error;
 324       script_error =
 325           interp->SetBreakpointCommandCallback(*bp_options, cmd_data_up);
 326       if (script_error.Fail()) {
 327         error.SetErrorStringWithFormat("Error generating script callback: %s.",
 328                                        error.AsCString());
 329         return nullptr;
 330       }
 331     }
 332   }
 333
 334   StructuredData::Dictionary *thread_spec_dict;
 335   success = options_dict.GetValueForKeyAsDictionary(
 336       ThreadSpec::GetSerializationKey(), thread_spec_dict);
 337   if (success) {
 338     Status thread_spec_error;
 339     std::unique_ptr<ThreadSpec> thread_spec_up =
 340         ThreadSpec::CreateFromStructuredData(*thread_spec_dict,
 341                                              thread_spec_error);
 342     if (thread_spec_error.Fail()) {
 343       error.SetErrorStringWithFormat(
 344           "Failed to deserialize breakpoint thread spec options: %s.",
 345           thread_spec_error.AsCString());
 346       return nullptr;
 347     }
 348     bp_options->SetThreadSpec(thread_spec_up);
 349   }
 350   return bp_options;
 351 }
 352
 353 StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() {
 354   StructuredData::DictionarySP options_dict_sp(
 355       new StructuredData::Dictionary());
 356   if (m_set_flags.Test(eEnabled))
 357     options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
 358                                     m_enabled);
 359   if (m_set_flags.Test(eOneShot))
 360     options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
 361                                m_one_shot);
 362   if (m_set_flags.Test(eAutoContinue))
 363     options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
 364                                m_auto_continue);
 365   if (m_set_flags.Test(eIgnoreCount))
 366     options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
 367                                     m_ignore_count);
 368   if (m_set_flags.Test(eCondition))
 369     options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
 370                                    m_condition_text);
 371
 372   if (m_set_flags.Test(eCallback) && m_baton_is_command_baton) {
 373     auto cmd_baton =
 374         std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
 375     StructuredData::ObjectSP commands_sp =
 376         cmd_baton->getItem()->SerializeToStructuredData();
 377     if (commands_sp) {
 378       options_dict_sp->AddItem(
 379           BreakpointOptions::CommandData::GetSerializationKey(), commands_sp);
 380     }
 381   }
 382   if (m_set_flags.Test(eThreadSpec) && m_thread_spec_up) {
 383     StructuredData::ObjectSP thread_spec_sp =
 384         m_thread_spec_up->SerializeToStructuredData();
 385     options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
 386   }
 387
 388   return options_dict_sp;
 389 }
 390
 391 // Callbacks
 392 void BreakpointOptions::SetCallback(BreakpointHitCallback callback,
 393                                     const lldb::BatonSP &callback_baton_sp,
 394                                     bool callback_is_synchronous) {
 395   // FIXME: This seems unsafe.  If BatonSP actually *is* a CommandBaton, but
 396   // in a shared_ptr<Baton> instead of a shared_ptr<CommandBaton>, then we will
 397   // set m_baton_is_command_baton to false, which is incorrect. One possible
 398   // solution is to make the base Baton class provide a method such as:
 399   //     virtual StringRef getBatonId() const { return ""; }
 400   // and have CommandBaton override this to return something unique, and then
 401   // check for it here.  Another option might be to make Baton using the llvm
 402   // casting infrastructure, so that we could write something like:
 403   //     if (llvm::isa<CommandBaton>(callback_baton_sp))
 404   // at relevant callsites instead of storing a boolean.
 405   m_callback_is_synchronous = callback_is_synchronous;
 406   m_callback = callback;
 407   m_callback_baton_sp = callback_baton_sp;
 408   m_baton_is_command_baton = false;
 409   m_set_flags.Set(eCallback);
 410 }
 411
 412 void BreakpointOptions::SetCallback(
 413     BreakpointHitCallback callback,
 414     const BreakpointOptions::CommandBatonSP &callback_baton_sp,
 415     bool callback_is_synchronous) {
 416   m_callback_is_synchronous = callback_is_synchronous;
 417   m_callback = callback;
 418   m_callback_baton_sp = callback_baton_sp;
 419   m_baton_is_command_baton = true;
 420   m_set_flags.Set(eCallback);
 421 }
 422
 423 void BreakpointOptions::ClearCallback() {
 424   m_callback = BreakpointOptions::NullCallback;
 425   m_callback_is_synchronous = false;
 426   m_callback_baton_sp.reset();
 427   m_baton_is_command_baton = false;
 428   m_set_flags.Clear(eCallback);
 429 }
 430
 431 Baton *BreakpointOptions::GetBaton() { return m_callback_baton_sp.get(); }
 432
 433 const Baton *BreakpointOptions::GetBaton() const {
 434   return m_callback_baton_sp.get();
 435 }
 436
 437 bool BreakpointOptions::InvokeCallback(StoppointCallbackContext *context,
 438                                        lldb::user_id_t break_id,
 439                                        lldb::user_id_t break_loc_id) {
 440   if (m_callback) {
 441     if (context->is_synchronous == IsCallbackSynchronous()) {
 442         return m_callback(m_callback_baton_sp ? m_callback_baton_sp->data()
 443                                           : nullptr,
 444                       context, break_id, break_loc_id);
 445     } else if (IsCallbackSynchronous()) {
 446       return false;
 447     }
 448   }
 449   return true;
 450 }
 451
 452 bool BreakpointOptions::HasCallback() const {
 453   return m_callback != BreakpointOptions::NullCallback;
 454 }
 455
 456 bool BreakpointOptions::GetCommandLineCallbacks(StringList &command_list) {
 457   if (!HasCallback())
 458     return false;
 459   if (!m_baton_is_command_baton)
 460     return false;
 461
 462   auto cmd_baton = std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
 463   CommandData *data = cmd_baton->getItem();
 464   if (!data)
 465     return false;
 466   command_list = data->user_source;
 467   return true;
 468 }
 469
 470 void BreakpointOptions::SetCondition(const char *condition) {
 471   if (!condition || condition[0] == '\0') {
 472     condition = "";
 473     m_set_flags.Clear(eCondition);
 474   }
 475   else
 476     m_set_flags.Set(eCondition);
 477
 478   m_condition_text.assign(condition);
 479   std::hash<std::string> hasher;
 480   m_condition_text_hash = hasher(m_condition_text);
 481 }
 482
 483 const char *BreakpointOptions::GetConditionText(size_t *hash) const {
 484   if (!m_condition_text.empty()) {
 485     if (hash)
 486       *hash = m_condition_text_hash;
 487
 488     return m_condition_text.c_str();
 489   } else {
 490     return nullptr;
 491   }
 492 }
 493
 494 const ThreadSpec *BreakpointOptions::GetThreadSpecNoCreate() const {
 495   return m_thread_spec_up.get();
 496 }
 497
 498 ThreadSpec *BreakpointOptions::GetThreadSpec() {
 499   if (m_thread_spec_up == nullptr) {
 500     m_set_flags.Set(eThreadSpec);
 501     m_thread_spec_up = std::make_unique<ThreadSpec>();
 502   }
 503
 504   return m_thread_spec_up.get();
 505 }
 506
 507 void BreakpointOptions::SetThreadID(lldb::tid_t thread_id) {
 508   GetThreadSpec()->SetTID(thread_id);
 509   m_set_flags.Set(eThreadSpec);
 510 }
 511
 512 void BreakpointOptions::SetThreadSpec(
 513     std::unique_ptr<ThreadSpec> &thread_spec_up) {
 514   m_thread_spec_up = std::move(thread_spec_up);
 515   m_set_flags.Set(eThreadSpec);
 516 }
 517
 518 void BreakpointOptions::GetDescription(Stream *s,
 519                                        lldb::DescriptionLevel level) const {
 520   // Figure out if there are any options not at their default value, and only
 521   // print anything if there are:
 522
 523   if (m_ignore_count != 0 || !m_enabled || m_one_shot || m_auto_continue ||
 524       (GetThreadSpecNoCreate() != nullptr &&
 525        GetThreadSpecNoCreate()->HasSpecification())) {
 526     if (level == lldb::eDescriptionLevelVerbose) {
 527       s->EOL();
 528       s->IndentMore();
 529       s->Indent();
 530       s->PutCString("Breakpoint Options:\n");
 531       s->IndentMore();
 532       s->Indent();
 533     } else
 534       s->PutCString(" Options: ");
 535
 536     if (m_ignore_count > 0)
 537       s->Printf("ignore: %d ", m_ignore_count);
 538     s->Printf("%sabled ", m_enabled ? "en" : "dis");
 539
 540     if (m_one_shot)
 541       s->Printf("one-shot ");
 542
 543     if (m_auto_continue)
 544       s->Printf("auto-continue ");
 545
 546     if (m_thread_spec_up)
 547       m_thread_spec_up->GetDescription(s, level);
 548
 549     if (level == lldb::eDescriptionLevelFull) {
 550       s->IndentLess();
 551       s->IndentMore();
 552     }
 553   }
 554
 555   if (m_callback_baton_sp.get()) {
 556     if (level != eDescriptionLevelBrief) {
 557       s->EOL();
 558       m_callback_baton_sp->GetDescription(s->AsRawOstream(), level,
 559                                           s->GetIndentLevel());
 560     }
 561   }
 562   if (!m_condition_text.empty()) {
 563     if (level != eDescriptionLevelBrief) {
 564       s->EOL();
 565       s->Printf("Condition: %s\n", m_condition_text.c_str());
 566     }
 567   }
 568 }
 569
 570 void BreakpointOptions::CommandBaton::GetDescription(
 571     llvm::raw_ostream &s, lldb::DescriptionLevel level,
 572     unsigned indentation) const {
 573   const CommandData *data = getItem();
 574
 575   if (level == eDescriptionLevelBrief) {
 576     s << ", commands = "
 577       << ((data && data->user_source.GetSize() > 0) ? "yes" : "no");
 578     return;
 579   }
 580
 581   indentation += 2;
 582   s.indent(indentation);
 583   s << "Breakpoint commands";
 584   if (data->interpreter != eScriptLanguageNone)
 585     s << llvm::formatv(" ({0}):\n",
 586                        ScriptInterpreter::LanguageToString(data->interpreter));
 587   else
 588     s << ":\n";
 589
 590   indentation += 2;
 591   if (data && data->user_source.GetSize() > 0) {
 592     for (llvm::StringRef str : data->user_source) {
 593       s.indent(indentation);
 594       s << str << "\n";
 595     }
 596   } else
 597     s << "No commands.\n";
 598 }
 599
 600 void BreakpointOptions::SetCommandDataCallback(
 601     std::unique_ptr<CommandData> &cmd_data) {
 602   cmd_data->interpreter = eScriptLanguageNone;
 603   auto baton_sp = std::make_shared<CommandBaton>(std::move(cmd_data));
 604   SetCallback(BreakpointOptions::BreakpointOptionsCallbackFunction, baton_sp);
 605   m_set_flags.Set(eCallback);
 606 }
 607
 608 bool BreakpointOptions::BreakpointOptionsCallbackFunction(
 609     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
 610     lldb::user_id_t break_loc_id) {
 611   bool ret_value = true;
 612   if (baton == nullptr)
 613     return true;
 614
 615   CommandData *data = (CommandData *)baton;
 616   StringList &commands = data->user_source;
 617
 618   if (commands.GetSize() > 0) {
 619     ExecutionContext exe_ctx(context->exe_ctx_ref);
 620     Target *target = exe_ctx.GetTargetPtr();
 621     if (target) {
 622       Debugger &debugger = target->GetDebugger();
 623       CommandReturnObject result(debugger.GetUseColor());
 624
 625       // Rig up the results secondary output stream to the debugger's, so the
 626       // output will come out synchronously if the debugger is set up that way.
 627       StreamSP output_stream(debugger.GetAsyncOutputStream());
 628       StreamSP error_stream(debugger.GetAsyncErrorStream());
 629       result.SetImmediateOutputStream(output_stream);
 630       result.SetImmediateErrorStream(error_stream);
 631
 632       CommandInterpreterRunOptions options;
 633       options.SetStopOnContinue(true);
 634       options.SetStopOnError(data->stop_on_error);
 635       options.SetEchoCommands(true);
 636       options.SetPrintResults(true);
 637       options.SetPrintErrors(true);
 638       options.SetAddToHistory(false);
 639
 640       debugger.GetCommandInterpreter().HandleCommands(commands, exe_ctx,
 641                                                       options, result);
 642       result.GetImmediateOutputStream()->Flush();
 643       result.GetImmediateErrorStream()->Flush();
 644     }
 645   }
 646   return ret_value;
 647 }
 648
 649 void BreakpointOptions::Clear()
 650 {
 651   m_set_flags.Clear();
 652   m_thread_spec_up.release();
 653   m_one_shot = false;
 654   m_ignore_count = 0;
 655   m_auto_continue = false;
 656   m_callback = nullptr;
 657   m_callback_baton_sp.reset();
 658   m_baton_is_command_baton = false;
 659   m_callback_is_synchronous = false;
 660   m_enabled = false;
 661   m_condition_text.clear();
 662 }