mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-19 03:25:54 -04:00
808142876c
Summary: A *.cpp file header in LLDB (and in LLDB) should like this: ``` //===-- TestUtilities.cpp -------------------------------------------------===// ``` However in LLDB most of our source files have arbitrary changes to this format and these changes are spreading through LLDB as folks usually just use the existing source files as templates for their new files (most notably the unnecessary editor language indicator `-*- C++ -*-` is spreading and in every review someone is pointing out that this is wrong, resulting in people pointing out that this is done in the same way in other files). This patch removes most of these inconsistencies including the editor language indicators, all the different missing/additional '-' characters, files that center the file name, missing trailing `===//` (mostly caused by clang-format breaking the line). Reviewers: aprantl, espindola, jfb, shafik, JDevlieghere Reviewed By: JDevlieghere Subscribers: dexonsmith, wuzish, emaste, sdardis, nemanjai, kbarton, MaskRay, atanasyan, arphaman, jfb, abidh, jsji, JDevlieghere, usaxena95, lldb-commits Tags: #lldb Differential Revision: https://reviews.llvm.org/D73258
1660 lines
59 KiB
C++
1660 lines
59 KiB
C++
//===-- Debugger.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/Debugger.h"
|
|
|
|
#include "lldb/Breakpoint/Breakpoint.h"
|
|
#include "lldb/Core/FormatEntity.h"
|
|
#include "lldb/Core/Mangled.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/StreamAsynchronousIO.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/DataFormatters/DataVisualization.h"
|
|
#include "lldb/Expression/REPL.h"
|
|
#include "lldb/Host/File.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Host/Terminal.h"
|
|
#include "lldb/Host/ThreadLauncher.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/OptionValue.h"
|
|
#include "lldb/Interpreter/OptionValueProperties.h"
|
|
#include "lldb/Interpreter/OptionValueSInt64.h"
|
|
#include "lldb/Interpreter/OptionValueString.h"
|
|
#include "lldb/Interpreter/Property.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Symbol/Symbol.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Target/Language.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/StructuredDataPlugin.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/TargetList.h"
|
|
#include "lldb/Target/Thread.h"
|
|
#include "lldb/Target/ThreadList.h"
|
|
#include "lldb/Utility/AnsiTerminal.h"
|
|
#include "lldb/Utility/Event.h"
|
|
#include "lldb/Utility/Listener.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Reproducer.h"
|
|
#include "lldb/Utility/State.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/Utility/StreamCallback.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
#if defined(_WIN32)
|
|
#include "lldb/Host/windows/PosixApi.h"
|
|
#include "lldb/Host/windows/windows.h"
|
|
#endif
|
|
|
|
#include "llvm/ADT/None.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/iterator.h"
|
|
#include "llvm/Support/DynamicLibrary.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Process.h"
|
|
#include "llvm/Support/Threading.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <list>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <set>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <string>
|
|
#include <system_error>
|
|
|
|
namespace lldb_private {
|
|
class Address;
|
|
}
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
static lldb::user_id_t g_unique_id = 1;
|
|
static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
|
|
|
|
#pragma mark Static Functions
|
|
|
|
typedef std::vector<DebuggerSP> DebuggerList;
|
|
static std::recursive_mutex *g_debugger_list_mutex_ptr =
|
|
nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
|
|
static DebuggerList *g_debugger_list_ptr =
|
|
nullptr; // NOTE: intentional leak to avoid issues with C++ destructor chain
|
|
|
|
static constexpr OptionEnumValueElement g_show_disassembly_enum_values[] = {
|
|
{
|
|
Debugger::eStopDisassemblyTypeNever,
|
|
"never",
|
|
"Never show disassembly when displaying a stop context.",
|
|
},
|
|
{
|
|
Debugger::eStopDisassemblyTypeNoDebugInfo,
|
|
"no-debuginfo",
|
|
"Show disassembly when there is no debug information.",
|
|
},
|
|
{
|
|
Debugger::eStopDisassemblyTypeNoSource,
|
|
"no-source",
|
|
"Show disassembly when there is no source information, or the source "
|
|
"file "
|
|
"is missing when displaying a stop context.",
|
|
},
|
|
{
|
|
Debugger::eStopDisassemblyTypeAlways,
|
|
"always",
|
|
"Always show disassembly when displaying a stop context.",
|
|
},
|
|
};
|
|
|
|
static constexpr OptionEnumValueElement g_language_enumerators[] = {
|
|
{
|
|
eScriptLanguageNone,
|
|
"none",
|
|
"Disable scripting languages.",
|
|
},
|
|
{
|
|
eScriptLanguagePython,
|
|
"python",
|
|
"Select python as the default scripting language.",
|
|
},
|
|
{
|
|
eScriptLanguageDefault,
|
|
"default",
|
|
"Select the lldb default as the default scripting language.",
|
|
},
|
|
};
|
|
|
|
#define MODULE_WITH_FUNC \
|
|
"{ " \
|
|
"${module.file.basename}{`${function.name-with-args}" \
|
|
"{${frame.no-debug}${function.pc-offset}}}}"
|
|
|
|
#define MODULE_WITH_FUNC_NO_ARGS \
|
|
"{ " \
|
|
"${module.file.basename}{`${function.name-without-args}" \
|
|
"{${frame.no-debug}${function.pc-offset}}}}"
|
|
|
|
#define FILE_AND_LINE \
|
|
"{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}" \
|
|
":${ansi.fg.yellow}${line.number}${ansi.normal}" \
|
|
"{:${ansi.fg.yellow}${line.column}${ansi.normal}}}"
|
|
|
|
#define IS_OPTIMIZED "{${function.is-optimized} [opt]}"
|
|
|
|
#define IS_ARTIFICIAL "{${frame.is-artificial} [artificial]}"
|
|
|
|
#define DEFAULT_THREAD_FORMAT \
|
|
"thread #${thread.index}: tid = ${thread.id%tid}" \
|
|
"{, ${frame.pc}}" MODULE_WITH_FUNC FILE_AND_LINE \
|
|
"{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}" \
|
|
"{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}" \
|
|
"{, activity = " \
|
|
"${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}" \
|
|
"{, ${thread.info.trace_messages} messages}" \
|
|
"{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}" \
|
|
"{\\nReturn value: ${thread.return-value}}" \
|
|
"{\\nCompleted expression: ${thread.completed-expression}}" \
|
|
"\\n"
|
|
|
|
#define DEFAULT_THREAD_STOP_FORMAT \
|
|
"thread #${thread.index}{, name = '${thread.name}'}" \
|
|
"{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}" \
|
|
"{, activity = " \
|
|
"${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}" \
|
|
"{, ${thread.info.trace_messages} messages}" \
|
|
"{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}" \
|
|
"{\\nReturn value: ${thread.return-value}}" \
|
|
"{\\nCompleted expression: ${thread.completed-expression}}" \
|
|
"\\n"
|
|
|
|
#define DEFAULT_FRAME_FORMAT \
|
|
"frame #${frame.index}: " \
|
|
"${ansi.fg.yellow}${frame.pc}${ansi.normal}" MODULE_WITH_FUNC FILE_AND_LINE \
|
|
IS_OPTIMIZED IS_ARTIFICIAL "\\n"
|
|
|
|
#define DEFAULT_FRAME_FORMAT_NO_ARGS \
|
|
"frame #${frame.index}: " \
|
|
"${ansi.fg.yellow}${frame.pc}${ansi.normal}" MODULE_WITH_FUNC_NO_ARGS \
|
|
FILE_AND_LINE IS_OPTIMIZED IS_ARTIFICIAL "\\n"
|
|
|
|
// Three parts to this disassembly format specification:
|
|
// 1. If this is a new function/symbol (no previous symbol/function), print
|
|
// dylib`funcname:\n
|
|
// 2. If this is a symbol context change (different from previous
|
|
// symbol/function), print
|
|
// dylib`funcname:\n
|
|
// 3. print
|
|
// address <+offset>:
|
|
#define DEFAULT_DISASSEMBLY_FORMAT \
|
|
"{${function.initial-function}{${module.file.basename}`}{${function.name-" \
|
|
"without-args}}:\\n}{${function.changed}\\n{${module.file.basename}`}{${" \
|
|
"function.name-without-args}}:\\n}{${current-pc-arrow} " \
|
|
"}${addr-file-or-load}{ " \
|
|
"<${function.concrete-only-addr-offset-no-padding}>}: "
|
|
|
|
// gdb's disassembly format can be emulated with ${current-pc-arrow}${addr-
|
|
// file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-
|
|
// offset-no-padding}>}:
|
|
|
|
// lldb's original format for disassembly would look like this format string -
|
|
// {${function.initial-function}{${module.file.basename}`}{${function.name-
|
|
// without-
|
|
// args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-
|
|
// without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
|
|
|
|
static constexpr OptionEnumValueElement s_stop_show_column_values[] = {
|
|
{
|
|
eStopShowColumnAnsiOrCaret,
|
|
"ansi-or-caret",
|
|
"Highlight the stop column with ANSI terminal codes when color/ANSI "
|
|
"mode is enabled; otherwise, fall back to using a text-only caret (^) "
|
|
"as if \"caret-only\" mode was selected.",
|
|
},
|
|
{
|
|
eStopShowColumnAnsi,
|
|
"ansi",
|
|
"Highlight the stop column with ANSI terminal codes when running LLDB "
|
|
"with color/ANSI enabled.",
|
|
},
|
|
{
|
|
eStopShowColumnCaret,
|
|
"caret",
|
|
"Highlight the stop column with a caret character (^) underneath the "
|
|
"stop column. This method introduces a new line in source listings "
|
|
"that display thread stop locations.",
|
|
},
|
|
{
|
|
eStopShowColumnNone,
|
|
"none",
|
|
"Do not highlight the stop column.",
|
|
},
|
|
};
|
|
|
|
#define LLDB_PROPERTIES_debugger
|
|
#include "CoreProperties.inc"
|
|
|
|
enum {
|
|
#define LLDB_PROPERTIES_debugger
|
|
#include "CorePropertiesEnum.inc"
|
|
};
|
|
|
|
LoadPluginCallbackType Debugger::g_load_plugin_callback = nullptr;
|
|
|
|
Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
|
|
VarSetOperationType op,
|
|
llvm::StringRef property_path,
|
|
llvm::StringRef value) {
|
|
bool is_load_script =
|
|
(property_path == "target.load-script-from-symbol-file");
|
|
// These properties might change how we visualize data.
|
|
bool invalidate_data_vis = (property_path == "escape-non-printables");
|
|
invalidate_data_vis |=
|
|
(property_path == "target.max-zero-padding-in-float-format");
|
|
if (invalidate_data_vis) {
|
|
DataVisualization::ForceUpdate();
|
|
}
|
|
|
|
TargetSP target_sp;
|
|
LoadScriptFromSymFile load_script_old_value;
|
|
if (is_load_script && exe_ctx->GetTargetSP()) {
|
|
target_sp = exe_ctx->GetTargetSP();
|
|
load_script_old_value =
|
|
target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
|
|
}
|
|
Status error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
|
|
if (error.Success()) {
|
|
// FIXME it would be nice to have "on-change" callbacks for properties
|
|
if (property_path == g_debugger_properties[ePropertyPrompt].name) {
|
|
llvm::StringRef new_prompt = GetPrompt();
|
|
std::string str = lldb_private::ansi::FormatAnsiTerminalCodes(
|
|
new_prompt, GetUseColor());
|
|
if (str.length())
|
|
new_prompt = str;
|
|
GetCommandInterpreter().UpdatePrompt(new_prompt);
|
|
auto bytes = std::make_unique<EventDataBytes>(new_prompt);
|
|
auto prompt_change_event_sp = std::make_shared<Event>(
|
|
CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
|
|
GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
|
|
} else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
|
|
// use-color changed. Ping the prompt so it can reset the ansi terminal
|
|
// codes.
|
|
SetPrompt(GetPrompt());
|
|
} else if (is_load_script && target_sp &&
|
|
load_script_old_value == eLoadScriptFromSymFileWarn) {
|
|
if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
|
|
eLoadScriptFromSymFileTrue) {
|
|
std::list<Status> errors;
|
|
StreamString feedback_stream;
|
|
if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
|
|
Stream &s = GetErrorStream();
|
|
for (auto error : errors) {
|
|
s.Printf("%s\n", error.AsCString());
|
|
}
|
|
if (feedback_stream.GetSize())
|
|
s.PutCString(feedback_stream.GetString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return error;
|
|
}
|
|
|
|
bool Debugger::GetAutoConfirm() const {
|
|
const uint32_t idx = ePropertyAutoConfirm;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
const FormatEntity::Entry *Debugger::GetDisassemblyFormat() const {
|
|
const uint32_t idx = ePropertyDisassemblyFormat;
|
|
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
|
|
}
|
|
|
|
const FormatEntity::Entry *Debugger::GetFrameFormat() const {
|
|
const uint32_t idx = ePropertyFrameFormat;
|
|
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
|
|
}
|
|
|
|
const FormatEntity::Entry *Debugger::GetFrameFormatUnique() const {
|
|
const uint32_t idx = ePropertyFrameFormatUnique;
|
|
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
|
|
}
|
|
|
|
bool Debugger::GetNotifyVoid() const {
|
|
const uint32_t idx = ePropertyNotiftVoid;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
llvm::StringRef Debugger::GetPrompt() const {
|
|
const uint32_t idx = ePropertyPrompt;
|
|
return m_collection_sp->GetPropertyAtIndexAsString(
|
|
nullptr, idx, g_debugger_properties[idx].default_cstr_value);
|
|
}
|
|
|
|
void Debugger::SetPrompt(llvm::StringRef p) {
|
|
const uint32_t idx = ePropertyPrompt;
|
|
m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
|
|
llvm::StringRef new_prompt = GetPrompt();
|
|
std::string str =
|
|
lldb_private::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
|
|
if (str.length())
|
|
new_prompt = str;
|
|
GetCommandInterpreter().UpdatePrompt(new_prompt);
|
|
}
|
|
|
|
llvm::StringRef Debugger::GetReproducerPath() const {
|
|
auto &r = repro::Reproducer::Instance();
|
|
return r.GetReproducerPath().GetCString();
|
|
}
|
|
|
|
const FormatEntity::Entry *Debugger::GetThreadFormat() const {
|
|
const uint32_t idx = ePropertyThreadFormat;
|
|
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
|
|
}
|
|
|
|
const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {
|
|
const uint32_t idx = ePropertyThreadStopFormat;
|
|
return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
|
|
}
|
|
|
|
lldb::ScriptLanguage Debugger::GetScriptLanguage() const {
|
|
const uint32_t idx = ePropertyScriptLanguage;
|
|
return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
bool Debugger::SetScriptLanguage(lldb::ScriptLanguage script_lang) {
|
|
const uint32_t idx = ePropertyScriptLanguage;
|
|
return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx,
|
|
script_lang);
|
|
}
|
|
|
|
uint32_t Debugger::GetTerminalWidth() const {
|
|
const uint32_t idx = ePropertyTerminalWidth;
|
|
return m_collection_sp->GetPropertyAtIndexAsSInt64(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
bool Debugger::SetTerminalWidth(uint32_t term_width) {
|
|
const uint32_t idx = ePropertyTerminalWidth;
|
|
return m_collection_sp->SetPropertyAtIndexAsSInt64(nullptr, idx, term_width);
|
|
}
|
|
|
|
bool Debugger::GetUseExternalEditor() const {
|
|
const uint32_t idx = ePropertyUseExternalEditor;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool Debugger::SetUseExternalEditor(bool b) {
|
|
const uint32_t idx = ePropertyUseExternalEditor;
|
|
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
|
|
}
|
|
|
|
bool Debugger::GetUseColor() const {
|
|
const uint32_t idx = ePropertyUseColor;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool Debugger::SetUseColor(bool b) {
|
|
const uint32_t idx = ePropertyUseColor;
|
|
bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
|
|
SetPrompt(GetPrompt());
|
|
return ret;
|
|
}
|
|
|
|
bool Debugger::GetHighlightSource() const {
|
|
const uint32_t idx = ePropertyHighlightSource;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
StopShowColumn Debugger::GetStopShowColumn() const {
|
|
const uint32_t idx = ePropertyStopShowColumn;
|
|
return (lldb::StopShowColumn)m_collection_sp->GetPropertyAtIndexAsEnumeration(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
llvm::StringRef Debugger::GetStopShowColumnAnsiPrefix() const {
|
|
const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
|
|
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
|
|
}
|
|
|
|
llvm::StringRef Debugger::GetStopShowColumnAnsiSuffix() const {
|
|
const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
|
|
return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, "");
|
|
}
|
|
|
|
uint32_t Debugger::GetStopSourceLineCount(bool before) const {
|
|
const uint32_t idx =
|
|
before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
|
|
return m_collection_sp->GetPropertyAtIndexAsSInt64(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
Debugger::StopDisassemblyType Debugger::GetStopDisassemblyDisplay() const {
|
|
const uint32_t idx = ePropertyStopDisassemblyDisplay;
|
|
return (Debugger::StopDisassemblyType)
|
|
m_collection_sp->GetPropertyAtIndexAsEnumeration(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
uint32_t Debugger::GetDisassemblyLineCount() const {
|
|
const uint32_t idx = ePropertyStopDisassemblyCount;
|
|
return m_collection_sp->GetPropertyAtIndexAsSInt64(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
bool Debugger::GetAutoOneLineSummaries() const {
|
|
const uint32_t idx = ePropertyAutoOneLineSummaries;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
|
|
}
|
|
|
|
bool Debugger::GetEscapeNonPrintables() const {
|
|
const uint32_t idx = ePropertyEscapeNonPrintables;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
|
|
}
|
|
|
|
bool Debugger::GetAutoIndent() const {
|
|
const uint32_t idx = ePropertyAutoIndent;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
|
|
}
|
|
|
|
bool Debugger::SetAutoIndent(bool b) {
|
|
const uint32_t idx = ePropertyAutoIndent;
|
|
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
|
|
}
|
|
|
|
bool Debugger::GetPrintDecls() const {
|
|
const uint32_t idx = ePropertyPrintDecls;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
|
|
}
|
|
|
|
bool Debugger::SetPrintDecls(bool b) {
|
|
const uint32_t idx = ePropertyPrintDecls;
|
|
return m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
|
|
}
|
|
|
|
uint32_t Debugger::GetTabSize() const {
|
|
const uint32_t idx = ePropertyTabSize;
|
|
return m_collection_sp->GetPropertyAtIndexAsUInt64(
|
|
nullptr, idx, g_debugger_properties[idx].default_uint_value);
|
|
}
|
|
|
|
bool Debugger::SetTabSize(uint32_t tab_size) {
|
|
const uint32_t idx = ePropertyTabSize;
|
|
return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, tab_size);
|
|
}
|
|
|
|
#pragma mark Debugger
|
|
|
|
// const DebuggerPropertiesSP &
|
|
// Debugger::GetSettings() const
|
|
//{
|
|
// return m_properties_sp;
|
|
//}
|
|
//
|
|
|
|
void Debugger::Initialize(LoadPluginCallbackType load_plugin_callback) {
|
|
assert(g_debugger_list_ptr == nullptr &&
|
|
"Debugger::Initialize called more than once!");
|
|
g_debugger_list_mutex_ptr = new std::recursive_mutex();
|
|
g_debugger_list_ptr = new DebuggerList();
|
|
g_load_plugin_callback = load_plugin_callback;
|
|
}
|
|
|
|
void Debugger::Terminate() {
|
|
assert(g_debugger_list_ptr &&
|
|
"Debugger::Terminate called without a matching Debugger::Initialize!");
|
|
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
// Clear our master list of debugger objects
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
for (const auto &debugger : *g_debugger_list_ptr)
|
|
debugger->Clear();
|
|
g_debugger_list_ptr->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Debugger::SettingsInitialize() { Target::SettingsInitialize(); }
|
|
|
|
void Debugger::SettingsTerminate() { Target::SettingsTerminate(); }
|
|
|
|
bool Debugger::LoadPlugin(const FileSpec &spec, Status &error) {
|
|
if (g_load_plugin_callback) {
|
|
llvm::sys::DynamicLibrary dynlib =
|
|
g_load_plugin_callback(shared_from_this(), spec, error);
|
|
if (dynlib.isValid()) {
|
|
m_loaded_plugins.push_back(dynlib);
|
|
return true;
|
|
}
|
|
} else {
|
|
// The g_load_plugin_callback is registered in SBDebugger::Initialize() and
|
|
// if the public API layer isn't available (code is linking against all of
|
|
// the internal LLDB static libraries), then we can't load plugins
|
|
error.SetErrorString("Public API layer is not available");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static FileSystem::EnumerateDirectoryResult
|
|
LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft,
|
|
llvm::StringRef path) {
|
|
Status error;
|
|
|
|
static ConstString g_dylibext(".dylib");
|
|
static ConstString g_solibext(".so");
|
|
|
|
if (!baton)
|
|
return FileSystem::eEnumerateDirectoryResultQuit;
|
|
|
|
Debugger *debugger = (Debugger *)baton;
|
|
|
|
namespace fs = llvm::sys::fs;
|
|
// If we have a regular file, a symbolic link or unknown file type, try and
|
|
// process the file. We must handle unknown as sometimes the directory
|
|
// enumeration might be enumerating a file system that doesn't have correct
|
|
// file type information.
|
|
if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
|
|
ft == fs::file_type::type_unknown) {
|
|
FileSpec plugin_file_spec(path);
|
|
FileSystem::Instance().Resolve(plugin_file_spec);
|
|
|
|
if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
|
|
plugin_file_spec.GetFileNameExtension() != g_solibext) {
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
Status plugin_load_error;
|
|
debugger->LoadPlugin(plugin_file_spec, plugin_load_error);
|
|
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
} else if (ft == fs::file_type::directory_file ||
|
|
ft == fs::file_type::symlink_file ||
|
|
ft == fs::file_type::type_unknown) {
|
|
// Try and recurse into anything that a directory or symbolic link. We must
|
|
// also do this for unknown as sometimes the directory enumeration might be
|
|
// enumerating a file system that doesn't have correct file type
|
|
// information.
|
|
return FileSystem::eEnumerateDirectoryResultEnter;
|
|
}
|
|
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
}
|
|
|
|
void Debugger::InstanceInitialize() {
|
|
const bool find_directories = true;
|
|
const bool find_files = true;
|
|
const bool find_other = true;
|
|
char dir_path[PATH_MAX];
|
|
if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
|
|
if (FileSystem::Instance().Exists(dir_spec) &&
|
|
dir_spec.GetPath(dir_path, sizeof(dir_path))) {
|
|
FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
|
|
find_files, find_other,
|
|
LoadPluginCallback, this);
|
|
}
|
|
}
|
|
|
|
if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
|
|
if (FileSystem::Instance().Exists(dir_spec) &&
|
|
dir_spec.GetPath(dir_path, sizeof(dir_path))) {
|
|
FileSystem::Instance().EnumerateDirectory(dir_path, find_directories,
|
|
find_files, find_other,
|
|
LoadPluginCallback, this);
|
|
}
|
|
}
|
|
|
|
PluginManager::DebuggerInitialize(*this);
|
|
}
|
|
|
|
DebuggerSP Debugger::CreateInstance(lldb::LogOutputCallback log_callback,
|
|
void *baton) {
|
|
DebuggerSP debugger_sp(new Debugger(log_callback, baton));
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
g_debugger_list_ptr->push_back(debugger_sp);
|
|
}
|
|
debugger_sp->InstanceInitialize();
|
|
return debugger_sp;
|
|
}
|
|
|
|
void Debugger::Destroy(DebuggerSP &debugger_sp) {
|
|
if (!debugger_sp)
|
|
return;
|
|
|
|
debugger_sp->Clear();
|
|
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
|
|
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
|
|
if ((*pos).get() == debugger_sp.get()) {
|
|
g_debugger_list_ptr->erase(pos);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DebuggerSP Debugger::FindDebuggerWithInstanceName(ConstString instance_name) {
|
|
DebuggerSP debugger_sp;
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
|
|
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
|
|
if ((*pos)->m_instance_name == instance_name) {
|
|
debugger_sp = *pos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return debugger_sp;
|
|
}
|
|
|
|
TargetSP Debugger::FindTargetWithProcessID(lldb::pid_t pid) {
|
|
TargetSP target_sp;
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
|
|
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
|
|
target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
|
|
if (target_sp)
|
|
break;
|
|
}
|
|
}
|
|
return target_sp;
|
|
}
|
|
|
|
TargetSP Debugger::FindTargetWithProcess(Process *process) {
|
|
TargetSP target_sp;
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
|
|
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
|
|
target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
|
|
if (target_sp)
|
|
break;
|
|
}
|
|
}
|
|
return target_sp;
|
|
}
|
|
|
|
Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton)
|
|
: UserID(g_unique_id++),
|
|
Properties(std::make_shared<OptionValueProperties>()),
|
|
m_input_file_sp(std::make_shared<NativeFile>(stdin, false)),
|
|
m_output_stream_sp(std::make_shared<StreamFile>(stdout, false)),
|
|
m_error_stream_sp(std::make_shared<StreamFile>(stderr, false)),
|
|
m_input_recorder(nullptr),
|
|
m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
|
|
m_terminal_state(), m_target_list(*this), m_platform_list(),
|
|
m_listener_sp(Listener::MakeListener("lldb.Debugger")),
|
|
m_source_manager_up(), m_source_file_cache(),
|
|
m_command_interpreter_up(
|
|
std::make_unique<CommandInterpreter>(*this, false)),
|
|
m_io_handler_stack(), m_instance_name(), m_loaded_plugins(),
|
|
m_event_handler_thread(), m_io_handler_thread(),
|
|
m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
|
|
m_forward_listener_sp(), m_clear_once() {
|
|
char instance_cstr[256];
|
|
snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
|
|
m_instance_name.SetCString(instance_cstr);
|
|
if (log_callback)
|
|
m_log_callback_stream_sp =
|
|
std::make_shared<StreamCallback>(log_callback, baton);
|
|
m_command_interpreter_up->Initialize();
|
|
// Always add our default platform to the platform list
|
|
PlatformSP default_platform_sp(Platform::GetHostPlatform());
|
|
assert(default_platform_sp);
|
|
m_platform_list.Append(default_platform_sp, true);
|
|
|
|
m_dummy_target_sp = m_target_list.GetDummyTarget(*this);
|
|
assert(m_dummy_target_sp.get() && "Couldn't construct dummy target?");
|
|
|
|
m_collection_sp->Initialize(g_debugger_properties);
|
|
m_collection_sp->AppendProperty(
|
|
ConstString("target"),
|
|
ConstString("Settings specify to debugging targets."), true,
|
|
Target::GetGlobalProperties()->GetValueProperties());
|
|
m_collection_sp->AppendProperty(
|
|
ConstString("platform"), ConstString("Platform settings."), true,
|
|
Platform::GetGlobalPlatformProperties()->GetValueProperties());
|
|
m_collection_sp->AppendProperty(
|
|
ConstString("symbols"), ConstString("Symbol lookup and cache settings."),
|
|
true, ModuleList::GetGlobalModuleListProperties().GetValueProperties());
|
|
if (m_command_interpreter_up) {
|
|
m_collection_sp->AppendProperty(
|
|
ConstString("interpreter"),
|
|
ConstString("Settings specify to the debugger's command interpreter."),
|
|
true, m_command_interpreter_up->GetValueProperties());
|
|
}
|
|
OptionValueSInt64 *term_width =
|
|
m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64(
|
|
nullptr, ePropertyTerminalWidth);
|
|
term_width->SetMinimumValue(10);
|
|
term_width->SetMaximumValue(1024);
|
|
|
|
// Turn off use-color if this is a dumb terminal.
|
|
const char *term = getenv("TERM");
|
|
if (term && !strcmp(term, "dumb"))
|
|
SetUseColor(false);
|
|
// Turn off use-color if we don't write to a terminal with color support.
|
|
if (!GetOutputFile().GetIsTerminalWithColors())
|
|
SetUseColor(false);
|
|
|
|
#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
|
|
// Enabling use of ANSI color codes because LLDB is using them to highlight
|
|
// text.
|
|
llvm::sys::Process::UseANSIEscapeCodes(true);
|
|
#endif
|
|
}
|
|
|
|
Debugger::~Debugger() { Clear(); }
|
|
|
|
void Debugger::Clear() {
|
|
// Make sure we call this function only once. With the C++ global destructor
|
|
// chain having a list of debuggers and with code that can be running on
|
|
// other threads, we need to ensure this doesn't happen multiple times.
|
|
//
|
|
// The following functions call Debugger::Clear():
|
|
// Debugger::~Debugger();
|
|
// static void Debugger::Destroy(lldb::DebuggerSP &debugger_sp);
|
|
// static void Debugger::Terminate();
|
|
llvm::call_once(m_clear_once, [this]() {
|
|
ClearIOHandlers();
|
|
StopIOHandlerThread();
|
|
StopEventHandlerThread();
|
|
m_listener_sp->Clear();
|
|
int num_targets = m_target_list.GetNumTargets();
|
|
for (int i = 0; i < num_targets; i++) {
|
|
TargetSP target_sp(m_target_list.GetTargetAtIndex(i));
|
|
if (target_sp) {
|
|
ProcessSP process_sp(target_sp->GetProcessSP());
|
|
if (process_sp)
|
|
process_sp->Finalize();
|
|
target_sp->Destroy();
|
|
}
|
|
}
|
|
m_broadcaster_manager_sp->Clear();
|
|
|
|
// Close the input file _before_ we close the input read communications
|
|
// class as it does NOT own the input file, our m_input_file does.
|
|
m_terminal_state.Clear();
|
|
GetInputFile().Close();
|
|
|
|
m_command_interpreter_up->Clear();
|
|
});
|
|
}
|
|
|
|
bool Debugger::GetCloseInputOnEOF() const {
|
|
// return m_input_comm.GetCloseOnEOF();
|
|
return false;
|
|
}
|
|
|
|
void Debugger::SetCloseInputOnEOF(bool b) {
|
|
// m_input_comm.SetCloseOnEOF(b);
|
|
}
|
|
|
|
bool Debugger::GetAsyncExecution() {
|
|
return !m_command_interpreter_up->GetSynchronous();
|
|
}
|
|
|
|
void Debugger::SetAsyncExecution(bool async_execution) {
|
|
m_command_interpreter_up->SetSynchronous(!async_execution);
|
|
}
|
|
|
|
repro::DataRecorder *Debugger::GetInputRecorder() { return m_input_recorder; }
|
|
|
|
void Debugger::SetInputFile(FileSP file_sp, repro::DataRecorder *recorder) {
|
|
assert(file_sp && file_sp->IsValid());
|
|
m_input_recorder = recorder;
|
|
m_input_file_sp = file_sp;
|
|
// Save away the terminal state if that is relevant, so that we can restore
|
|
// it in RestoreInputState.
|
|
SaveInputTerminalState();
|
|
}
|
|
|
|
void Debugger::SetOutputFile(FileSP file_sp) {
|
|
assert(file_sp && file_sp->IsValid());
|
|
m_output_stream_sp = std::make_shared<StreamFile>(file_sp);
|
|
}
|
|
|
|
void Debugger::SetErrorFile(FileSP file_sp) {
|
|
assert(file_sp && file_sp->IsValid());
|
|
m_error_stream_sp = std::make_shared<StreamFile>(file_sp);
|
|
}
|
|
|
|
void Debugger::SaveInputTerminalState() {
|
|
int fd = GetInputFile().GetDescriptor();
|
|
if (fd != File::kInvalidDescriptor)
|
|
m_terminal_state.Save(fd, true);
|
|
}
|
|
|
|
void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); }
|
|
|
|
ExecutionContext Debugger::GetSelectedExecutionContext() {
|
|
ExecutionContext exe_ctx;
|
|
TargetSP target_sp(GetSelectedTarget());
|
|
exe_ctx.SetTargetSP(target_sp);
|
|
|
|
if (target_sp) {
|
|
ProcessSP process_sp(target_sp->GetProcessSP());
|
|
exe_ctx.SetProcessSP(process_sp);
|
|
if (process_sp && !process_sp->IsRunning()) {
|
|
ThreadSP thread_sp(process_sp->GetThreadList().GetSelectedThread());
|
|
if (thread_sp) {
|
|
exe_ctx.SetThreadSP(thread_sp);
|
|
exe_ctx.SetFrameSP(thread_sp->GetSelectedFrame());
|
|
if (exe_ctx.GetFramePtr() == nullptr)
|
|
exe_ctx.SetFrameSP(thread_sp->GetStackFrameAtIndex(0));
|
|
}
|
|
}
|
|
}
|
|
return exe_ctx;
|
|
}
|
|
|
|
void Debugger::DispatchInputInterrupt() {
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
IOHandlerSP reader_sp(m_io_handler_stack.Top());
|
|
if (reader_sp)
|
|
reader_sp->Interrupt();
|
|
}
|
|
|
|
void Debugger::DispatchInputEndOfFile() {
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
IOHandlerSP reader_sp(m_io_handler_stack.Top());
|
|
if (reader_sp)
|
|
reader_sp->GotEOF();
|
|
}
|
|
|
|
void Debugger::ClearIOHandlers() {
|
|
// The bottom input reader should be the main debugger input reader. We do
|
|
// not want to close that one here.
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
while (m_io_handler_stack.GetSize() > 1) {
|
|
IOHandlerSP reader_sp(m_io_handler_stack.Top());
|
|
if (reader_sp)
|
|
PopIOHandler(reader_sp);
|
|
}
|
|
}
|
|
|
|
void Debugger::RunIOHandlers() {
|
|
IOHandlerSP reader_sp = m_io_handler_stack.Top();
|
|
while (true) {
|
|
if (!reader_sp)
|
|
break;
|
|
|
|
reader_sp->Run();
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
m_io_handler_synchronous_mutex);
|
|
|
|
// Remove all input readers that are done from the top of the stack
|
|
while (true) {
|
|
IOHandlerSP top_reader_sp = m_io_handler_stack.Top();
|
|
if (top_reader_sp && top_reader_sp->GetIsDone())
|
|
PopIOHandler(top_reader_sp);
|
|
else
|
|
break;
|
|
}
|
|
reader_sp = m_io_handler_stack.Top();
|
|
}
|
|
}
|
|
ClearIOHandlers();
|
|
}
|
|
|
|
void Debugger::RunIOHandlerSync(const IOHandlerSP &reader_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_synchronous_mutex);
|
|
|
|
PushIOHandler(reader_sp);
|
|
IOHandlerSP top_reader_sp = reader_sp;
|
|
|
|
while (top_reader_sp) {
|
|
if (!top_reader_sp)
|
|
break;
|
|
|
|
top_reader_sp->Run();
|
|
|
|
// Don't unwind past the starting point.
|
|
if (top_reader_sp.get() == reader_sp.get()) {
|
|
if (PopIOHandler(reader_sp))
|
|
break;
|
|
}
|
|
|
|
// If we pushed new IO handlers, pop them if they're done or restart the
|
|
// loop to run them if they're not.
|
|
while (true) {
|
|
top_reader_sp = m_io_handler_stack.Top();
|
|
if (top_reader_sp && top_reader_sp->GetIsDone()) {
|
|
PopIOHandler(top_reader_sp);
|
|
// Don't unwind past the starting point.
|
|
if (top_reader_sp.get() == reader_sp.get())
|
|
return;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Debugger::IsTopIOHandler(const lldb::IOHandlerSP &reader_sp) {
|
|
return m_io_handler_stack.IsTop(reader_sp);
|
|
}
|
|
|
|
bool Debugger::CheckTopIOHandlerTypes(IOHandler::Type top_type,
|
|
IOHandler::Type second_top_type) {
|
|
return m_io_handler_stack.CheckTopIOHandlerTypes(top_type, second_top_type);
|
|
}
|
|
|
|
void Debugger::PrintAsync(const char *s, size_t len, bool is_stdout) {
|
|
lldb_private::StreamFile &stream =
|
|
is_stdout ? GetOutputStream() : GetErrorStream();
|
|
m_io_handler_stack.PrintAsync(&stream, s, len);
|
|
}
|
|
|
|
ConstString Debugger::GetTopIOHandlerControlSequence(char ch) {
|
|
return m_io_handler_stack.GetTopIOHandlerControlSequence(ch);
|
|
}
|
|
|
|
const char *Debugger::GetIOHandlerCommandPrefix() {
|
|
return m_io_handler_stack.GetTopIOHandlerCommandPrefix();
|
|
}
|
|
|
|
const char *Debugger::GetIOHandlerHelpPrologue() {
|
|
return m_io_handler_stack.GetTopIOHandlerHelpPrologue();
|
|
}
|
|
|
|
bool Debugger::RemoveIOHandler(const IOHandlerSP &reader_sp) {
|
|
return PopIOHandler(reader_sp);
|
|
}
|
|
|
|
void Debugger::RunIOHandlerAsync(const IOHandlerSP &reader_sp,
|
|
bool cancel_top_handler) {
|
|
PushIOHandler(reader_sp, cancel_top_handler);
|
|
}
|
|
|
|
void Debugger::AdoptTopIOHandlerFilesIfInvalid(FileSP &in, StreamFileSP &out,
|
|
StreamFileSP &err) {
|
|
// Before an IOHandler runs, it must have in/out/err streams. This function
|
|
// is called when one ore more of the streams are nullptr. We use the top
|
|
// input reader's in/out/err streams, or fall back to the debugger file
|
|
// handles, or we fall back onto stdin/stdout/stderr as a last resort.
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
IOHandlerSP top_reader_sp(m_io_handler_stack.Top());
|
|
// If no STDIN has been set, then set it appropriately
|
|
if (!in || !in->IsValid()) {
|
|
if (top_reader_sp)
|
|
in = top_reader_sp->GetInputFileSP();
|
|
else
|
|
in = GetInputFileSP();
|
|
// If there is nothing, use stdin
|
|
if (!in)
|
|
in = std::make_shared<NativeFile>(stdin, false);
|
|
}
|
|
// If no STDOUT has been set, then set it appropriately
|
|
if (!out || !out->GetFile().IsValid()) {
|
|
if (top_reader_sp)
|
|
out = top_reader_sp->GetOutputStreamFileSP();
|
|
else
|
|
out = GetOutputStreamSP();
|
|
// If there is nothing, use stdout
|
|
if (!out)
|
|
out = std::make_shared<StreamFile>(stdout, false);
|
|
}
|
|
// If no STDERR has been set, then set it appropriately
|
|
if (!err || !err->GetFile().IsValid()) {
|
|
if (top_reader_sp)
|
|
err = top_reader_sp->GetErrorStreamFileSP();
|
|
else
|
|
err = GetErrorStreamSP();
|
|
// If there is nothing, use stderr
|
|
if (!err)
|
|
err = std::make_shared<StreamFile>(stderr, false);
|
|
}
|
|
}
|
|
|
|
void Debugger::PushIOHandler(const IOHandlerSP &reader_sp,
|
|
bool cancel_top_handler) {
|
|
if (!reader_sp)
|
|
return;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
|
|
// Get the current top input reader...
|
|
IOHandlerSP top_reader_sp(m_io_handler_stack.Top());
|
|
|
|
// Don't push the same IO handler twice...
|
|
if (reader_sp == top_reader_sp)
|
|
return;
|
|
|
|
// Push our new input reader
|
|
m_io_handler_stack.Push(reader_sp);
|
|
reader_sp->Activate();
|
|
|
|
// Interrupt the top input reader to it will exit its Run() function and let
|
|
// this new input reader take over
|
|
if (top_reader_sp) {
|
|
top_reader_sp->Deactivate();
|
|
if (cancel_top_handler)
|
|
top_reader_sp->Cancel();
|
|
}
|
|
}
|
|
|
|
bool Debugger::PopIOHandler(const IOHandlerSP &pop_reader_sp) {
|
|
if (!pop_reader_sp)
|
|
return false;
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_io_handler_stack.GetMutex());
|
|
|
|
// The reader on the stop of the stack is done, so let the next read on the
|
|
// stack refresh its prompt and if there is one...
|
|
if (m_io_handler_stack.IsEmpty())
|
|
return false;
|
|
|
|
IOHandlerSP reader_sp(m_io_handler_stack.Top());
|
|
|
|
if (pop_reader_sp != reader_sp)
|
|
return false;
|
|
|
|
reader_sp->Deactivate();
|
|
reader_sp->Cancel();
|
|
m_io_handler_stack.Pop();
|
|
|
|
reader_sp = m_io_handler_stack.Top();
|
|
if (reader_sp)
|
|
reader_sp->Activate();
|
|
|
|
return true;
|
|
}
|
|
|
|
StreamSP Debugger::GetAsyncOutputStream() {
|
|
return std::make_shared<StreamAsynchronousIO>(*this, true);
|
|
}
|
|
|
|
StreamSP Debugger::GetAsyncErrorStream() {
|
|
return std::make_shared<StreamAsynchronousIO>(*this, false);
|
|
}
|
|
|
|
size_t Debugger::GetNumDebuggers() {
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
return g_debugger_list_ptr->size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
lldb::DebuggerSP Debugger::GetDebuggerAtIndex(size_t index) {
|
|
DebuggerSP debugger_sp;
|
|
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
if (index < g_debugger_list_ptr->size())
|
|
debugger_sp = g_debugger_list_ptr->at(index);
|
|
}
|
|
|
|
return debugger_sp;
|
|
}
|
|
|
|
DebuggerSP Debugger::FindDebuggerWithID(lldb::user_id_t id) {
|
|
DebuggerSP debugger_sp;
|
|
|
|
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
|
|
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
|
|
DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
|
|
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
|
|
if ((*pos)->GetID() == id) {
|
|
debugger_sp = *pos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return debugger_sp;
|
|
}
|
|
|
|
bool Debugger::FormatDisassemblerAddress(const FormatEntity::Entry *format,
|
|
const SymbolContext *sc,
|
|
const SymbolContext *prev_sc,
|
|
const ExecutionContext *exe_ctx,
|
|
const Address *addr, Stream &s) {
|
|
FormatEntity::Entry format_entry;
|
|
|
|
if (format == nullptr) {
|
|
if (exe_ctx != nullptr && exe_ctx->HasTargetScope())
|
|
format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
|
|
if (format == nullptr) {
|
|
FormatEntity::Parse("${addr}: ", format_entry);
|
|
format = &format_entry;
|
|
}
|
|
}
|
|
bool function_changed = false;
|
|
bool initial_function = false;
|
|
if (prev_sc && (prev_sc->function || prev_sc->symbol)) {
|
|
if (sc && (sc->function || sc->symbol)) {
|
|
if (prev_sc->symbol && sc->symbol) {
|
|
if (!sc->symbol->Compare(prev_sc->symbol->GetName(),
|
|
prev_sc->symbol->GetType())) {
|
|
function_changed = true;
|
|
}
|
|
} else if (prev_sc->function && sc->function) {
|
|
if (prev_sc->function->GetMangled() != sc->function->GetMangled()) {
|
|
function_changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// The first context on a list of instructions will have a prev_sc that has
|
|
// no Function or Symbol -- if SymbolContext had an IsValid() method, it
|
|
// would return false. But we do get a prev_sc pointer.
|
|
if ((sc && (sc->function || sc->symbol)) && prev_sc &&
|
|
(prev_sc->function == nullptr && prev_sc->symbol == nullptr)) {
|
|
initial_function = true;
|
|
}
|
|
return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr,
|
|
function_changed, initial_function);
|
|
}
|
|
|
|
void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
|
|
void *baton) {
|
|
// For simplicity's sake, I am not going to deal with how to close down any
|
|
// open logging streams, I just redirect everything from here on out to the
|
|
// callback.
|
|
m_log_callback_stream_sp =
|
|
std::make_shared<StreamCallback>(log_callback, baton);
|
|
}
|
|
|
|
bool Debugger::EnableLog(llvm::StringRef channel,
|
|
llvm::ArrayRef<const char *> categories,
|
|
llvm::StringRef log_file, uint32_t log_options,
|
|
llvm::raw_ostream &error_stream) {
|
|
const bool should_close = true;
|
|
const bool unbuffered = true;
|
|
|
|
std::shared_ptr<llvm::raw_ostream> log_stream_sp;
|
|
if (m_log_callback_stream_sp) {
|
|
log_stream_sp = m_log_callback_stream_sp;
|
|
// For now when using the callback mode you always get thread & timestamp.
|
|
log_options |=
|
|
LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
|
|
} else if (log_file.empty()) {
|
|
log_stream_sp = std::make_shared<llvm::raw_fd_ostream>(
|
|
GetOutputFile().GetDescriptor(), !should_close, unbuffered);
|
|
} else {
|
|
auto pos = m_log_streams.find(log_file);
|
|
if (pos != m_log_streams.end())
|
|
log_stream_sp = pos->second.lock();
|
|
if (!log_stream_sp) {
|
|
llvm::sys::fs::OpenFlags flags = llvm::sys::fs::OF_Text;
|
|
if (log_options & LLDB_LOG_OPTION_APPEND)
|
|
flags |= llvm::sys::fs::OF_Append;
|
|
int FD;
|
|
if (std::error_code ec = llvm::sys::fs::openFileForWrite(
|
|
log_file, FD, llvm::sys::fs::CD_CreateAlways, flags)) {
|
|
error_stream << "Unable to open log file: " << ec.message();
|
|
return false;
|
|
}
|
|
log_stream_sp =
|
|
std::make_shared<llvm::raw_fd_ostream>(FD, should_close, unbuffered);
|
|
m_log_streams[log_file] = log_stream_sp;
|
|
}
|
|
}
|
|
assert(log_stream_sp);
|
|
|
|
if (log_options == 0)
|
|
log_options =
|
|
LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
|
|
|
|
return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories,
|
|
error_stream);
|
|
}
|
|
|
|
ScriptInterpreter *
|
|
Debugger::GetScriptInterpreter(bool can_create,
|
|
llvm::Optional<lldb::ScriptLanguage> language) {
|
|
std::lock_guard<std::recursive_mutex> locker(m_script_interpreter_mutex);
|
|
lldb::ScriptLanguage script_language =
|
|
language ? *language : GetScriptLanguage();
|
|
|
|
if (!m_script_interpreters[script_language]) {
|
|
if (!can_create)
|
|
return nullptr;
|
|
m_script_interpreters[script_language] =
|
|
PluginManager::GetScriptInterpreterForLanguage(script_language, *this);
|
|
}
|
|
|
|
return m_script_interpreters[script_language].get();
|
|
}
|
|
|
|
SourceManager &Debugger::GetSourceManager() {
|
|
if (!m_source_manager_up)
|
|
m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());
|
|
return *m_source_manager_up;
|
|
}
|
|
|
|
// This function handles events that were broadcast by the process.
|
|
void Debugger::HandleBreakpointEvent(const EventSP &event_sp) {
|
|
using namespace lldb;
|
|
const uint32_t event_type =
|
|
Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
|
|
event_sp);
|
|
|
|
// if (event_type & eBreakpointEventTypeAdded
|
|
// || event_type & eBreakpointEventTypeRemoved
|
|
// || event_type & eBreakpointEventTypeEnabled
|
|
// || event_type & eBreakpointEventTypeDisabled
|
|
// || event_type & eBreakpointEventTypeCommandChanged
|
|
// || event_type & eBreakpointEventTypeConditionChanged
|
|
// || event_type & eBreakpointEventTypeIgnoreChanged
|
|
// || event_type & eBreakpointEventTypeLocationsResolved)
|
|
// {
|
|
// // Don't do anything about these events, since the breakpoint
|
|
// commands already echo these actions.
|
|
// }
|
|
//
|
|
if (event_type & eBreakpointEventTypeLocationsAdded) {
|
|
uint32_t num_new_locations =
|
|
Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
|
|
event_sp);
|
|
if (num_new_locations > 0) {
|
|
BreakpointSP breakpoint =
|
|
Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp);
|
|
StreamSP output_sp(GetAsyncOutputStream());
|
|
if (output_sp) {
|
|
output_sp->Printf("%d location%s added to breakpoint %d\n",
|
|
num_new_locations, num_new_locations == 1 ? "" : "s",
|
|
breakpoint->GetID());
|
|
output_sp->Flush();
|
|
}
|
|
}
|
|
}
|
|
// else if (event_type & eBreakpointEventTypeLocationsRemoved)
|
|
// {
|
|
// // These locations just get disabled, not sure it is worth spamming
|
|
// folks about this on the command line.
|
|
// }
|
|
// else if (event_type & eBreakpointEventTypeLocationsResolved)
|
|
// {
|
|
// // This might be an interesting thing to note, but I'm going to
|
|
// leave it quiet for now, it just looked noisy.
|
|
// }
|
|
}
|
|
|
|
void Debugger::FlushProcessOutput(Process &process, bool flush_stdout,
|
|
bool flush_stderr) {
|
|
const auto &flush = [&](Stream &stream,
|
|
size_t (Process::*get)(char *, size_t, Status &)) {
|
|
Status error;
|
|
size_t len;
|
|
char buffer[1024];
|
|
while ((len = (process.*get)(buffer, sizeof(buffer), error)) > 0)
|
|
stream.Write(buffer, len);
|
|
stream.Flush();
|
|
};
|
|
|
|
std::lock_guard<std::mutex> guard(m_output_flush_mutex);
|
|
if (flush_stdout)
|
|
flush(*GetAsyncOutputStream(), &Process::GetSTDOUT);
|
|
if (flush_stderr)
|
|
flush(*GetAsyncErrorStream(), &Process::GetSTDERR);
|
|
}
|
|
|
|
// This function handles events that were broadcast by the process.
|
|
void Debugger::HandleProcessEvent(const EventSP &event_sp) {
|
|
using namespace lldb;
|
|
const uint32_t event_type = event_sp->GetType();
|
|
ProcessSP process_sp =
|
|
(event_type == Process::eBroadcastBitStructuredData)
|
|
? EventDataStructuredData::GetProcessFromEvent(event_sp.get())
|
|
: Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
|
|
|
|
StreamSP output_stream_sp = GetAsyncOutputStream();
|
|
StreamSP error_stream_sp = GetAsyncErrorStream();
|
|
const bool gui_enabled = IsForwardingEvents();
|
|
|
|
if (!gui_enabled) {
|
|
bool pop_process_io_handler = false;
|
|
assert(process_sp);
|
|
|
|
bool state_is_stopped = false;
|
|
const bool got_state_changed =
|
|
(event_type & Process::eBroadcastBitStateChanged) != 0;
|
|
const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
|
|
const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
|
|
const bool got_structured_data =
|
|
(event_type & Process::eBroadcastBitStructuredData) != 0;
|
|
|
|
if (got_state_changed) {
|
|
StateType event_state =
|
|
Process::ProcessEventData::GetStateFromEvent(event_sp.get());
|
|
state_is_stopped = StateIsStoppedState(event_state, false);
|
|
}
|
|
|
|
// Display running state changes first before any STDIO
|
|
if (got_state_changed && !state_is_stopped) {
|
|
Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
|
|
pop_process_io_handler);
|
|
}
|
|
|
|
// Now display STDOUT and STDERR
|
|
FlushProcessOutput(*process_sp, got_stdout || got_state_changed,
|
|
got_stderr || got_state_changed);
|
|
|
|
// Give structured data events an opportunity to display.
|
|
if (got_structured_data) {
|
|
StructuredDataPluginSP plugin_sp =
|
|
EventDataStructuredData::GetPluginFromEvent(event_sp.get());
|
|
if (plugin_sp) {
|
|
auto structured_data_sp =
|
|
EventDataStructuredData::GetObjectFromEvent(event_sp.get());
|
|
if (output_stream_sp) {
|
|
StreamString content_stream;
|
|
Status error =
|
|
plugin_sp->GetDescription(structured_data_sp, content_stream);
|
|
if (error.Success()) {
|
|
if (!content_stream.GetString().empty()) {
|
|
// Add newline.
|
|
content_stream.PutChar('\n');
|
|
content_stream.Flush();
|
|
|
|
// Print it.
|
|
output_stream_sp->PutCString(content_stream.GetString());
|
|
}
|
|
} else {
|
|
error_stream_sp->Printf("Failed to print structured "
|
|
"data with plugin %s: %s",
|
|
plugin_sp->GetPluginName().AsCString(),
|
|
error.AsCString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now display any stopped state changes after any STDIO
|
|
if (got_state_changed && state_is_stopped) {
|
|
Process::HandleProcessStateChangedEvent(event_sp, output_stream_sp.get(),
|
|
pop_process_io_handler);
|
|
}
|
|
|
|
output_stream_sp->Flush();
|
|
error_stream_sp->Flush();
|
|
|
|
if (pop_process_io_handler)
|
|
process_sp->PopProcessIOHandler();
|
|
}
|
|
}
|
|
|
|
void Debugger::HandleThreadEvent(const EventSP &event_sp) {
|
|
// At present the only thread event we handle is the Frame Changed event, and
|
|
// all we do for that is just reprint the thread status for that thread.
|
|
using namespace lldb;
|
|
const uint32_t event_type = event_sp->GetType();
|
|
const bool stop_format = true;
|
|
if (event_type == Thread::eBroadcastBitStackChanged ||
|
|
event_type == Thread::eBroadcastBitThreadSelected) {
|
|
ThreadSP thread_sp(
|
|
Thread::ThreadEventData::GetThreadFromEvent(event_sp.get()));
|
|
if (thread_sp) {
|
|
thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1, stop_format);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Debugger::IsForwardingEvents() { return (bool)m_forward_listener_sp; }
|
|
|
|
void Debugger::EnableForwardEvents(const ListenerSP &listener_sp) {
|
|
m_forward_listener_sp = listener_sp;
|
|
}
|
|
|
|
void Debugger::CancelForwardEvents(const ListenerSP &listener_sp) {
|
|
m_forward_listener_sp.reset();
|
|
}
|
|
|
|
void Debugger::DefaultEventHandler() {
|
|
ListenerSP listener_sp(GetListener());
|
|
ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
|
|
ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
|
|
ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
|
|
BroadcastEventSpec target_event_spec(broadcaster_class_target,
|
|
Target::eBroadcastBitBreakpointChanged);
|
|
|
|
BroadcastEventSpec process_event_spec(
|
|
broadcaster_class_process,
|
|
Process::eBroadcastBitStateChanged | Process::eBroadcastBitSTDOUT |
|
|
Process::eBroadcastBitSTDERR | Process::eBroadcastBitStructuredData);
|
|
|
|
BroadcastEventSpec thread_event_spec(broadcaster_class_thread,
|
|
Thread::eBroadcastBitStackChanged |
|
|
Thread::eBroadcastBitThreadSelected);
|
|
|
|
listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
|
|
target_event_spec);
|
|
listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
|
|
process_event_spec);
|
|
listener_sp->StartListeningForEventSpec(m_broadcaster_manager_sp,
|
|
thread_event_spec);
|
|
listener_sp->StartListeningForEvents(
|
|
m_command_interpreter_up.get(),
|
|
CommandInterpreter::eBroadcastBitQuitCommandReceived |
|
|
CommandInterpreter::eBroadcastBitAsynchronousOutputData |
|
|
CommandInterpreter::eBroadcastBitAsynchronousErrorData);
|
|
|
|
// Let the thread that spawned us know that we have started up and that we
|
|
// are now listening to all required events so no events get missed
|
|
m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);
|
|
|
|
bool done = false;
|
|
while (!done) {
|
|
EventSP event_sp;
|
|
if (listener_sp->GetEvent(event_sp, llvm::None)) {
|
|
if (event_sp) {
|
|
Broadcaster *broadcaster = event_sp->GetBroadcaster();
|
|
if (broadcaster) {
|
|
uint32_t event_type = event_sp->GetType();
|
|
ConstString broadcaster_class(broadcaster->GetBroadcasterClass());
|
|
if (broadcaster_class == broadcaster_class_process) {
|
|
HandleProcessEvent(event_sp);
|
|
} else if (broadcaster_class == broadcaster_class_target) {
|
|
if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(
|
|
event_sp.get())) {
|
|
HandleBreakpointEvent(event_sp);
|
|
}
|
|
} else if (broadcaster_class == broadcaster_class_thread) {
|
|
HandleThreadEvent(event_sp);
|
|
} else if (broadcaster == m_command_interpreter_up.get()) {
|
|
if (event_type &
|
|
CommandInterpreter::eBroadcastBitQuitCommandReceived) {
|
|
done = true;
|
|
} else if (event_type &
|
|
CommandInterpreter::eBroadcastBitAsynchronousErrorData) {
|
|
const char *data = static_cast<const char *>(
|
|
EventDataBytes::GetBytesFromEvent(event_sp.get()));
|
|
if (data && data[0]) {
|
|
StreamSP error_sp(GetAsyncErrorStream());
|
|
if (error_sp) {
|
|
error_sp->PutCString(data);
|
|
error_sp->Flush();
|
|
}
|
|
}
|
|
} else if (event_type & CommandInterpreter::
|
|
eBroadcastBitAsynchronousOutputData) {
|
|
const char *data = static_cast<const char *>(
|
|
EventDataBytes::GetBytesFromEvent(event_sp.get()));
|
|
if (data && data[0]) {
|
|
StreamSP output_sp(GetAsyncOutputStream());
|
|
if (output_sp) {
|
|
output_sp->PutCString(data);
|
|
output_sp->Flush();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_forward_listener_sp)
|
|
m_forward_listener_sp->AddEvent(event_sp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
lldb::thread_result_t Debugger::EventHandlerThread(lldb::thread_arg_t arg) {
|
|
((Debugger *)arg)->DefaultEventHandler();
|
|
return {};
|
|
}
|
|
|
|
bool Debugger::StartEventHandlerThread() {
|
|
if (!m_event_handler_thread.IsJoinable()) {
|
|
// We must synchronize with the DefaultEventHandler() thread to ensure it
|
|
// is up and running and listening to events before we return from this
|
|
// function. We do this by listening to events for the
|
|
// eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
|
|
ConstString full_name("lldb.debugger.event-handler");
|
|
ListenerSP listener_sp(Listener::MakeListener(full_name.AsCString()));
|
|
listener_sp->StartListeningForEvents(&m_sync_broadcaster,
|
|
eBroadcastBitEventThreadIsListening);
|
|
|
|
auto thread_name =
|
|
full_name.GetLength() < llvm::get_max_thread_name_length()
|
|
? full_name.AsCString()
|
|
: "dbg.evt-handler";
|
|
|
|
// Use larger 8MB stack for this thread
|
|
llvm::Expected<HostThread> event_handler_thread =
|
|
ThreadLauncher::LaunchThread(thread_name, EventHandlerThread, this,
|
|
g_debugger_event_thread_stack_bytes);
|
|
|
|
if (event_handler_thread) {
|
|
m_event_handler_thread = *event_handler_thread;
|
|
} else {
|
|
LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
|
|
"failed to launch host thread: {}",
|
|
llvm::toString(event_handler_thread.takeError()));
|
|
}
|
|
|
|
// Make sure DefaultEventHandler() is running and listening to events
|
|
// before we return from this function. We are only listening for events of
|
|
// type eBroadcastBitEventThreadIsListening so we don't need to check the
|
|
// event, we just need to wait an infinite amount of time for it (nullptr
|
|
// timeout as the first parameter)
|
|
lldb::EventSP event_sp;
|
|
listener_sp->GetEvent(event_sp, llvm::None);
|
|
}
|
|
return m_event_handler_thread.IsJoinable();
|
|
}
|
|
|
|
void Debugger::StopEventHandlerThread() {
|
|
if (m_event_handler_thread.IsJoinable()) {
|
|
GetCommandInterpreter().BroadcastEvent(
|
|
CommandInterpreter::eBroadcastBitQuitCommandReceived);
|
|
m_event_handler_thread.Join(nullptr);
|
|
}
|
|
}
|
|
|
|
lldb::thread_result_t Debugger::IOHandlerThread(lldb::thread_arg_t arg) {
|
|
Debugger *debugger = (Debugger *)arg;
|
|
debugger->RunIOHandlers();
|
|
debugger->StopEventHandlerThread();
|
|
return {};
|
|
}
|
|
|
|
bool Debugger::HasIOHandlerThread() { return m_io_handler_thread.IsJoinable(); }
|
|
|
|
bool Debugger::StartIOHandlerThread() {
|
|
if (!m_io_handler_thread.IsJoinable()) {
|
|
llvm::Expected<HostThread> io_handler_thread = ThreadLauncher::LaunchThread(
|
|
"lldb.debugger.io-handler", IOHandlerThread, this,
|
|
8 * 1024 * 1024); // Use larger 8MB stack for this thread
|
|
if (io_handler_thread) {
|
|
m_io_handler_thread = *io_handler_thread;
|
|
} else {
|
|
LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST),
|
|
"failed to launch host thread: {}",
|
|
llvm::toString(io_handler_thread.takeError()));
|
|
}
|
|
}
|
|
return m_io_handler_thread.IsJoinable();
|
|
}
|
|
|
|
void Debugger::StopIOHandlerThread() {
|
|
if (m_io_handler_thread.IsJoinable()) {
|
|
GetInputFile().Close();
|
|
m_io_handler_thread.Join(nullptr);
|
|
}
|
|
}
|
|
|
|
void Debugger::JoinIOHandlerThread() {
|
|
if (HasIOHandlerThread()) {
|
|
thread_result_t result;
|
|
m_io_handler_thread.Join(&result);
|
|
m_io_handler_thread = LLDB_INVALID_HOST_THREAD;
|
|
}
|
|
}
|
|
|
|
Target *Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
|
|
Target *target = nullptr;
|
|
if (!prefer_dummy) {
|
|
target = m_target_list.GetSelectedTarget().get();
|
|
if (target)
|
|
return target;
|
|
}
|
|
|
|
return GetDummyTarget();
|
|
}
|
|
|
|
Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
|
|
Status err;
|
|
FileSpec repl_executable;
|
|
|
|
if (language == eLanguageTypeUnknown) {
|
|
LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
|
|
|
|
if (auto single_lang = repl_languages.GetSingularLanguage()) {
|
|
language = *single_lang;
|
|
} else if (repl_languages.Empty()) {
|
|
err.SetErrorStringWithFormat(
|
|
"LLDB isn't configured with REPL support for any languages.");
|
|
return err;
|
|
} else {
|
|
err.SetErrorStringWithFormat(
|
|
"Multiple possible REPL languages. Please specify a language.");
|
|
return err;
|
|
}
|
|
}
|
|
|
|
Target *const target =
|
|
nullptr; // passing in an empty target means the REPL must create one
|
|
|
|
REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options));
|
|
|
|
if (!err.Success()) {
|
|
return err;
|
|
}
|
|
|
|
if (!repl_sp) {
|
|
err.SetErrorStringWithFormat("couldn't find a REPL for %s",
|
|
Language::GetNameForLanguageType(language));
|
|
return err;
|
|
}
|
|
|
|
repl_sp->SetCompilerOptions(repl_options);
|
|
repl_sp->RunLoop();
|
|
|
|
return err;
|
|
}
|