contrib/llvm-project/lldb/source/Core/Debugger.cpp

   1 //===-- Debugger.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
   9 #include "lldb/Core/Debugger.h"
  10
  11 #include "lldb/Breakpoint/Breakpoint.h"
  12 #include "lldb/Core/FormatEntity.h"
  13 #include "lldb/Core/Mangled.h"
  14 #include "lldb/Core/ModuleList.h"
  15 #include "lldb/Core/PluginManager.h"
  16 #include "lldb/Core/StreamAsynchronousIO.h"
  17 #include "lldb/Core/StreamFile.h"
  18 #include "lldb/DataFormatters/DataVisualization.h"
  19 #include "lldb/Expression/REPL.h"
  20 #include "lldb/Host/File.h"
  21 #include "lldb/Host/FileSystem.h"
  22 #include "lldb/Host/HostInfo.h"
  23 #include "lldb/Host/Terminal.h"
  24 #include "lldb/Host/ThreadLauncher.h"
  25 #include "lldb/Interpreter/CommandInterpreter.h"
  26 #include "lldb/Interpreter/OptionValue.h"
  27 #include "lldb/Interpreter/OptionValueProperties.h"
  28 #include "lldb/Interpreter/OptionValueSInt64.h"
  29 #include "lldb/Interpreter/OptionValueString.h"
  30 #include "lldb/Interpreter/Property.h"
  31 #include "lldb/Interpreter/ScriptInterpreter.h"
  32 #include "lldb/Symbol/Function.h"
  33 #include "lldb/Symbol/Symbol.h"
  34 #include "lldb/Symbol/SymbolContext.h"
  35 #include "lldb/Target/Language.h"
  36 #include "lldb/Target/Process.h"
  37 #include "lldb/Target/StructuredDataPlugin.h"
  38 #include "lldb/Target/Target.h"
  39 #include "lldb/Target/TargetList.h"
  40 #include "lldb/Target/Thread.h"
  41 #include "lldb/Target/ThreadList.h"
  42 #include "lldb/Utility/AnsiTerminal.h"
  43 #include "lldb/Utility/Event.h"
  44 #include "lldb/Utility/Listener.h"
  45 #include "lldb/Utility/Log.h"
  46 #include "lldb/Utility/Reproducer.h"
  47 #include "lldb/Utility/State.h"
  48 #include "lldb/Utility/Stream.h"
  49 #include "lldb/Utility/StreamCallback.h"
  50 #include "lldb/Utility/StreamString.h"
  51
  52 #if defined(_WIN32)
  53 #include "lldb/Host/windows/PosixApi.h"
  54 #include "lldb/Host/windows/windows.h"
  55 #endif
  56
  57 #include "llvm/ADT/None.h"
  58 #include "llvm/ADT/STLExtras.h"
  59 #include "llvm/ADT/StringRef.h"
  60 #include "llvm/ADT/iterator.h"
  61 #include "llvm/Support/DynamicLibrary.h"
  62 #include "llvm/Support/FileSystem.h"
  63 #include "llvm/Support/Process.h"
  64 #include "llvm/Support/Threading.h"
  65 #include "llvm/Support/raw_ostream.h"
  66
  67 #include <list>
  68 #include <memory>
  69 #include <mutex>
  70 #include <set>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 #include <string.h>
  74 #include <string>
  75 #include <system_error>
  76
  77 namespace lldb_private {
  78 class Address;
  79 }
  80
  81 using namespace lldb;
  82 using namespace lldb_private;
  83
  84 static lldb::user_id_t g_unique_id = 1;
  85 static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
  86
  87 #pragma mark Static Functions
  88
  89 typedef std::vector<DebuggerSP> DebuggerList;
  90 static std::recursive_mutex *g_debugger_list_mutex_ptr =
  91     nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
  92 static DebuggerList *g_debugger_list_ptr =
  93     nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
  94
  95 static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
  96     {Debugger::eStopDisassemblyTypeNever, "never",
  97      "Never show disassembly when displaying a stop context."},
  98     {Debugger::eStopDisassemblyTypeNoDebugInfo, "no-debuginfo",
  99      "Show disassembly when there is no debug information."},
 100     {Debugger::eStopDisassemblyTypeNoSource, "no-source",
 101      "Show disassembly when there is no source information, or the source file "
 102      "is missing when displaying a stop context."},
 103     {Debugger::eStopDisassemblyTypeAlways, "always",
 104      "Always show disassembly when displaying a stop context."} };
 105
 106 static constexpr OptionEnumValueElement g_language_enumerators[] = {
 107     {eScriptLanguageNone, "none", "Disable scripting languages."},
 108     {eScriptLanguagePython, "python",
 109      "Select python as the default scripting language."},
 110     {eScriptLanguageDefault, "default",
 111      "Select the lldb default as the default scripting language."} };
 112
 113 #define MODULE_WITH_FUNC                                                       \
 114   "{ "                                                                         \
 115   "${module.file.basename}{`${function.name-with-args}"                        \
 116   "{${frame.no-debug}${function.pc-offset}}}}"
 117
 118 #define MODULE_WITH_FUNC_NO_ARGS                                               \
 119   "{ "                                                                         \
 120   "${module.file.basename}{`${function.name-without-args}"                     \
 121   "{${frame.no-debug}${function.pc-offset}}}}"
 122
 123 #define FILE_AND_LINE                                                          \
 124   "{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}"                    \
 125   ":${ansi.fg.yellow}${line.number}${ansi.normal}"                             \
 126   "{:${ansi.fg.yellow}${line.column}${ansi.normal}}}"
 127
 128 #define IS_OPTIMIZED "{${function.is-optimized} [opt]}"
 129
 130 #define IS_ARTIFICIAL "{${frame.is-artificial} [artificial]}"
 131
 132 #define DEFAULT_THREAD_FORMAT                                                  \
 133   "thread #${thread.index}: tid = ${thread.id%tid}"                            \
 134   "{, ${frame.pc}}" MODULE_WITH_FUNC FILE_AND_LINE                             \
 135   "{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}"                  \
 136   "{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}"                \
 137   "{, activity = "                                                             \
 138   "${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}"              \
 139   "{, ${thread.info.trace_messages} messages}"                                 \
 140   "{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}"        \
 141   "{\\nReturn value: ${thread.return-value}}"                                  \
 142   "{\\nCompleted expression: ${thread.completed-expression}}"                  \
 143   "\\n"
 144
 145 #define DEFAULT_THREAD_STOP_FORMAT                                             \
 146   "thread #${thread.index}{, name = '${thread.name}'}"                         \
 147   "{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}"                \
 148   "{, activity = "                                                             \
 149   "${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}"              \
 150   "{, ${thread.info.trace_messages} messages}"                                 \
 151   "{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}"        \
 152   "{\\nReturn value: ${thread.return-value}}"                                  \
 153   "{\\nCompleted expression: ${thread.completed-expression}}"                  \
 154   "\\n"
 155
 156 #define DEFAULT_FRAME_FORMAT                                                   \
 157   "frame #${frame.index}: "                                                    \
 158   "${ansi.fg.yellow}${frame.pc}${ansi.normal}" MODULE_WITH_FUNC FILE_AND_LINE  \
 159       IS_OPTIMIZED IS_ARTIFICIAL "\\n"
 160
 161 #define DEFAULT_FRAME_FORMAT_NO_ARGS                                           \
 162   "frame #${frame.index}: "                                                    \
 163   "${ansi.fg.yellow}${frame.pc}${ansi.normal}" MODULE_WITH_FUNC_NO_ARGS        \
 164       FILE_AND_LINE IS_OPTIMIZED IS_ARTIFICIAL "\\n"
 165
 166 // Three parts to this disassembly format specification:
 167 //   1. If this is a new function/symbol (no previous symbol/function), print
 168 //      dylib`funcname:\n
 169 //   2. If this is a symbol context change (different from previous
 170 //   symbol/function), print
 171 //      dylib`funcname:\n
 172 //   3. print
 173 //      address <+offset>:
 174 #define DEFAULT_DISASSEMBLY_FORMAT                                             \
 175   "{${function.initial-function}{${module.file.basename}`}{${function.name-"   \
 176   "without-args}}:\\n}{${function.changed}\\n{${module.file.basename}`}{${"    \
 177   "function.name-without-args}}:\\n}{${current-pc-arrow} "                     \
 178   "}${addr-file-or-load}{ "                                                    \
 179   "<${function.concrete-only-addr-offset-no-padding}>}: "
 180
 181 // gdb's disassembly format can be emulated with ${current-pc-arrow}${addr-
 182 // file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-
 183 // offset-no-padding}>}:
 184
 185 // lldb's original format for disassembly would look like this format string -
 186 // {${function.initial-function}{${module.file.basename}`}{${function.name-
 187 // without-
 188 // args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-
 189 // without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
 190
 191 static constexpr OptionEnumValueElement s_stop_show_column_values[] = {
 192     {eStopShowColumnAnsiOrCaret, "ansi-or-caret",
 193      "Highlight the stop column with ANSI terminal codes when color/ANSI mode "
 194      "is enabled; otherwise, fall back to using a text-only caret (^) as if "
 195      "\"caret-only\" mode was selected."},
 196     {eStopShowColumnAnsi, "ansi", "Highlight the stop column with ANSI "
 197                                   "terminal codes when running LLDB with "
 198                                   "color/ANSI enabled."},
 199     {eStopShowColumnCaret, "caret",
 200      "Highlight the stop column with a caret character (^) underneath the stop "
 201      "column. This method introduces a new line in source listings that "
 202      "display thread stop locations."},
 203     {eStopShowColumnNone, "none", "Do not highlight the stop column."}};
 204
 205 static constexpr PropertyDefinition g_properties[] = {
 206     {"auto-confirm", OptionValue::eTypeBoolean, true, false, nullptr, {},
 207      "If true all confirmation prompts will receive their default reply."},
 208     {"disassembly-format", OptionValue::eTypeFormatEntity, true, 0,
 209      DEFAULT_DISASSEMBLY_FORMAT, {},
 210      "The default disassembly format "
 211      "string to use when disassembling "
 212      "instruction sequences."},
 213     {"frame-format", OptionValue::eTypeFormatEntity, true, 0,
 214      DEFAULT_FRAME_FORMAT, {},
 215      "The default frame format string to use "
 216      "when displaying stack frame information "
 217      "for threads."},
 218     {"notify-void", OptionValue::eTypeBoolean, true, false, nullptr, {},
 219      "Notify the user explicitly if an expression returns void (default: "
 220      "false)."},
 221     {"prompt", OptionValue::eTypeString, true,
 222      OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", {},
 223      "The debugger command line prompt displayed for the user."},
 224     {"script-lang", OptionValue::eTypeEnum, true, eScriptLanguagePython,
 225      nullptr, OptionEnumValues(g_language_enumerators),
 226      "The script language to be used for evaluating user-written scripts."},
 227     {"stop-disassembly-count", OptionValue::eTypeSInt64, true, 4, nullptr, {},
 228      "The number of disassembly lines to show when displaying a "
 229      "stopped context."},
 230     {"stop-disassembly-display", OptionValue::eTypeEnum, true,
 231      Debugger::eStopDisassemblyTypeNoDebugInfo, nullptr,
 232      OptionEnumValues(g_show_disassembly_enum_values),
 233      "Control when to display disassembly when displaying a stopped context."},
 234     {"stop-line-count-after", OptionValue::eTypeSInt64, true, 3, nullptr, {},
 235      "The number of sources lines to display that come after the "
 236      "current source line when displaying a stopped context."},
 237     {"stop-line-count-before", OptionValue::eTypeSInt64, true, 3, nullptr, {},
 238      "The number of sources lines to display that come before the "
 239      "current source line when displaying a stopped context."},
 240     {"highlight-source", OptionValue::eTypeBoolean, true, true, nullptr, {},
 241      "If true, LLDB will highlight the displayed source code."},
 242     {"stop-show-column", OptionValue::eTypeEnum, false,
 243      eStopShowColumnAnsiOrCaret, nullptr, OptionEnumValues(s_stop_show_column_values),
 244      "If true, LLDB will use the column information from the debug info to "
 245      "mark the current position when displaying a stopped context."},
 246     {"stop-show-column-ansi-prefix", OptionValue::eTypeString, true, 0,
 247      "${ansi.underline}", {},
 248      "When displaying the column marker in a color-enabled (i.e. ANSI) "
 249      "terminal, use the ANSI terminal code specified in this format at the "
 250      "immediately before the column to be marked."},
 251     {"stop-show-column-ansi-suffix", OptionValue::eTypeString, true, 0,
 252      "${ansi.normal}", {},
 253      "When displaying the column marker in a color-enabled (i.e. ANSI) "
 254      "terminal, use the ANSI terminal code specified in this format "
 255      "immediately after the column to be marked."},
 256     {"term-width", OptionValue::eTypeSInt64, true, 80, nullptr, {},
 257      "The maximum number of columns to use for displaying text."},
 258     {"thread-format", OptionValue::eTypeFormatEntity, true, 0,
 259      DEFAULT_THREAD_FORMAT, {},
 260      "The default thread format string to use "
 261      "when displaying thread information."},
 262     {"thread-stop-format", OptionValue::eTypeFormatEntity, true, 0,
 263      DEFAULT_THREAD_STOP_FORMAT, {},
 264      "The default thread format  "
 265      "string to use when displaying thread "
 266      "information as part of the stop display."},
 267     {"use-external-editor", OptionValue::eTypeBoolean, true, false, nullptr, {},
 268      "Whether to use an external editor or not."},
 269     {"use-color", OptionValue::eTypeBoolean, true, true, nullptr, {},
 270      "Whether to use Ansi color codes or not."},
 271     {"auto-one-line-summaries", OptionValue::eTypeBoolean, true, true, nullptr,
 272      {},
 273      "If true, LLDB will automatically display small structs in "
 274      "one-liner format (default: true)."},
 275     {"auto-indent", OptionValue::eTypeBoolean, true, true, nullptr, {},
 276      "If true, LLDB will auto indent/outdent code. Currently only supported in "
 277      "the REPL (default: true)."},
 278     {"print-decls", OptionValue::eTypeBoolean, true, true, nullptr, {},
 279      "If true, LLDB will print the values of variables declared in an "
 280      "expression. Currently only supported in the REPL (default: true)."},
 281     {"tab-size", OptionValue::eTypeUInt64, true, 4, nullptr, {},
 282      "The tab size to use when indenting code in multi-line input mode "
 283      "(default: 4)."},
 284     {"escape-non-printables", OptionValue::eTypeBoolean, true, true, nullptr,
 285      {},
 286      "If true, LLDB will automatically escape non-printable and "
 287      "escape characters when formatting strings."},
 288     {"frame-format-unique", OptionValue::eTypeFormatEntity, true, 0,
 289      DEFAULT_FRAME_FORMAT_NO_ARGS, {},
 290      "The default frame format string to use when displaying stack frame"
 291      "information for threads from thread backtrace unique."}};
 292
 293 enum {
 294   ePropertyAutoConfirm = 0,
 295   ePropertyDisassemblyFormat,
 296   ePropertyFrameFormat,
 297   ePropertyNotiftVoid,
 298   ePropertyPrompt,
 299   ePropertyScriptLanguage,
 300   ePropertyStopDisassemblyCount,
 301   ePropertyStopDisassemblyDisplay,
 302   ePropertyStopLineCountAfter,
 303   ePropertyStopLineCountBefore,
 304   ePropertyHighlightSource,
 305   ePropertyStopShowColumn,
 306   ePropertyStopShowColumnAnsiPrefix,
 307   ePropertyStopShowColumnAnsiSuffix,
 308   ePropertyTerminalWidth,
 309   ePropertyThreadFormat,
 310   ePropertyThreadStopFormat,
 311   ePropertyUseExternalEditor,
 312   ePropertyUseColor,
 313   ePropertyAutoOneLineSummaries,
 314   ePropertyAutoIndent,
 315   ePropertyPrintDecls,
 316   ePropertyTabSize,
 317   ePropertyEscapeNonPrintables,
 318   ePropertyFrameFormatUnique,
 319 };
 320
 321 LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;
 322
 323 Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
 324                                   VarSetOperationType op,
 325                                   llvm::StringRef property_path,
 326                                   llvm::StringRef value) {
 327   bool is_load_script = (property_path == "target.load-script-from-symbol-file");
 328   bool is_escape_non_printables = (property_path == "escape-non-printables");
 329   TargetSP target_sp;
 330   LoadScriptFromSymFile load_script_old_value;
 331   if (is_load_script && exe_ctx->GetTargetSP()) {
 332     target_sp = exe_ctx->GetTargetSP();
 333     load_script_old_value =
 334         target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
 335   }
 336   Status error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
 337   if (error.Success()) {
 338     // FIXME it would be nice to have "on-change" callbacks for properties
 339     if (property_path == g_properties[ePropertyPrompt].name) {
 340       llvm::StringRef new_prompt = GetPrompt();
 341       std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes(
 342           new_prompt, GetUseColor());
 343       if (str.length())
 344         new_prompt = str;
 345       GetCommandInterpreter().UpdatePrompt(new_prompt);
 346       auto bytes = llvm::make_unique<EventDataBytes>(new_prompt);
 347       auto prompt_change_event_sp = std::make_shared<Event>(
 348           CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
 349       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
 350     } else if (property_path == g_properties[ePropertyUseColor].name) {
 351       // use-color changed. Ping the prompt so it can reset the ansi terminal
 352       // codes.
 353       SetPrompt(GetPrompt());
 354     } else if (is_load_script && target_sp &&
 355                load_script_old_value == eLoadScriptFromSymFileWarn) {
 356       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
 357           eLoadScriptFromSymFileTrue) {
 358         std::list<Status> errors;
 359         StreamString feedback_stream;
 360         if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
 361           StreamFileSP stream_sp(GetErrorFile());
 362           if (stream_sp) {
 363             for (auto error : errors) {
 364               stream_sp->Printf("%s\n", error.AsCString());
 365             }
 366             if (feedback_stream.GetSize())
 367               stream_sp->PutCString(feedback_stream.GetString());
 368           }
 369         }
 370       }
 371     } else if (is_escape_non_printables) {
 372       DataVisualization::ForceUpdate();
 373     }
 374   }
 375   return error;
 376 }
 377
 378 bool Debugger::GetAutoConfirm() const {
 379   const uint32_t idx = ePropertyAutoConfirm;
 380   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 381       nullptr, idx, g_properties[idx].default_uint_value != 0);
 382 }
 383
 384 const FormatEntity::Entry *Debugger::GetDisassemblyFormat() const {
 385   const uint32_t idx = ePropertyDisassemblyFormat;
 386   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 387 }
 388
 389 const FormatEntity::Entry *Debugger::GetFrameFormat() const {
 390   const uint32_t idx = ePropertyFrameFormat;
 391   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 392 }
 393
 394 const FormatEntity::Entry *Debugger::GetFrameFormatUnique() const {
 395   const uint32_t idx = ePropertyFrameFormatUnique;
 396   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 397 }
 398
 399 bool Debugger::GetNotifyVoid() const {
 400   const uint32_t idx = ePropertyNotiftVoid;
 401   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 402       nullptr, idx, g_properties[idx].default_uint_value != 0);
 403 }
 404
 405 llvm::StringRef Debugger::GetPrompt() const {
 406   const uint32_t idx = ePropertyPrompt;
 407   return m_collection_sp->GetPropertyAtIndexAsString(
 408       nullptr, idx, g_properties[idx].default_cstr_value);
 409 }
 410
 411 void Debugger::SetPrompt(llvm::StringRef p) {
 412   const uint32_t idx = ePropertyPrompt;
 413   m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
 414   llvm::StringRef new_prompt = GetPrompt();
 415   std::string str =
 416       lldb_utility::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
 417   if (str.length())
 418     new_prompt = str;
 419   GetCommandInterpreter().UpdatePrompt(new_prompt);
 420 }
 421
 422 llvm::StringRef Debugger::GetReproducerPath() const {
 423   auto &r = repro::Reproducer::Instance();
 424   return r.GetReproducerPath().GetCString();
 425 }
 426
 427 const FormatEntity::Entry *Debugger::GetThreadFormat() const {
 428   const uint32_t idx = ePropertyThreadFormat;
 429   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 430 }
 431
 432 const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {
 433   const uint32_t idx = ePropertyThreadStopFormat;
 434   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 435 }
 436
 437 lldb::ScriptLanguage Debugger::GetScriptLanguage() const {
 438   const uint32_t idx = ePropertyScriptLanguage;
 439   return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(
 440       nullptr, idx, g_properties[idx].default_uint_value);
 441 }
 442
 443 bool Debugger::SetScriptLanguage(lldb::ScriptLanguage script_lang) {
 444   const uint32_t idx = ePropertyScriptLanguage;
 445   return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx,
 446                                                           script_lang);
 447 }
 448
 449 uint32_t Debugger::GetTerminalWidth() const {
 450   const uint32_t idx = ePropertyTerminalWidth;
 451   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 452       nullptr, idx, g_properties[idx].default_uint_value);
 453 }
 454
 455 bool Debugger::SetTerminalWidth(uint32_t term_width) {
 456   const uint32_t idx = ePropertyTerminalWidth;
 457   return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width);
 458 }
 459
 460 bool Debugger::GetUseExternalEditor() const {
 461   const uint32_t idx = ePropertyUseExternalEditor;
 462   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 463       nullptr, idx, g_properties[idx].default_uint_value != 0);
 464 }
 465
 466 bool Debugger::SetUseExternalEditor(bool b) {
 467   const uint32_t idx = ePropertyUseExternalEditor;
 468   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 469 }
 470
 471 bool Debugger::GetUseColor() const {
 472   const uint32_t idx = ePropertyUseColor;
 473   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 474       nullptr, idx, g_properties[idx].default_uint_value != 0);
 475 }
 476
 477 bool Debugger::SetUseColor(bool b) {
 478   const uint32_t idx = ePropertyUseColor;
 479   bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 480   SetPrompt(GetPrompt());
 481   return ret;
 482 }
 483
 484 bool Debugger::GetHighlightSource() const {
 485   const uint32_t idx = ePropertyHighlightSource;
 486   return m_collection_sp->GetPropertyAtIndexAsBoolean(
 487       nullptr, idx, g_properties[idx].default_uint_value);
 488 }
 489
 490 StopShowColumn Debugger::GetStopShowColumn() const {
 491   const uint32_t idx = ePropertyStopShowColumn;
 492   return (lldb::StopShowColumn)m_collection_sp->GetPropertyAtIndexAsEnumeration(
 493       nullptr, idx, g_properties[idx].default_uint_value);
 494 }
 495
 496 llvm::StringRef Debugger::GetStopShowColumnAnsiPrefix() const {
 497   const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
 498   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
 499 }
 500
 501 llvm::StringRef Debugger::GetStopShowColumnAnsiSuffix() const {
 502   const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
 503   return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
 504 }
 505
 506 uint32_t Debugger::GetStopSourceLineCount(bool before) const {
 507   const uint32_t idx =
 508       before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
 509   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 510       nullptr, idx, g_properties[idx].default_uint_value);
 511 }
 512
 513 Debugger::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {
 514   const uint32_t idx = ePropertyStopDisassemblyDisplay;
 515   return (Debugger::StopDisassemblyType)
 516       m_collection_sp->GetPropertyAtIndexAsEnumeration(
 517           nullptr, idx, g_properties[idx].default_uint_value);
 518 }
 519
 520 uint32_t Debugger::GetDisassemblyLineCount() const {
 521   const uint32_t idx = ePropertyStopDisassemblyCount;
 522   return m_collection_sp->GetPropertyAtIndexAsSInt64(
 523       nullptr, idx, g_properties[idx].default_uint_value);
 524 }
 525
 526 bool Debugger::GetAutoOneLineSummaries() const {
 527   const uint32_t idx = ePropertyAutoOneLineSummaries;
 528   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 529 }
 530
 531 bool Debugger::GetEscapeNonPrintables() const {
 532   const uint32_t idx = ePropertyEscapeNonPrintables;
 533   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 534 }
 535
 536 bool Debugger::GetAutoIndent() const {
 537   const uint32_t idx = ePropertyAutoIndent;
 538   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 539 }
 540
 541 bool Debugger::SetAutoIndent(bool b) {
 542   const uint32_t idx = ePropertyAutoIndent;
 543   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 544 }
 545
 546 bool Debugger::GetPrintDecls() const {
 547   const uint32_t idx = ePropertyPrintDecls;
 548   return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
 549 }
 550
 551 bool Debugger::SetPrintDecls(bool b) {
 552   const uint32_t idx = ePropertyPrintDecls;
 553   return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 554 }
 555
 556 uint32_t Debugger::GetTabSize() const {
 557   const uint32_t idx = ePropertyTabSize;
 558   return m_collection_sp->GetPropertyAtIndexAsUInt64(
 559       nullptr, idx, g_properties[idx].default_uint_value);
 560 }
 561
 562 bool Debugger::SetTabSize(uint32_t tab_size) {
 563   const uint32_t idx = ePropertyTabSize;
 564   return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
 565 }
 566
 567 #pragma mark Debugger
 568
 569 // const DebuggerPropertiesSP &
 570 // Debugger::GetSettings() const
 571 //{
 572 //    return m_properties_sp;
 573 //}
 574 //
 575
 576 void Debugger::Initialize(LoadPluginCallbackType load_plugin_callback) {
 577   assert(g_debugger_list_ptr == nullptr &&
 578          "Debugger::Initialize called more than once!");
 579   g_debugger_list_mutex_ptr = new std::recursive_mutex();
 580   g_debugger_list_ptr = new DebuggerList();
 581   g_load_plugin_callback = load_plugin_callback;
 582 }
 583
 584 void Debugger::Terminate() {
 585   assert(g_debugger_list_ptr &&
 586          "Debugger::Terminate called without a matching Debugger::Initialize!");
 587
 588   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 589     // Clear our master list of debugger objects
 590     {
 591       std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 592       for (const auto &debugger : *g_debugger_list_ptr)
 593         debugger->Clear();
 594       g_debugger_list_ptr->clear();
 595     }
 596   }
 597 }
 598
 599 void Debugger::SettingsInitialize() { Target::SettingsInitialize(); }
 600
 601 void Debugger::SettingsTerminate() { Target::SettingsTerminate(); }
 602
 603 bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
 604   if (g_load_plugin_callback) {
 605     llvm::sys::DynamicLibrary dynlib =
 606         g_load_plugin_callback(shared_from_this(), spec, error);
 607     if (dynlib.isValid()) {
 608       m_loaded_plugins.push_back(dynlib);
 609       return true;
 610     }
 611   } else {
 612     // The g_load_plugin_callback is registered in SBDebugger::Initialize() and
 613     // if the public API layer isn't available (code is linking against all of
 614     // the internal LLDB static libraries), then we can't load plugins
 615     error.SetErrorString("Public API layer is not available");
 616   }
 617   return false;
 618 }
 619
 620 static FileSystem::EnumerateDirectoryResult
 621 LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
 622                    llvm::StringRef path) {
 623   Status error;
 624
 625   static ConstString g_dylibext(".dylib");
 626   static ConstString g_solibext(".so");
 627
 628   if (!baton)
 629     return FileSystem::eEnumerateDirectoryResultQuit;
 630
 631   Debugger *debugger = (Debugger *)baton;
 632
 633   namespace fs = llvm::sys::fs;
 634   // If we have a regular file, a symbolic link or unknown file type, try and
 635   // process the file. We must handle unknown as sometimes the directory
 636   // enumeration might be enumerating a file system that doesn't have correct
 637   // file type information.
 638   if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
 639       ft == fs::file_type::type_unknown) {
 640     FileSpec plugin_file_spec(path);
 641     FileSystem::Instance().Resolve(plugin_file_spec);
 642
 643     if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
 644         plugin_file_spec.GetFileNameExtension() != g_solibext) {
 645       return FileSystem::eEnumerateDirectoryResultNext;
 646     }
 647
 648     Status plugin_load_error;
 649     debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
 650
 651     return FileSystem::eEnumerateDirectoryResultNext;
 652   } else if (ft == fs::file_type::directory_file ||
 653              ft == fs::file_type::symlink_file ||
 654              ft == fs::file_type::type_unknown) {
 655     // Try and recurse into anything that a directory or symbolic link. We must
 656     // also do this for unknown as sometimes the directory enumeration might be
 657     // enumerating a file system that doesn't have correct file type
 658     // information.
 659     return FileSystem::eEnumerateDirectoryResultEnter;
 660   }
 661
 662   return FileSystem::eEnumerateDirectoryResultNext;
 663 }
 664
 665 void Debugger::InstanceInitialize() {
 666   const bool find_directories = true;
 667   const bool find_files = true;
 668   const bool find_other = true;
 669   char dir_path[PATH_MAX];
 670   if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
 671     if (FileSystem::Instance().Exists(dir_spec) &&
 672         dir_spec.GetPath(dir_path, sizeof(dir_path))) {
 673       FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
 674                                                 find_files, find_other,
 675                                                 LoadPluginCallback, this);
 676     }
 677   }
 678
 679   if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
 680     if (FileSystem::Instance().Exists(dir_spec) &&
 681         dir_spec.GetPath(dir_path, sizeof(dir_path))) {
 682       FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
 683                                                 find_files, find_other,
 684                                                 LoadPluginCallback, this);
 685     }
 686   }
 687
 688   PluginManager::DebuggerInitialize(*this);
 689 }
 690
 691 DebuggerSP Debugger::CreateInstance(lldb::LogOutputCallback log_callback,
 692                                     void *baton) {
 693   DebuggerSP debugger_sp(new Debugger(log_callback, baton));
 694   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 695     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 696     g_debugger_list_ptr->push_back(debugger_sp);
 697   }
 698   debugger_sp->InstanceInitialize();
 699   return debugger_sp;
 700 }
 701
 702 void Debugger::Destroy(DebuggerSP &debugger_sp) {
 703   if (!debugger_sp)
 704     return;
 705
 706   debugger_sp->Clear();
 707
 708   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 709     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 710     DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
 711     for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
 712       if ((*pos).get() == debugger_sp.get()) {
 713         g_debugger_list_ptr->erase(pos);
 714         return;
 715       }
 716     }
 717   }
 718 }
 719
 720 DebuggerSP
 721 Debugger::FindDebuggerWithInstanceName(ConstString instance_name) {
 722   DebuggerSP debugger_sp;
 723   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 724     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 725     DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
 726     for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
 727       if ((*pos)->m_instance_name == instance_name) {
 728         debugger_sp = *pos;
 729         break;
 730       }
 731     }
 732   }
 733   return debugger_sp;
 734 }
 735
 736 TargetSP Debugger::FindTargetWithProcessID(lldb::pid_t pid) {
 737   TargetSP target_sp;
 738   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 739     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 740     DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
 741     for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
 742       target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
 743       if (target_sp)
 744         break;
 745     }
 746   }
 747   return target_sp;
 748 }
 749
 750 TargetSP Debugger::FindTargetWithProcess(Process *process) {
 751   TargetSP target_sp;
 752   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
 753     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
 754     DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
 755     for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
 756       target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
 757       if (target_sp)
 758         break;
 759     }
 760   }
 761   return target_sp;
 762 }
 763
 764 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
 765     : UserID(g_unique_id++),
 766       Properties(std::make_shared<OptionValueProperties>()),
 767       m_input_file_sp(std::make_shared<StreamFile>(stdin, false)),
 768       m_output_file_sp(std::make_shared<StreamFile>(stdout, false)),
 769       m_error_file_sp(std::make_shared<StreamFile>(stderr, false)),
 770       m_input_recorder(nullptr),
 771       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
 772       m_terminal_state(), m_target_list(*this), m_platform_list(),
 773       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
 774       m_source_manager_up(), m_source_file_cache(),
 775       m_command_interpreter_up(
 776           llvm::make_unique<CommandInterpreter>(*this, false)),
 777       m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(),
 778       m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
 779       m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
 780       m_forward_listener_sp(), m_clear_once() {
 781   char instance_cstr[256];
 782   snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
 783   m_instance_name.SetCString(instance_cstr);
 784   if (log_callback)
 785     m_log_callback_stream_sp =
 786         std::make_shared<StreamCallback>(log_callback, baton);
 787   m_command_interpreter_up->Initialize();
 788   // Always add our default platform to the platform list
 789   PlatformSP default_platform_sp(Platform::GetHostPlatform());
 790   assert(default_platform_sp);
 791   m_platform_list.Append(default_platform_sp, true);
 792
 793   m_collection_sp->Initialize(g_properties);
 794   m_collection_sp->AppendProperty(
 795       ConstString("target"),
 796       ConstString("Settings specify to debugging targets."), true,
 797       Target::GetGlobalProperties()->GetValueProperties());
 798   m_collection_sp->AppendProperty(
 799       ConstString("platform"), ConstString("Platform settings."), true,
 800       Platform::GetGlobalPlatformProperties()->GetValueProperties());
 801   m_collection_sp->AppendProperty(
 802       ConstString("symbols"), ConstString("Symbol lookup and cache settings."),
 803       true, ModuleList::GetGlobalModuleListProperties().GetValueProperties());
 804   if (m_command_interpreter_up) {
 805     m_collection_sp->AppendProperty(
 806         ConstString("interpreter"),
 807         ConstString("Settings specify to the debugger's command interpreter."),
 808         true, m_command_interpreter_up->GetValueProperties());
 809   }
 810   OptionValueSInt64 *term_width =
 811       m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(
 812           nullptr, ePropertyTerminalWidth);
 813   term_width->SetMinimumValue(10);
 814   term_width->SetMaximumValue(1024);
 815
 816   // Turn off use-color if this is a dumb terminal.
 817   const char *term = getenv("TERM");
 818   if (term && !strcmp(term, "dumb"))
 819     SetUseColor(false);
 820   // Turn off use-color if we don't write to a terminal with color support.
 821   if (!m_output_file_sp->GetFile().GetIsTerminalWithColors())
 822     SetUseColor(false);
 823
 824 #if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
 825   // Enabling use of ANSI color codes because LLDB is using them to highlight
 826   // text.
 827   llvm::sys::Process::UseANSIEscapeCodes(true);
 828 #endif
 829 }
 830
 831 Debugger::~Debugger() { Clear(); }
 832
 833 void Debugger::Clear() {
 834   // Make sure we call this function only once. With the C++ global destructor
 835   // chain having a list of debuggers and with code that can be running on
 836   // other threads, we need to ensure this doesn't happen multiple times.
 837   //
 838   // The following functions call Debugger::Clear():
 839   //     Debugger::~Debugger();
 840   //     static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
 841   //     static void Debugger::Terminate();
 842   llvm::call_once(m_clear_once, [this]() {
 843     ClearIOHandlers();
 844     StopIOHandlerThread();
 845     StopEventHandlerThread();
 846     m_listener_sp->Clear();
 847     int num_targets = m_target_list.GetNumTargets();
 848     for (int i = 0; i < num_targets; i++) {
 849       TargetSP target_sp(m_target_list.GetTargetAtIndex(i));
 850       if (target_sp) {
 851         ProcessSP process_sp(target_sp->GetProcessSP());
 852         if (process_sp)
 853           process_sp->Finalize();
 854         target_sp->Destroy();
 855       }
 856     }
 857     m_broadcaster_manager_sp->Clear();
 858
 859     // Close the input file _before_ we close the input read communications
 860     // class as it does NOT own the input file, our m_input_file does.
 861     m_terminal_state.Clear();
 862     if (m_input_file_sp)
 863       m_input_file_sp->GetFile().Close();
 864
 865     m_command_interpreter_up->Clear();
 866   });
 867 }
 868
 869 bool Debugger::GetCloseInputOnEOF() const {
 870   //    return m_input_comm.GetCloseOnEOF();
 871   return false;
 872 }
 873
 874 void Debugger::SetCloseInputOnEOF(bool b) {
 875   //    m_input_comm.SetCloseOnEOF(b);
 876 }
 877
 878 bool Debugger::GetAsyncExecution() {
 879   return !m_command_interpreter_up->GetSynchronous();
 880 }
 881
 882 void Debugger::SetAsyncExecution(bool async_execution) {
 883   m_command_interpreter_up->SetSynchronous(!async_execution);
 884 }
 885
 886 repro::DataRecorder *Debugger::GetInputRecorder() { return m_input_recorder; }
 887
 888 void Debugger::SetInputFileHandle(FILE *fh, bool tranfer_ownership,
 889                                   repro::DataRecorder *recorder) {
 890   m_input_recorder = recorder;
 891   if (m_input_file_sp)
 892     m_input_file_sp->GetFile().SetStream(fh, tranfer_ownership);
 893   else
 894     m_input_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 895
 896   File &in_file = m_input_file_sp->GetFile();
 897   if (!in_file.IsValid())
 898     in_file.SetStream(stdin, true);
 899
 900   // Save away the terminal state if that is relevant, so that we can restore
 901   // it in RestoreInputState.
 902   SaveInputTerminalState();
 903 }
 904
 905 void Debugger::SetOutputFileHandle(FILE *fh, bool tranfer_ownership) {
 906   if (m_output_file_sp)
 907     m_output_file_sp->GetFile().SetStream(fh, tranfer_ownership);
 908   else
 909     m_output_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 910
 911   File &out_file = m_output_file_sp->GetFile();
 912   if (!out_file.IsValid())
 913     out_file.SetStream(stdout, false);
 914
 915   // Do not create the ScriptInterpreter just for setting the output file
 916   // handle as the constructor will know how to do the right thing on its own.
 917   if (ScriptInterpreter *script_interpreter =
 918           GetScriptInterpreter(/*can_create=*/false))
 919     script_interpreter->ResetOutputFileHandle(fh);
 920 }
 921
 922 void Debugger::SetErrorFileHandle(FILE *fh, bool tranfer_ownership) {
 923   if (m_error_file_sp)
 924     m_error_file_sp->GetFile().SetStream(fh, tranfer_ownership);
 925   else
 926     m_error_file_sp = std::make_shared<StreamFile>(fh, tranfer_ownership);
 927
 928   File &err_file = m_error_file_sp->GetFile();
 929   if (!err_file.IsValid())
 930     err_file.SetStream(stderr, false);
 931 }
 932
 933 void Debugger::SaveInputTerminalState() {
 934   if (m_input_file_sp) {
 935     File &in_file = m_input_file_sp->GetFile();
 936     if (in_file.GetDescriptor() != File::kInvalidDescriptor)
 937       m_terminal_state.Save(in_file.GetDescriptor(), true);
 938   }
 939 }
 940
 941 void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); }
 942
 943 ExecutionContext Debugger::GetSelectedExecutionContext() {
 944   ExecutionContext exe_ctx;
 945   TargetSP target_sp(GetSelectedTarget());
 946   exe_ctx.SetTargetSP(target_sp);
 947
 948   if (target_sp) {
 949     ProcessSP process_sp(target_sp->GetProcessSP());
 950     exe_ctx.SetProcessSP(process_sp);
 951     if (process_sp && !process_sp->IsRunning()) {
 952       ThreadSP thread_sp(process_sp->GetThreadList().GetSelectedThread());
 953       if (thread_sp) {
 954         exe_ctx.SetThreadSP(thread_sp);
 955         exe_ctx.SetFrameSP(thread_sp->GetSelectedFrame());
 956         if (exe_ctx.GetFramePtr() == nullptr)
 957           exe_ctx.SetFrameSP(thread_sp->GetStackFrameAtIndex(0));
 958       }
 959     }
 960   }
 961   return exe_ctx;
 962 }
 963
 964 void Debugger::DispatchInputInterrupt() {
 965   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 966   IOHandlerSP reader_sp(m_input_reader_stack.Top());
 967   if (reader_sp)
 968     reader_sp->Interrupt();
 969 }
 970
 971 void Debugger::DispatchInputEndOfFile() {
 972   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 973   IOHandlerSP reader_sp(m_input_reader_stack.Top());
 974   if (reader_sp)
 975     reader_sp->GotEOF();
 976 }
 977
 978 void Debugger::ClearIOHandlers() {
 979   // The bottom input reader should be the main debugger input reader.  We do
 980   // not want to close that one here.
 981   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 982   while (m_input_reader_stack.GetSize() > 1) {
 983     IOHandlerSP reader_sp(m_input_reader_stack.Top());
 984     if (reader_sp)
 985       PopIOHandler(reader_sp);
 986   }
 987 }
 988
 989 void Debugger::ExecuteIOHandlers() {
 990   while (true) {
 991     IOHandlerSP reader_sp(m_input_reader_stack.Top());
 992     if (!reader_sp)
 993       break;
 994
 995     reader_sp->Run();
 996
 997     // Remove all input readers that are done from the top of the stack
 998     while (true) {
 999       IOHandlerSP top_reader_sp = m_input_reader_stack.Top();
1000       if (top_reader_sp && top_reader_sp->GetIsDone())
1001         PopIOHandler(top_reader_sp);
1002       else
1003         break;
1004     }
1005   }
1006   ClearIOHandlers();
1007 }
1008
1009 bool Debugger::IsTopIOHandler(const lldb::IOHandlerSP &reader_sp) {
1010   return m_input_reader_stack.IsTop(reader_sp);
1011 }
1012
1013 bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
1014                                       IOHandler::Type second_top_type) {
1015   return m_input_reader_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
1016 }
1017
1018 void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
1019   lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
1020   m_input_reader_stack.PrintAsync(stream.get(), s, len);
1021 }
1022
1023 ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
1024   return m_input_reader_stack.GetTopIOHandlerControlSequence(ch);
1025 }
1026
1027 const char *Debugger::GetIOHandlerCommandPrefix() {
1028   return m_input_reader_stack.GetTopIOHandlerCommandPrefix();
1029 }
1030
1031 const char *Debugger::GetIOHandlerHelpPrologue() {
1032   return m_input_reader_stack.GetTopIOHandlerHelpPrologue();
1033 }
1034
1035 void Debugger::RunIOHandler(const IOHandlerSP &reader_sp) {
1036   PushIOHandler(reader_sp);
1037
1038   IOHandlerSP top_reader_sp = reader_sp;
1039   while (top_reader_sp) {
1040     top_reader_sp->Run();
1041
1042     if (top_reader_sp.get() == reader_sp.get()) {
1043       if (PopIOHandler(reader_sp))
1044         break;
1045     }
1046
1047     while (true) {
1048       top_reader_sp = m_input_reader_stack.Top();
1049       if (top_reader_sp && top_reader_sp->GetIsDone())
1050         PopIOHandler(top_reader_sp);
1051       else
1052         break;
1053     }
1054   }
1055 }
1056
1057 void Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in,
1058                                                StreamFileSP &out,
1059                                                StreamFileSP &err) {
1060   // Before an IOHandler runs, it must have in/out/err streams. This function
1061   // is called when one ore more of the streams are nullptr. We use the top
1062   // input reader's in/out/err streams, or fall back to the debugger file
1063   // handles, or we fall back onto stdin/stdout/stderr as a last resort.
1064
1065   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
1066   IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
1067   // If no STDIN has been set, then set it appropriately
1068   if (!in) {
1069     if (top_reader_sp)
1070       in = top_reader_sp->GetInputStreamFile();
1071     else
1072       in = GetInputFile();
1073
1074     // If there is nothing, use stdin
1075     if (!in)
1076       in = std::make_shared<StreamFile>(stdin, false);
1077   }
1078   // If no STDOUT has been set, then set it appropriately
1079   if (!out) {
1080     if (top_reader_sp)
1081       out = top_reader_sp->GetOutputStreamFile();
1082     else
1083       out = GetOutputFile();
1084
1085     // If there is nothing, use stdout
1086     if (!out)
1087       out = std::make_shared<StreamFile>(stdout, false);
1088   }
1089   // If no STDERR has been set, then set it appropriately
1090   if (!err) {
1091     if (top_reader_sp)
1092       err = top_reader_sp->GetErrorStreamFile();
1093     else
1094       err = GetErrorFile();
1095
1096     // If there is nothing, use stderr
1097     if (!err)
1098       err = std::make_shared<StreamFile>(stdout, false);
1099   }
1100 }
1101
1102 void Debugger::PushIOHandler(const IOHandlerSP &reader_sp,
1103                              bool cancel_top_handler) {
1104   if (!reader_sp)
1105     return;
1106
1107   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
1108
1109   // Get the current top input reader...
1110   IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
1111
1112   // Don't push the same IO handler twice...
1113   if (reader_sp == top_reader_sp)
1114     return;
1115
1116   // Push our new input reader
1117   m_input_reader_stack.Push(reader_sp);
1118   reader_sp->Activate();
1119
1120   // Interrupt the top input reader to it will exit its Run() function and let
1121   // this new input reader take over
1122   if (top_reader_sp) {
1123     top_reader_sp->Deactivate();
1124     if (cancel_top_handler)
1125       top_reader_sp->Cancel();
1126   }
1127 }
1128
1129 bool Debugger::PopIOHandler(const IOHandlerSP &pop_reader_sp) {
1130   if (!pop_reader_sp)
1131     return false;
1132
1133   std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
1134
1135   // The reader on the stop of the stack is done, so let the next read on the
1136   // stack refresh its prompt and if there is one...
1137   if (m_input_reader_stack.IsEmpty())
1138     return false;
1139
1140   IOHandlerSP reader_sp(m_input_reader_stack.Top());
1141
1142   if (pop_reader_sp != reader_sp)
1143     return false;
1144
1145   reader_sp->Deactivate();
1146   reader_sp->Cancel();
1147   m_input_reader_stack.Pop();
1148
1149   reader_sp = m_input_reader_stack.Top();
1150   if (reader_sp)
1151     reader_sp->Activate();
1152
1153   return true;
1154 }
1155
1156 StreamSP Debugger::GetAsyncOutputStream() {
1157   return std::make_shared<StreamAsynchronousIO>(*this, true);
1158 }
1159
1160 StreamSP Debugger::GetAsyncErrorStream() {
1161   return std::make_shared<StreamAsynchronousIO>(*this, false);
1162 }
1163
1164 size_t Debugger::GetNumDebuggers() {
1165   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
1166     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
1167     return g_debugger_list_ptr->size();
1168   }
1169   return 0;
1170 }
1171
1172 lldb::DebuggerSP Debugger::GetDebuggerAtIndex(size_t index) {
1173   DebuggerSP debugger_sp;
1174
1175   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
1176     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
1177     if (index < g_debugger_list_ptr->size())
1178       debugger_sp = g_debugger_list_ptr->at(index);
1179   }
1180
1181   return debugger_sp;
1182 }
1183
1184 DebuggerSP Debugger::FindDebuggerWithID(lldb::user_id_t id) {
1185   DebuggerSP debugger_sp;
1186
1187   if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
1188     std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
1189     DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
1190     for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
1191       if ((*pos)->GetID() == id) {
1192         debugger_sp = *pos;
1193         break;
1194       }
1195     }
1196   }
1197   return debugger_sp;
1198 }
1199
1200 bool Debugger::FormatDisassemblerAddress(const FormatEntity::Entry *format,
1201                                          const SymbolContext *sc,
1202                                          const SymbolContext *prev_sc,
1203                                          const ExecutionContext *exe_ctx,
1204                                          const Address *addr, Stream &s) {
1205   FormatEntity::Entry format_entry;
1206
1207   if (format == nullptr) {
1208     if (exe_ctx != nullptr && exe_ctx->HasTargetScope())
1209       format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
1210     if (format == nullptr) {
1211       FormatEntity::Parse("${addr}: ", format_entry);
1212       format = &format_entry;
1213     }
1214   }
1215   bool function_changed = false;
1216   bool initial_function = false;
1217   if (prev_sc && (prev_sc->function || prev_sc->symbol)) {
1218     if (sc && (sc->function || sc->symbol)) {
1219       if (prev_sc->symbol && sc->symbol) {
1220         if (!sc->symbol->Compare(prev_sc->symbol->GetName(),
1221                                  prev_sc->symbol->GetType())) {
1222           function_changed = true;
1223         }
1224       } else if (prev_sc->function && sc->function) {
1225         if (prev_sc->function->GetMangled() != sc->function->GetMangled()) {
1226           function_changed = true;
1227         }
1228       }
1229     }
1230   }
1231   // The first context on a list of instructions will have a prev_sc that has
1232   // no Function or Symbol -- if SymbolContext had an IsValid() method, it
1233   // would return false.  But we do get a prev_sc pointer.
1234   if ((sc && (sc->function || sc->symbol)) && prev_sc &&
1235       (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) {
1236     initial_function = true;
1237   }
1238   return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr,
1239                               function_changed, initial_function);
1240 }
1241
1242 void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1243                                   void *baton) {
1244   // For simplicity's sake, I am not going to deal with how to close down any
1245   // open logging streams, I just redirect everything from here on out to the
1246   // callback.
1247   m_log_callback_stream_sp =
1248       std::make_shared<StreamCallback>(log_callback, baton);
1249 }
1250
1251 bool Debugger::EnableLog(llvm::StringRef channel,
1252                          llvm::ArrayRef<const char *> categories,
1253                          llvm::StringRef log_file, uint32_t log_options,
1254                          llvm::raw_ostream &error_stream) {
1255   const bool should_close = true;
1256   const bool unbuffered = true;
1257
1258   std::shared_ptr<llvm::raw_ostream> log_stream_sp;
1259   if (m_log_callback_stream_sp) {
1260     log_stream_sp = m_log_callback_stream_sp;
1261     // For now when using the callback mode you always get thread & timestamp.
1262     log_options |=
1263         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1264   } else if (log_file.empty()) {
1265     log_stream_sp = std::make_shared<llvm::raw_fd_ostream>(
1266         GetOutputFile()->GetFile().GetDescriptor(), !should_close, unbuffered);
1267   } else {
1268     auto pos = m_log_streams.find(log_file);
1269     if (pos != m_log_streams.end())
1270       log_stream_sp = pos->second.lock();
1271     if (!log_stream_sp) {
1272       llvm::sys::fs::OpenFlags flags = llvm::sys::fs::F_Text;
1273       if (log_options & LLDB_LOG_OPTION_APPEND)
1274         flags |= llvm::sys::fs::F_Append;
1275       int FD;
1276       if (std::error_code ec = llvm::sys::fs::openFileForWrite(
1277               log_file, FD, llvm::sys::fs::CD_CreateAlways, flags)) {
1278         error_stream << "Unable to open log file: " << ec.message();
1279         return false;
1280       }
1281       log_stream_sp =
1282           std::make_shared<llvm::raw_fd_ostream>(FD, should_close, unbuffered);
1283       m_log_streams[log_file] = log_stream_sp;
1284     }
1285   }
1286   assert(log_stream_sp);
1287
1288   if (log_options == 0)
1289     log_options =
1290         LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
1291
1292   return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories,
1293                                error_stream);
1294 }
1295
1296 ScriptInterpreter *Debugger::GetScriptInterpreter(bool can_create) {
1297   std::lock_guard<std::recursive_mutex> locker(m_script_interpreter_mutex);
1298
1299   if (!m_script_interpreter_sp) {
1300     if (!can_create)
1301       return nullptr;
1302     m_script_interpreter_sp = PluginManager::GetScriptInterpreterForLanguage(
1303         GetScriptLanguage(), *this);
1304   }
1305
1306   return m_script_interpreter_sp.get();
1307 }
1308
1309 SourceManager &Debugger::GetSourceManager() {
1310   if (!m_source_manager_up)
1311     m_source_manager_up = llvm::make_unique<SourceManager>(shared_from_this());
1312   return *m_source_manager_up;
1313 }
1314
1315 // This function handles events that were broadcast by the process.
1316 void Debugger::HandleBreakpointEvent(const EventSP &event_sp) {
1317   using namespace lldb;
1318   const uint32_t event_type =
1319       Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
1320           event_sp);
1321
1322   //    if (event_type & eBreakpointEventTypeAdded
1323   //        || event_type & eBreakpointEventTypeRemoved
1324   //        || event_type & eBreakpointEventTypeEnabled
1325   //        || event_type & eBreakpointEventTypeDisabled
1326   //        || event_type & eBreakpointEventTypeCommandChanged
1327   //        || event_type & eBreakpointEventTypeConditionChanged
1328   //        || event_type & eBreakpointEventTypeIgnoreChanged
1329   //        || event_type & eBreakpointEventTypeLocationsResolved)
1330   //    {
1331   //        // Don't do anything about these events, since the breakpoint
1332   //        commands already echo these actions.
1333   //    }
1334   //
1335   if (event_type & eBreakpointEventTypeLocationsAdded) {
1336     uint32_t num_new_locations =
1337         Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
1338             event_sp);
1339     if (num_new_locations > 0) {
1340       BreakpointSP breakpoint =
1341           Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp);
1342       StreamSP output_sp(GetAsyncOutputStream());
1343       if (output_sp) {
1344         output_sp->Printf("%d location%s added to breakpoint %d\n",
1345                           num_new_locations, num_new_locations == 1 ? "" : "s",
1346                           breakpoint->GetID());
1347         output_sp->Flush();
1348       }
1349     }
1350   }
1351   //    else if (event_type & eBreakpointEventTypeLocationsRemoved)
1352   //    {
1353   //        // These locations just get disabled, not sure it is worth spamming
1354   //        folks about this on the command line.
1355   //    }
1356   //    else if (event_type & eBreakpointEventTypeLocationsResolved)
1357   //    {
1358   //        // This might be an interesting thing to note, but I'm going to
1359   //        leave it quiet for now, it just looked noisy.
1360   //    }
1361 }
1362
1363 size_t Debugger::GetProcessSTDOUT(Process *process, Stream *stream) {
1364   size_t total_bytes = 0;
1365   if (stream == nullptr)
1366     stream = GetOutputFile().get();
1367
1368   if (stream) {
1369     //  The process has stuff waiting for stdout; get it and write it out to the
1370     //  appropriate place.
1371     if (process == nullptr) {
1372       TargetSP target_sp = GetTargetList().GetSelectedTarget();
1373       if (target_sp)
1374         process = target_sp->GetProcessSP().get();
1375     }
1376     if (process) {
1377       Status error;
1378       size_t len;
1379       char stdio_buffer[1024];
1380       while ((len = process->GetSTDOUT(stdio_buffer, sizeof(stdio_buffer),
1381                                        error)) > 0) {
1382         stream->Write(stdio_buffer, len);
1383         total_bytes += len;
1384       }
1385     }
1386     stream->Flush();
1387   }
1388   return total_bytes;
1389 }
1390
1391 size_t Debugger::GetProcessSTDERR(Process *process, Stream *stream) {
1392   size_t total_bytes = 0;
1393   if (stream == nullptr)
1394     stream = GetOutputFile().get();
1395
1396   if (stream) {
1397     //  The process has stuff waiting for stderr; get it and write it out to the
1398     //  appropriate place.
1399     if (process == nullptr) {
1400       TargetSP target_sp = GetTargetList().GetSelectedTarget();
1401       if (target_sp)
1402         process = target_sp->GetProcessSP().get();
1403     }
1404     if (process) {
1405       Status error;
1406       size_t len;
1407       char stdio_buffer[1024];
1408       while ((len = process->GetSTDERR(stdio_buffer, sizeof(stdio_buffer),
1409                                        error)) > 0) {
1410         stream->Write(stdio_buffer, len);
1411         total_bytes += len;
1412       }
1413     }
1414     stream->Flush();
1415   }
1416   return total_bytes;
1417 }
1418
1419 // This function handles events that were broadcast by the process.
1420 void Debugger::HandleProcessEvent(const EventSP &event_sp) {
1421   using namespace lldb;
1422   const uint32_t event_type = event_sp->GetType();
1423   ProcessSP process_sp =
1424       (event_type == Process::eBroadcastBitStructuredData)
1425           ? EventDataStructuredData::GetProcessFromEvent(event_sp.get())
1426           : Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
1427
1428   StreamSP output_stream_sp = GetAsyncOutputStream();
1429   StreamSP error_stream_sp = GetAsyncErrorStream();
1430   const bool gui_enabled = IsForwardingEvents();
1431
1432   if (!gui_enabled) {
1433     bool pop_process_io_handler = false;
1434     assert(process_sp);
1435
1436     bool state_is_stopped = false;
1437     const bool got_state_changed =
1438         (event_type & Process::eBroadcastBitStateChanged) != 0;
1439     const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
1440     const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
1441     const bool got_structured_data =
1442         (event_type & Process::eBroadcastBitStructuredData) != 0;
1443
1444     if (got_state_changed) {
1445       StateType event_state =
1446           Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1447       state_is_stopped = StateIsStoppedState(event_state, false);
1448     }
1449
1450     // Display running state changes first before any STDIO
1451     if (got_state_changed && !state_is_stopped) {
1452       Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
1453                                               pop_process_io_handler);
1454     }
1455
1456     // Now display and STDOUT
1457     if (got_stdout || got_state_changed) {
1458       GetProcessSTDOUT(process_sp.get(), output_stream_sp.get());
1459     }
1460
1461     // Now display and STDERR
1462     if (got_stderr || got_state_changed) {
1463       GetProcessSTDERR(process_sp.get(), error_stream_sp.get());
1464     }
1465
1466     // Give structured data events an opportunity to display.
1467     if (got_structured_data) {
1468       StructuredDataPluginSP plugin_sp =
1469           EventDataStructuredData::GetPluginFromEvent(event_sp.get());
1470       if (plugin_sp) {
1471         auto structured_data_sp =
1472             EventDataStructuredData::GetObjectFromEvent(event_sp.get());
1473         if (output_stream_sp) {
1474           StreamString content_stream;
1475           Status error =
1476               plugin_sp->GetDescription(structured_data_sp, content_stream);
1477           if (error.Success()) {
1478             if (!content_stream.GetString().empty()) {
1479               // Add newline.
1480               content_stream.PutChar('\n');
1481               content_stream.Flush();
1482
1483               // Print it.
1484               output_stream_sp->PutCString(content_stream.GetString());
1485             }
1486           } else {
1487             error_stream_sp->Printf("Failed to print structured "
1488                                     "data with plugin %s: %s",
1489                                     plugin_sp->GetPluginName().AsCString(),
1490                                     error.AsCString());
1491           }
1492         }
1493       }
1494     }
1495
1496     // Now display any stopped state changes after any STDIO
1497     if (got_state_changed && state_is_stopped) {
1498       Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
1499                                               pop_process_io_handler);
1500     }
1501
1502     output_stream_sp->Flush();
1503     error_stream_sp->Flush();
1504
1505     if (pop_process_io_handler)
1506       process_sp->PopProcessIOHandler();
1507   }
1508 }
1509
1510 void Debugger::HandleThreadEvent(const EventSP &event_sp) {
1511   // At present the only thread event we handle is the Frame Changed event, and
1512   // all we do for that is just reprint the thread status for that thread.
1513   using namespace lldb;
1514   const uint32_t event_type = event_sp->GetType();
1515   const bool stop_format = true;
1516   if (event_type == Thread::eBroadcastBitStackChanged ||
1517       event_type == Thread::eBroadcastBitThreadSelected) {
1518     ThreadSP thread_sp(
1519         Thread::ThreadEventData::GetThreadFromEvent(event_sp.get()));
1520     if (thread_sp) {
1521       thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1, stop_format);
1522     }
1523   }
1524 }
1525
1526 bool Debugger::IsForwardingEvents() { return (bool)m_forward_listener_sp; }
1527
1528 void Debugger::EnableForwardEvents(const ListenerSP &listener_sp) {
1529   m_forward_listener_sp = listener_sp;
1530 }
1531
1532 void Debugger::CancelForwardEvents(const ListenerSP &listener_sp) {
1533   m_forward_listener_sp.reset();
1534 }
1535
1536 void Debugger::DefaultEventHandler() {
1537   ListenerSP listener_sp(GetListener());
1538   ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
1539   ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
1540   ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
1541   BroadcastEventSpec target_event_spec(broadcaster_class_target,
1542                                        Target::eBroadcastBitBreakpointChanged);
1543
1544   BroadcastEventSpec process_event_spec(
1545       broadcaster_class_process,
1546       Process::eBroadcastBitStateChanged | Process::eBroadcastBitSTDOUT |
1547           Process::eBroadcastBitSTDERR | Process::eBroadcastBitStructuredData);
1548
1549   BroadcastEventSpec thread_event_spec(broadcaster_class_thread,
1550                                        Thread::eBroadcastBitStackChanged |
1551                                            Thread::eBroadcastBitThreadSelected);
1552
1553   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
1554                                           target_event_spec);
1555   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
1556                                           process_event_spec);
1557   listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
1558                                           thread_event_spec);
1559   listener_sp->StartListeningForEvents(
1560       m_command_interpreter_up.get(),
1561       CommandInterpreter::eBroadcastBitQuitCommandReceived |
1562           CommandInterpreter::eBroadcastBitAsynchronousOutputData |
1563           CommandInterpreter::eBroadcastBitAsynchronousErrorData);
1564
1565   // Let the thread that spawned us know that we have started up and that we
1566   // are now listening to all required events so no events get missed
1567   m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);
1568
1569   bool done = false;
1570   while (!done) {
1571     EventSP event_sp;
1572     if (listener_sp->GetEvent(event_sp, llvm::None)) {
1573       if (event_sp) {
1574         Broadcaster *broadcaster = event_sp->GetBroadcaster();
1575         if (broadcaster) {
1576           uint32_t event_type = event_sp->GetType();
1577           ConstString broadcaster_class(broadcaster->GetBroadcasterClass());
1578           if (broadcaster_class == broadcaster_class_process) {
1579             HandleProcessEvent(event_sp);
1580           } else if (broadcaster_class == broadcaster_class_target) {
1581             if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(
1582                     event_sp.get())) {
1583               HandleBreakpointEvent(event_sp);
1584             }
1585           } else if (broadcaster_class == broadcaster_class_thread) {
1586             HandleThreadEvent(event_sp);
1587           } else if (broadcaster == m_command_interpreter_up.get()) {
1588             if (event_type &
1589                 CommandInterpreter::eBroadcastBitQuitCommandReceived) {
1590               done = true;
1591             } else if (event_type &
1592                        CommandInterpreter::eBroadcastBitAsynchronousErrorData) {
1593               const char *data = reinterpret_cast<const char *>(
1594                   EventDataBytes::GetBytesFromEvent(event_sp.get()));
1595               if (data && data[0]) {
1596                 StreamSP error_sp(GetAsyncErrorStream());
1597                 if (error_sp) {
1598                   error_sp->PutCString(data);
1599                   error_sp->Flush();
1600                 }
1601               }
1602             } else if (event_type & CommandInterpreter::
1603                                         eBroadcastBitAsynchronousOutputData) {
1604               const char *data = reinterpret_cast<const char *>(
1605                   EventDataBytes::GetBytesFromEvent(event_sp.get()));
1606               if (data && data[0]) {
1607                 StreamSP output_sp(GetAsyncOutputStream());
1608                 if (output_sp) {
1609                   output_sp->PutCString(data);
1610                   output_sp->Flush();
1611                 }
1612               }
1613             }
1614           }
1615         }
1616
1617         if (m_forward_listener_sp)
1618           m_forward_listener_sp->AddEvent(event_sp);
1619       }
1620     }
1621   }
1622 }
1623
1624 lldb::thread_result_t Debugger::EventHandlerThread(lldb::thread_arg_t arg) {
1625   ((Debugger *)arg)->DefaultEventHandler();
1626   return {};
1627 }
1628
1629 bool Debugger::StartEventHandlerThread() {
1630   if (!m_event_handler_thread.IsJoinable()) {
1631     // We must synchronize with the DefaultEventHandler() thread to ensure it
1632     // is up and running and listening to events before we return from this
1633     // function. We do this by listening to events for the
1634     // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
1635     ConstString full_name("lldb.debugger.event-handler");
1636     ListenerSP listener_sp(Listener::MakeListener(full_name.AsCString()));
1637     listener_sp->StartListeningForEvents(&m_sync_broadcaster,
1638                                          eBroadcastBitEventThreadIsListening);
1639
1640     auto thread_name =
1641         full_name.GetLength() < llvm::get_max_thread_name_length() ?
1642         full_name.AsCString() : "dbg.evt-handler";
1643
1644     // Use larger 8MB stack for this thread
1645     llvm::Expected<HostThread> event_handler_thread =
1646         ThreadLauncher::LaunchThread(thread_name, EventHandlerThread, this,
1647                                      g_debugger_event_thread_stack_bytes);
1648
1649     if (event_handler_thread) {
1650       m_event_handler_thread = *event_handler_thread;
1651     } else {
1652       LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
1653                "failed to launch host thread: {}",
1654                llvm::toString(event_handler_thread.takeError()));
1655     }
1656
1657     // Make sure DefaultEventHandler() is running and listening to events
1658     // before we return from this function. We are only listening for events of
1659     // type eBroadcastBitEventThreadIsListening so we don't need to check the
1660     // event, we just need to wait an infinite amount of time for it (nullptr
1661     // timeout as the first parameter)
1662     lldb::EventSP event_sp;
1663     listener_sp->GetEvent(event_sp, llvm::None);
1664   }
1665   return m_event_handler_thread.IsJoinable();
1666 }
1667
1668 void Debugger::StopEventHandlerThread() {
1669   if (m_event_handler_thread.IsJoinable()) {
1670     GetCommandInterpreter().BroadcastEvent(
1671         CommandInterpreter::eBroadcastBitQuitCommandReceived);
1672     m_event_handler_thread.Join(nullptr);
1673   }
1674 }
1675
1676 lldb::thread_result_t Debugger::IOHandlerThread(lldb::thread_arg_t arg) {
1677   Debugger *debugger = (Debugger *)arg;
1678   debugger->ExecuteIOHandlers();
1679   debugger->StopEventHandlerThread();
1680   return {};
1681 }
1682
1683 bool Debugger::HasIOHandlerThread() { return m_io_handler_thread.IsJoinable(); }
1684
1685 bool Debugger::StartIOHandlerThread() {
1686   if (!m_io_handler_thread.IsJoinable()) {
1687     llvm::Expected<HostThread> io_handler_thread = ThreadLauncher::LaunchThread(
1688         "lldb.debugger.io-handler", IOHandlerThread, this,
1689         8 * 1024 * 1024); // Use larger 8MB stack for this thread
1690     if (io_handler_thread) {
1691       m_io_handler_thread = *io_handler_thread;
1692     } else {
1693       LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
1694                "failed to launch host thread: {}",
1695                llvm::toString(io_handler_thread.takeError()));
1696     }
1697   }
1698   return m_io_handler_thread.IsJoinable();
1699 }
1700
1701 void Debugger::StopIOHandlerThread() {
1702   if (m_io_handler_thread.IsJoinable()) {
1703     if (m_input_file_sp)
1704       m_input_file_sp->GetFile().Close();
1705     m_io_handler_thread.Join(nullptr);
1706   }
1707 }
1708
1709 void Debugger::JoinIOHandlerThread() {
1710   if (HasIOHandlerThread()) {
1711     thread_result_t result;
1712     m_io_handler_thread.Join(&result);
1713     m_io_handler_thread = LLDB_INVALID_HOST_THREAD;
1714   }
1715 }
1716
1717 Target *Debugger::GetDummyTarget() {
1718   return m_target_list.GetDummyTarget(*this).get();
1719 }
1720
1721 Target *Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
1722   Target *target = nullptr;
1723   if (!prefer_dummy) {
1724     target = m_target_list.GetSelectedTarget().get();
1725     if (target)
1726       return target;
1727   }
1728
1729   return GetDummyTarget();
1730 }
1731
1732 Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
1733   Status err;
1734   FileSpec repl_executable;
1735
1736   if (language == eLanguageTypeUnknown) {
1737     std::set<LanguageType> repl_languages;
1738
1739     Language::GetLanguagesSupportingREPLs(repl_languages);
1740
1741     if (repl_languages.size() == 1) {
1742       language = *repl_languages.begin();
1743     } else if (repl_languages.empty()) {
1744       err.SetErrorStringWithFormat(
1745           "LLDB isn't configured with REPL support for any languages.");
1746       return err;
1747     } else {
1748       err.SetErrorStringWithFormat(
1749           "Multiple possible REPL languages.  Please specify a language.");
1750       return err;
1751     }
1752   }
1753
1754   Target *const target =
1755       nullptr; // passing in an empty target means the REPL must create one
1756
1757   REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options));
1758
1759   if (!err.Success()) {
1760     return err;
1761   }
1762
1763   if (!repl_sp) {
1764     err.SetErrorStringWithFormat("couldn't find a REPL for %s",
1765                                  Language::GetNameForLanguageType(language));
1766     return err;
1767   }
1768
1769   repl_sp->SetCompilerOptions(repl_options);
1770   repl_sp->RunLoop();
1771
1772   return err;
1773 }