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