62#include "llvm/ADT/STLExtras.h"
63#include "llvm/ADT/StringRef.h"
64#include "llvm/ADT/iterator.h"
65#include "llvm/Support/DynamicLibrary.h"
66#include "llvm/Support/FileSystem.h"
67#include "llvm/Support/Process.h"
68#include "llvm/Support/ThreadPool.h"
69#include "llvm/Support/Threading.h"
70#include "llvm/Support/raw_ostream.h"
81#include <system_error>
101#pragma mark Static Functions
113 "Never show disassembly when displaying a stop context.",
118 "Show disassembly when there is no debug information.",
123 "Show disassembly when there is no source information, or the source "
125 "is missing when displaying a stop context.",
130 "Always show disassembly when displaying a stop context.",
138 "Disable scripting languages.",
143 "Select python as the default scripting language.",
148 "Select the lldb default as the default scripting language.",
154 "Use no verbosity when running dwim-print."},
156 "Use partial verbosity when running dwim-print - display a message when "
157 "`expression` evaluation is used."},
159 "Use full verbosity when running dwim-print."},
166 "Highlight the stop column with ANSI terminal codes when color/ANSI "
167 "mode is enabled; otherwise, fall back to using a text-only caret (^) "
168 "as if \"caret-only\" mode was selected.",
173 "Highlight the stop column with ANSI terminal codes when running LLDB "
174 "with color/ANSI enabled.",
179 "Highlight the stop column with a caret character (^) underneath the "
180 "stop column. This method introduces a new line in source listings "
181 "that display thread stop locations.",
186 "Do not highlight the stop column.",
190#define LLDB_PROPERTIES_debugger
191#include "CoreProperties.inc"
194#define LLDB_PROPERTIES_debugger
195#include "CorePropertiesEnum.inc"
202 llvm::StringRef property_path,
203 llvm::StringRef value) {
204 bool is_load_script =
205 (property_path ==
"target.load-script-from-symbol-file");
207 bool invalidate_data_vis = (property_path ==
"escape-non-printables");
208 invalidate_data_vis |=
209 (property_path ==
"target.max-zero-padding-in-float-format");
210 if (invalidate_data_vis) {
216 if (is_load_script && exe_ctx && exe_ctx->
GetTargetSP()) {
218 load_script_old_value =
219 target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
222 if (
error.Success()) {
224 if (property_path == g_debugger_properties[ePropertyPrompt].name) {
225 llvm::StringRef new_prompt =
GetPrompt();
231 auto bytes = std::make_unique<EventDataBytes>(new_prompt);
232 auto prompt_change_event_sp = std::make_shared<Event>(
235 }
else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
239 }
else if (property_path ==
240 g_debugger_properties[ePropertyPromptAnsiPrefix].name ||
242 g_debugger_properties[ePropertyPromptAnsiSuffix].name) {
246 }
else if (property_path ==
247 g_debugger_properties[ePropertyUseSourceCache].name) {
253 }
else if (is_load_script && target_sp &&
255 if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
257 std::list<Status> errors;
259 if (!target_sp->LoadScriptingResources(errors, feedback_stream)) {
261 for (
auto error : errors) {
274 constexpr uint32_t idx = ePropertyAutoConfirm;
275 return GetPropertyAtIndexAs<bool>(
276 idx, g_debugger_properties[idx].default_uint_value != 0);
280 constexpr uint32_t idx = ePropertyDisassemblyFormat;
281 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
285 constexpr uint32_t idx = ePropertyFrameFormat;
286 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
290 constexpr uint32_t idx = ePropertyFrameFormatUnique;
291 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
295 constexpr uint32_t idx = ePropertyStopDisassemblyMaxSize;
296 return GetPropertyAtIndexAs<uint64_t>(
297 idx, g_debugger_properties[idx].default_uint_value);
301 constexpr uint32_t idx = ePropertyNotiftVoid;
302 return GetPropertyAtIndexAs<uint64_t>(
303 idx, g_debugger_properties[idx].default_uint_value != 0);
307 constexpr uint32_t idx = ePropertyPrompt;
308 return GetPropertyAtIndexAs<llvm::StringRef>(
309 idx, g_debugger_properties[idx].default_cstr_value);
313 const uint32_t idx = ePropertyPromptAnsiPrefix;
314 return GetPropertyAtIndexAs<llvm::StringRef>(
315 idx, g_debugger_properties[idx].default_cstr_value);
319 const uint32_t idx = ePropertyPromptAnsiSuffix;
320 return GetPropertyAtIndexAs<llvm::StringRef>(
321 idx, g_debugger_properties[idx].default_cstr_value);
325 constexpr uint32_t idx = ePropertyPrompt;
327 llvm::StringRef new_prompt =
GetPrompt();
336 constexpr uint32_t idx = ePropertyThreadFormat;
337 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
341 constexpr uint32_t idx = ePropertyThreadStopFormat;
342 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
346 const uint32_t idx = ePropertyScriptLanguage;
347 return GetPropertyAtIndexAs<lldb::ScriptLanguage>(
349 g_debugger_properties[idx].default_uint_value));
353 const uint32_t idx = ePropertyScriptLanguage;
358 const uint32_t idx = ePropertyREPLLanguage;
359 return GetPropertyAtIndexAs<LanguageType>(idx, {});
363 const uint32_t idx = ePropertyREPLLanguage;
368 const uint32_t idx = ePropertyTerminalWidth;
369 return GetPropertyAtIndexAs<uint64_t>(
370 idx, g_debugger_properties[idx].default_uint_value);
375 handler_sp->TerminalSizeChanged();
377 const uint32_t idx = ePropertyTerminalWidth;
382 const uint32_t idx = ePropertyUseExternalEditor;
383 return GetPropertyAtIndexAs<bool>(
384 idx, g_debugger_properties[idx].default_uint_value != 0);
388 const uint32_t idx = ePropertyUseExternalEditor;
393 const uint32_t idx = ePropertyExternalEditor;
394 return GetPropertyAtIndexAs<llvm::StringRef>(
395 idx, g_debugger_properties[idx].default_cstr_value);
399 const uint32_t idx = ePropertyExternalEditor;
404 const uint32_t idx = ePropertyUseColor;
405 return GetPropertyAtIndexAs<bool>(
406 idx, g_debugger_properties[idx].default_uint_value != 0);
410 const uint32_t idx = ePropertyUseColor;
417 const uint32_t idx = ePropertyShowProgress;
418 return GetPropertyAtIndexAs<bool>(
419 idx, g_debugger_properties[idx].default_uint_value != 0);
423 const uint32_t idx = ePropertyShowProgress;
428 const uint32_t idx = ePropertyShowProgressAnsiPrefix;
429 return GetPropertyAtIndexAs<llvm::StringRef>(
430 idx, g_debugger_properties[idx].default_cstr_value);
434 const uint32_t idx = ePropertyShowProgressAnsiSuffix;
435 return GetPropertyAtIndexAs<llvm::StringRef>(
436 idx, g_debugger_properties[idx].default_cstr_value);
440 const uint32_t idx = ePropertyShowAutosuggestion;
441 return GetPropertyAtIndexAs<bool>(
442 idx, g_debugger_properties[idx].default_uint_value != 0);
446 const uint32_t idx = ePropertyShowAutosuggestionAnsiPrefix;
447 return GetPropertyAtIndexAs<llvm::StringRef>(
448 idx, g_debugger_properties[idx].default_cstr_value);
452 const uint32_t idx = ePropertyShowAutosuggestionAnsiSuffix;
453 return GetPropertyAtIndexAs<llvm::StringRef>(
454 idx, g_debugger_properties[idx].default_cstr_value);
458 const uint32_t idx = ePropertyShowRegexMatchAnsiPrefix;
459 return GetPropertyAtIndexAs<llvm::StringRef>(
460 idx, g_debugger_properties[idx].default_cstr_value);
464 const uint32_t idx = ePropertyShowRegexMatchAnsiSuffix;
465 return GetPropertyAtIndexAs<llvm::StringRef>(
466 idx, g_debugger_properties[idx].default_cstr_value);
470 const uint32_t idx = ePropertyShowDontUsePoHint;
471 return GetPropertyAtIndexAs<bool>(
472 idx, g_debugger_properties[idx].default_uint_value != 0);
476 const uint32_t idx = ePropertyUseSourceCache;
477 return GetPropertyAtIndexAs<bool>(
478 idx, g_debugger_properties[idx].default_uint_value != 0);
482 const uint32_t idx = ePropertyUseSourceCache;
490 const uint32_t idx = ePropertyHighlightSource;
491 return GetPropertyAtIndexAs<bool>(
492 idx, g_debugger_properties[idx].default_uint_value != 0);
496 const uint32_t idx = ePropertyStopShowColumn;
497 return GetPropertyAtIndexAs<lldb::StopShowColumn>(
499 g_debugger_properties[idx].default_uint_value));
503 const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
504 return GetPropertyAtIndexAs<llvm::StringRef>(
505 idx, g_debugger_properties[idx].default_cstr_value);
509 const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
510 return GetPropertyAtIndexAs<llvm::StringRef>(
511 idx, g_debugger_properties[idx].default_cstr_value);
515 const uint32_t idx = ePropertyStopShowLineMarkerAnsiPrefix;
516 return GetPropertyAtIndexAs<llvm::StringRef>(
517 idx, g_debugger_properties[idx].default_cstr_value);
521 const uint32_t idx = ePropertyStopShowLineMarkerAnsiSuffix;
522 return GetPropertyAtIndexAs<llvm::StringRef>(
523 idx, g_debugger_properties[idx].default_cstr_value);
528 before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
529 return GetPropertyAtIndexAs<uint64_t>(
530 idx, g_debugger_properties[idx].default_uint_value);
534 const uint32_t idx = ePropertyStopDisassemblyDisplay;
535 return GetPropertyAtIndexAs<Debugger::StopDisassemblyType>(
537 g_debugger_properties[idx].default_uint_value));
541 const uint32_t idx = ePropertyStopDisassemblyCount;
542 return GetPropertyAtIndexAs<uint64_t>(
543 idx, g_debugger_properties[idx].default_uint_value);
547 const uint32_t idx = ePropertyAutoOneLineSummaries;
548 return GetPropertyAtIndexAs<bool>(
549 idx, g_debugger_properties[idx].default_uint_value != 0);
553 const uint32_t idx = ePropertyEscapeNonPrintables;
554 return GetPropertyAtIndexAs<bool>(
555 idx, g_debugger_properties[idx].default_uint_value != 0);
559 const uint32_t idx = ePropertyAutoIndent;
560 return GetPropertyAtIndexAs<bool>(
561 idx, g_debugger_properties[idx].default_uint_value != 0);
565 const uint32_t idx = ePropertyAutoIndent;
570 const uint32_t idx = ePropertyPrintDecls;
571 return GetPropertyAtIndexAs<bool>(
572 idx, g_debugger_properties[idx].default_uint_value != 0);
576 const uint32_t idx = ePropertyPrintDecls;
581 const uint32_t idx = ePropertyTabSize;
582 return GetPropertyAtIndexAs<uint64_t>(
583 idx, g_debugger_properties[idx].default_uint_value);
587 const uint32_t idx = ePropertyTabSize;
592 const uint32_t idx = ePropertyDWIMPrintVerbosity;
593 return GetPropertyAtIndexAs<lldb::DWIMPrintVerbosity>(
595 g_debugger_properties[idx].default_uint_value));
609 "Debugger::Initialize called more than once!");
612 g_thread_pool =
new llvm::DefaultThreadPool(llvm::optimal_concurrency());
618 "Debugger::Terminate called without a matching Debugger::Initialize!");
623 debugger->HandleDestroyCallback();
648 llvm::sys::DynamicLibrary dynlib =
650 if (dynlib.isValid()) {
658 error.SetErrorString(
"Public API layer is not available");
665 llvm::StringRef path) {
668 static constexpr llvm::StringLiteral g_dylibext(
".dylib");
669 static constexpr llvm::StringLiteral g_solibext(
".so");
676 namespace fs = llvm::sys::fs;
681 if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
682 ft == fs::file_type::type_unknown) {
692 debugger->
LoadPlugin(plugin_file_spec, plugin_load_error);
695 }
else if (ft == fs::file_type::directory_file ||
696 ft == fs::file_type::symlink_file ||
697 ft == fs::file_type::type_unknown) {
709 const bool find_directories =
true;
710 const bool find_files =
true;
711 const bool find_other =
true;
713 if (
FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
715 dir_spec.GetPath(dir_path,
sizeof(dir_path))) {
717 find_files, find_other,
722 if (
FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
724 dir_spec.GetPath(dir_path,
sizeof(dir_path))) {
726 find_files, find_other,
741 debugger_sp->InstanceInitialize();
756 debugger_sp->HandleDestroyCallback();
763 (*debugger_sp->GetAsyncOutputStream()) << result.
GetOutputData() <<
'\n';
765 (*debugger_sp->GetAsyncErrorStream()) << result.
GetErrorData() <<
'\n';
768 debugger_sp->Clear();
774 if ((*pos).get() == debugger_sp.get()) {
792 if (llvm::StringRef(debugger_sp->GetInstanceName()) == instance_name)
804 target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
818 target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
827 static constexpr llvm::StringLiteral class_name(
"lldb.debugger");
834 m_input_file_sp(std::make_shared<
NativeFile>(stdin, false)),
835 m_output_stream_sp(std::make_shared<
StreamFile>(stdout, false)),
836 m_error_stream_sp(std::make_shared<
StreamFile>(stderr, false)),
837 m_input_recorder(nullptr),
839 m_terminal_state(), m_target_list(*this), m_platform_list(),
840 m_listener_sp(
Listener::MakeListener(
"lldb.Debugger")),
841 m_source_manager_up(), m_source_file_cache(),
842 m_command_interpreter_up(
844 m_io_handler_stack(),
845 m_instance_name(
llvm::formatv(
"debugger_{0}", GetID()).str()),
846 m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
847 m_sync_broadcaster(nullptr,
"lldb.debugger.sync"),
848 m_broadcaster(m_broadcaster_manager_sp,
849 GetStaticBroadcasterClass().str()),
850 m_forward_listener_sp(), m_clear_once() {
855 "target",
"Settings specify to debugging targets.",
true,
858 "platform",
"Platform settings.",
true,
861 "symbols",
"Symbol lookup and cache settings.",
true,
869 "Settings specify to the debugger's command interpreter.",
true,
874 std::make_shared<CallbackLogHandler>(log_callback, baton);
878 assert(default_platform_sp);
885 arch = HostInfo::GetArchitecture();
886 assert(arch.
IsValid() &&
"No valid default or host archspec");
887 const bool is_dummy_target =
true;
889 new Target(*
this, arch, default_platform_sp, is_dummy_target));
895 ePropertyTerminalWidth);
900 const char *term = getenv(
"TERM");
901 if (term && !strcmp(term,
"dumb"))
909 [
this](
const FileSpec &dir) -> llvm::Error {
911 llvm::StringRef log_path = entry.first();
912 llvm::StringRef file_name = llvm::sys::path::filename(log_path);
915 llvm::sys::fs::copy_file(log_path, destination.
GetPath());
917 return llvm::errorCodeToError(ec);
919 return llvm::Error::success();
923#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
926 llvm::sys::Process::UseANSIEscapeCodes(
true);
948 if (
ProcessSP process_sp = target_sp->GetProcessSP())
949 process_sp->Finalize(
false );
950 target_sp->Destroy();
977static inline int OpenPipe(
int fds[2], std::size_t size) {
979 return _pipe(fds, size, O_BINARY);
989 int fds[2] = {-1, -1};
991 if (data ==
nullptr) {
996 size_t size = strlen(data);
1004 "can't create pipe file descriptors for LLDB commands");
1008 int r = write(fds[
WRITE], data, size);
1012 llvm::sys::Process::SafelyCloseFileDescriptor(fds[
WRITE]);
1016 FILE *commands_file = fdopen(fds[
READ],
"rb");
1017 if (commands_file ==
nullptr) {
1019 "when trying to open LLDB commands pipe",
1021 llvm::sys::Process::SafelyCloseFileDescriptor(fds[
READ]);
1030 assert(file_sp && file_sp->IsValid());
1038 assert(file_sp && file_sp->IsValid());
1043 assert(file_sp && file_sp->IsValid());
1056 bool adopt_selected =
true;
1065 reader_sp->Interrupt();
1072 reader_sp->GotEOF();
1094 std::lock_guard<std::recursive_mutex> guard(
1100 if (top_reader_sp && top_reader_sp->GetIsDone())
1117 while (top_reader_sp) {
1118 top_reader_sp->Run();
1121 if (top_reader_sp.get() == reader_sp.get()) {
1130 if (top_reader_sp && top_reader_sp->GetIsDone()) {
1133 if (top_reader_sp.get() == reader_sp.get())
1156 stream->Write(s, len);
1177 bool cancel_top_handler) {
1191 if (!in || !in->IsValid()) {
1193 in = top_reader_sp->GetInputFileSP();
1198 in = std::make_shared<NativeFile>(stdin,
false);
1201 if (!out || !out->GetFile().IsValid()) {
1203 out = top_reader_sp->GetOutputStreamFileSP();
1208 out = std::make_shared<StreamFile>(stdout,
false);
1211 if (!err || !err->GetFile().IsValid()) {
1213 err = top_reader_sp->GetErrorStreamFileSP();
1218 err = std::make_shared<StreamFile>(stderr,
false);
1223 bool cancel_top_handler) {
1233 if (reader_sp == top_reader_sp)
1238 reader_sp->Activate();
1242 if (top_reader_sp) {
1243 top_reader_sp->Deactivate();
1244 if (cancel_top_handler)
1245 top_reader_sp->Cancel();
1262 if (pop_reader_sp != reader_sp)
1265 reader_sp->Deactivate();
1266 reader_sp->Cancel();
1271 reader_sp->Activate();
1277 return std::make_shared<StreamAsynchronousIO>(*
this,
true,
GetUseColor());
1281 return std::make_shared<StreamAsynchronousIO>(*
this,
false,
GetUseColor());
1308 std::string function_name,
const llvm::formatv_object_base &payload)
1309 : m_function_name(std::move(function_name)),
1310 m_interrupt_time(std::chrono::system_clock::now()),
1311 m_thread_id(
llvm::get_threadid()) {
1313 desc << payload <<
"\n";
1327 if (debugger_sp->InterruptRequested())
1328 result.push_back(debugger_sp);
1347 if (index < g_debugger_list_ptr->size())
1361 if ((*pos)->GetID() ==
id) {
1377 if (format ==
nullptr) {
1380 if (format ==
nullptr) {
1382 format = &format_entry;
1385 bool function_changed =
false;
1386 bool initial_function =
false;
1392 function_changed =
true;
1396 function_changed =
true;
1406 initial_function =
true;
1409 function_changed, initial_function);
1413 llvm::StringRef backtrace,
1414 llvm::StringRef prompt) {
1416 llvm::formatv(
"{0}\n{1}{2}", message, backtrace, prompt).str());
1425 std::make_shared<CallbackLogHandler>(log_callback, baton);
1435 std::string title, std::string details,
1436 uint64_t completed, uint64_t total,
1437 bool is_debugger_specific,
1438 uint32_t progress_broadcast_bit) {
1444 progress_broadcast_bit,
1446 completed, total, is_debugger_specific)));
1451 std::string details, uint64_t completed,
1453 std::optional<lldb::user_id_t> debugger_id,
1454 uint32_t progress_category_bit) {
1462 std::move(details), completed, total,
1464 progress_category_bit);
1475 progress_category_bit);
1481 std::string message,
1482 bool debugger_specific) {
1483 uint32_t event_type = 0;
1486 assert(
false &&
"DiagnosticEventData::Type::Info should not be broadcast");
1502 event_data.
Dump(stream.get());
1505 EventSP event_sp = std::make_shared<Event>(
1512 std::string message,
1513 std::optional<lldb::user_id_t> debugger_id,
1514 std::once_flag *once) {
1515 auto ReportDiagnosticLambda = [&]() {
1544 std::call_once(*once, ReportDiagnosticLambda);
1546 ReportDiagnosticLambda();
1550 std::optional<lldb::user_id_t> debugger_id,
1551 std::once_flag *once) {
1557 std::optional<lldb::user_id_t> debugger_id,
1558 std::once_flag *once) {
1564 std::optional<lldb::user_id_t> debugger_id,
1565 std::once_flag *once) {
1574 EventSP event_sp = std::make_shared<Event>(
1577 debugger_sp->GetBroadcaster().BroadcastEvent(event_sp);
1582static std::shared_ptr<LogHandler>
1584 size_t buffer_size) {
1585 switch (log_handler_kind) {
1587 return std::make_shared<StreamLogHandler>(fd, should_close, buffer_size);
1589 return std::make_shared<RotatingLogHandler>(buffer_size);
1591 return std::make_shared<SystemLogHandler>();
1599 llvm::ArrayRef<const char *> categories,
1600 llvm::StringRef log_file, uint32_t log_options,
1602 llvm::raw_ostream &error_stream) {
1604 std::shared_ptr<LogHandler> log_handler_sp;
1610 }
else if (log_file.empty()) {
1613 false, buffer_size);
1617 log_handler_sp = pos->second.lock();
1618 if (!log_handler_sp) {
1626 FileSpec(log_file), flags, lldb::eFilePermissionsFileDefault,
false);
1628 error_stream <<
"Unable to open log file '" << log_file
1629 <<
"': " << llvm::toString(file.takeError()) <<
"\n";
1639 assert(log_handler_sp);
1641 if (log_options == 0)
1650 std::optional<lldb::ScriptLanguage> language) {
1673 using namespace lldb;
1674 const uint32_t event_type =
1691 if (event_type & eBreakpointEventTypeLocationsAdded) {
1692 uint32_t num_new_locations =
1695 if (num_new_locations > 0) {
1700 output_sp->Printf(
"%d location%s added to breakpoint %d\n",
1701 num_new_locations, num_new_locations == 1 ?
"" :
"s",
1702 breakpoint->GetID());
1720 bool flush_stderr) {
1721 const auto &flush = [&](
Stream &stream,
1726 while ((len = (process.*get)(buffer,
sizeof(buffer),
error)) > 0)
1727 stream.
Write(buffer, len);
1740 using namespace lldb;
1741 const uint32_t event_type = event_sp->GetType();
1752 bool pop_process_io_handler =
false;
1755 bool state_is_stopped =
false;
1756 const bool got_state_changed =
1760 const bool got_structured_data =
1763 if (got_state_changed) {
1770 if (got_state_changed && !state_is_stopped) {
1775 pop_process_io_handler);
1780 got_stderr || got_state_changed);
1783 if (got_structured_data) {
1787 auto structured_data_sp =
1789 if (output_stream_sp) {
1792 plugin_sp->GetDescription(structured_data_sp, content_stream);
1793 if (
error.Success()) {
1794 if (!content_stream.
GetString().empty()) {
1797 content_stream.
Flush();
1800 output_stream_sp->PutCString(content_stream.
GetString());
1803 error_stream_sp->Format(
"Failed to print structured "
1804 "data with plugin {0}: {1}",
1805 plugin_sp->GetPluginName(),
error);
1812 if (got_state_changed && state_is_stopped) {
1815 pop_process_io_handler);
1818 output_stream_sp->Flush();
1819 error_stream_sp->Flush();
1821 if (pop_process_io_handler)
1822 process_sp->PopProcessIOHandler();
1829 using namespace lldb;
1830 const uint32_t event_type = event_sp->GetType();
1831 const bool stop_format =
true;
1861 broadcaster_class_process,
1872 process_event_spec);
1875 listener_sp->StartListeningForEvents(
1881 listener_sp->StartListeningForEvents(
1892 if (listener_sp->GetEvent(event_sp, std::nullopt)) {
1894 Broadcaster *broadcaster = event_sp->GetBroadcaster();
1896 uint32_t event_type = event_sp->GetType();
1898 if (broadcaster_class == broadcaster_class_process) {
1900 }
else if (broadcaster_class == broadcaster_class_target) {
1905 }
else if (broadcaster_class == broadcaster_class_thread) {
1911 }
else if (event_type &
1913 const char *data =
static_cast<const char *
>(
1915 if (data && data[0]) {
1918 error_sp->PutCString(data);
1923 eBroadcastBitAsynchronousOutputData) {
1924 const char *data =
static_cast<const char *
>(
1926 if (data && data[0]) {
1929 output_sp->PutCString(data);
1958 ConstString full_name(
"lldb.debugger.event-handler");
1963 llvm::StringRef thread_name =
1964 full_name.
GetLength() < llvm::get_max_thread_name_length()
1966 :
"dbg.evt-handler";
1969 llvm::Expected<HostThread> event_handler_thread =
1974 if (event_handler_thread) {
1978 "failed to launch host thread: {0}");
1987 listener_sp->GetEvent(event_sp, std::nullopt);
2013 const uint64_t
id = data->GetID();
2019 <<
static_cast<void *
>(
this) <<
" Debugger(" <<
GetID()
2020 <<
")::HandleProgressEvent( m_current_event_id = "
2022 data->Dump(&log_stream);
2023 log_stream <<
" } )";
2028 if (data->GetCompleted() == data->GetTotal())
2049 output->Printf(
"\r");
2051 if (data->GetCompleted() == data->GetTotal()) {
2053 output->Printf(
"\x1B[2K");
2059 std::string message = data->GetMessage();
2060 if (data->IsFinite())
2061 message = llvm::formatv(
"[{0}/{1}] {2}", data->GetCompleted(),
2062 data->GetTotal(), message)
2067 const uint32_t ellipsis = 3;
2068 if (message.size() + ellipsis >= term_width)
2069 message = message.substr(0, term_width - ellipsis);
2073 if (!ansi_prefix.empty())
2077 output->Printf(
"%s...", message.c_str());
2080 if (!ansi_suffix.empty())
2085 output->Printf(
"\x1B[K\r");
2097 data->Dump(stream.get());
2115 if (io_handler_thread) {
2119 "failed to launch host thread: {0}");
2147 if (!prefer_dummy) {
2165 language = *single_lang;
2166 }
else if (repl_languages.
Empty()) {
2168 "LLDB isn't configured with REPL support for any languages.");
2172 "Multiple possible REPL languages. Please specify a language.");
2192 repl_sp->SetCompilerOptions(repl_options);
2200 "Debugger::GetThreadPool called before Debugger::Initialize");
static llvm::raw_ostream & error(Stream &strm)
static void PrivateReportDiagnostic(Debugger &debugger, DiagnosticEventData::Type type, std::string message, bool debugger_specific)
static std::recursive_mutex * g_debugger_list_mutex_ptr
static llvm::DefaultThreadPool * g_thread_pool
static constexpr OptionEnumValueElement g_show_disassembly_enum_values[]
static lldb::user_id_t g_unique_id
static constexpr OptionEnumValueElement g_language_enumerators[]
static constexpr OptionEnumValueElement g_dwim_print_verbosities[]
static constexpr OptionEnumValueElement s_stop_show_column_values[]
static void PrivateReportProgress(Debugger &debugger, uint64_t progress_id, std::string title, std::string details, uint64_t completed, uint64_t total, bool is_debugger_specific, uint32_t progress_broadcast_bit)
static Debugger::DebuggerList * g_debugger_list_ptr
static int OpenPipe(int fds[2], std::size_t size)
static size_t g_debugger_event_thread_stack_bytes
static FileSystem::EnumerateDirectoryResult LoadPluginCallback(void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path)
static std::shared_ptr< LogHandler > CreateLogHandler(LogHandlerKind log_handler_kind, int fd, bool should_close, size_t buffer_size)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOG_OPTION_APPEND
#define LLDB_LOG_ERROR(log, error,...)
#define LLDB_LOG_OPTION_PREPEND_TIMESTAMP
#define LLDB_LOG_OPTION_PREPEND_THREAD_NAME
A section + offset based address class.
An architecture specification class.
bool IsValid() const
Tests if this ArchSpec is valid.
static lldb::BreakpointEventType GetBreakpointEventTypeFromEvent(const lldb::EventSP &event_sp)
static lldb::BreakpointSP GetBreakpointFromEvent(const lldb::EventSP &event_sp)
static const BreakpointEventData * GetEventDataFromEvent(const Event *event_sp)
static size_t GetNumBreakpointLocationsFromEvent(const lldb::EventSP &event_sp)
An event broadcasting class.
bool EventTypeHasListeners(uint32_t event_type)
virtual llvm::StringRef GetBroadcasterClass() const
This needs to be filled in if you are going to register the broadcaster with the broadcaster manager ...
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
void UpdatePrompt(llvm::StringRef prompt)
bool WasInterrupted() const
bool SaveTranscript(CommandReturnObject &result, std::optional< std::string > output_file=std::nullopt)
Save the current debugger session transcript to a file on disk.
@ eBroadcastBitAsynchronousOutputData
@ eBroadcastBitQuitCommandReceived
@ eBroadcastBitAsynchronousErrorData
@ eBroadcastBitResetPrompt
bool GetSaveSessionOnQuit() const
llvm::StringRef GetErrorData()
llvm::StringRef GetOutputData()
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
size_t GetLength() const
Get the length in bytes of string value.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
static void ForceUpdate()
InterruptionReport(std::string function_name, std::string description)
std::string m_description
A class to manage flag bits.
static void AssertCallback(llvm::StringRef message, llvm::StringRef backtrace, llvm::StringRef prompt)
llvm::StringRef GetAutosuggestionAnsiPrefix() const
repro::DataRecorder * GetInputRecorder()
lldb::StreamFileSP m_error_stream_sp
bool SetUseExternalEditor(bool use_external_editor_p)
PlatformList m_platform_list
HostThread m_event_handler_thread
static lldb::TargetSP FindTargetWithProcessID(lldb::pid_t pid)
uint64_t GetDisassemblyLineCount() const
lldb::TargetSP GetSelectedTarget()
bool SetExternalEditor(llvm::StringRef editor)
void RequestInterrupt()
Interruption in LLDB:
void ReportInterruption(const InterruptionReport &report)
ExecutionContext GetSelectedExecutionContext()
void HandleProgressEvent(const lldb::EventSP &event_sp)
SourceManager & GetSourceManager()
bool SetShowProgress(bool show_progress)
static void ReportProgress(uint64_t progress_id, std::string title, std::string details, uint64_t completed, uint64_t total, std::optional< lldb::user_id_t > debugger_id, uint32_t progress_category_bit=eBroadcastBitProgress)
Report progress events.
lldb::StreamSP GetAsyncOutputStream()
bool StartEventHandlerThread()
Manually start the global event handler thread.
bool SetUseSourceCache(bool use_source_cache)
void StopEventHandlerThread()
Manually stop the debugger's default event handler.
static void ReportInfo(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report info events.
void SetAsyncExecution(bool async)
HostThread SetIOHandlerThread(HostThread &new_thread)
void CancelForwardEvents(const lldb::ListenerSP &listener_sp)
bool GetPrintDecls() const
lldb::FileSP GetInputFileSP()
void StopIOHandlerThread()
bool GetHighlightSource() const
llvm::StringMap< std::weak_ptr< LogHandler > > m_stream_handlers
CommandInterpreter & GetCommandInterpreter()
void SaveInputTerminalState()
LoadedPluginsList m_loaded_plugins
void InstanceInitialize()
bool SetTabSize(uint64_t tab_size)
void HandleDiagnosticEvent(const lldb::EventSP &event_sp)
bool StartIOHandlerThread()
static lldb::DebuggerSP GetDebuggerAtIndex(size_t index)
llvm::StringRef GetAutosuggestionAnsiSuffix() const
StreamFile & GetErrorStream()
lldb::ListenerSP m_listener_sp
void PushIOHandler(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
lldb::thread_result_t IOHandlerThread()
static lldb::TargetSP FindTargetWithProcess(Process *process)
bool GetUseExternalEditor() const
TerminalState m_terminal_state
static void ReportDiagnosticImpl(DiagnosticEventData::Type type, std::string message, std::optional< lldb::user_id_t > debugger_id, std::once_flag *once)
const FormatEntity::Entry * GetThreadStopFormat() const
bool InterruptRequested()
bool GetEscapeNonPrintables() const
lldb::TargetSP m_dummy_target_sp
std::unique_ptr< CommandInterpreter > m_command_interpreter_up
static void ReportWarning(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report warning events.
static bool FormatDisassemblerAddress(const FormatEntity::Entry *format, const SymbolContext *sc, const SymbolContext *prev_sc, const ExecutionContext *exe_ctx, const Address *addr, Stream &s)
static void SettingsInitialize()
static llvm::ThreadPoolInterface & GetThreadPool()
Shared thread pool. Use only with ThreadPoolTaskGroup.
llvm::StringRef GetShowProgressAnsiSuffix() const
bool IsTopIOHandler(const lldb::IOHandlerSP &reader_sp)
bool HasIOHandlerThread() const
void DispatchInputEndOfFile()
bool IsIOHandlerThreadCurrentThread() const
lldb::ListenerSP m_forward_listener_sp
std::array< lldb::ScriptInterpreterSP, lldb::eScriptLanguageUnknown > m_script_interpreters
std::shared_ptr< CallbackLogHandler > m_callback_handler_sp
void SetDestroyCallback(lldb_private::DebuggerDestroyCallback destroy_callback, void *baton)
void * m_destroy_callback_baton
StopDisassemblyType GetStopDisassemblyDisplay() const
Broadcaster m_broadcaster
Public Debugger event broadcaster.
void DispatchInputInterrupt()
static void Initialize(LoadPluginCallbackType load_plugin_callback)
static lldb::DebuggerSP FindDebuggerWithInstanceName(llvm::StringRef instance_name)
uint64_t GetTerminalWidth() const
std::mutex m_interrupt_mutex
std::recursive_mutex m_io_handler_synchronous_mutex
bool RemoveIOHandler(const lldb::IOHandlerSP &reader_sp)
Remove the given IO handler if it's currently active.
Diagnostics::CallbackID m_diagnostics_callback_id
bool GetAutoOneLineSummaries() const
const char * GetIOHandlerCommandPrefix()
lldb::BroadcasterManagerSP m_broadcaster_manager_sp
Status RunREPL(lldb::LanguageType language, const char *repl_options)
bool PopIOHandler(const lldb::IOHandlerSP &reader_sp)
static LoadPluginCallbackType g_load_plugin_callback
std::recursive_mutex m_script_interpreter_mutex
void RunIOHandlerAsync(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler=true)
Run the given IO handler and return immediately.
void SetInputFile(lldb::FileSP file)
lldb::StreamFileSP GetErrorStreamSP()
void SetPrompt(llvm::StringRef p)
lldb::StreamSP GetAsyncErrorStream()
bool EnableLog(llvm::StringRef channel, llvm::ArrayRef< const char * > categories, llvm::StringRef log_file, uint32_t log_options, size_t buffer_size, LogHandlerKind log_handler_kind, llvm::raw_ostream &error_stream)
uint64_t GetStopDisassemblyMaxSize() const
Broadcaster m_sync_broadcaster
Private debugger synchronization.
void RestoreInputTerminalState()
bool GetUseSourceCache() const
HostThread m_io_handler_thread
llvm::StringRef GetRegexMatchAnsiSuffix() const
static llvm::StringRef GetStaticBroadcasterClass()
lldb::FileSP m_input_file_sp
bool SetREPLLanguage(lldb::LanguageType repl_lang)
const FormatEntity::Entry * GetDisassemblyFormat() const
bool GetAutoIndent() const
llvm::StringRef GetStopShowColumnAnsiSuffix() const
@ eStopDisassemblyTypeNever
@ eStopDisassemblyTypeNoDebugInfo
@ eStopDisassemblyTypeNoSource
@ eStopDisassemblyTypeAlways
Status SetPropertyValue(const ExecutionContext *exe_ctx, VarSetOperationType op, llvm::StringRef property_path, llvm::StringRef value) override
llvm::StringRef GetPromptAnsiSuffix() const
void SetErrorFile(lldb::FileSP file)
bool GetAutoConfirm() const
lldb::ScriptLanguage GetScriptLanguage() const
std::unique_ptr< SourceManager > m_source_manager_up
static lldb::DebuggerSP CreateInstance(lldb::LogOutputCallback log_callback=nullptr, void *baton=nullptr)
lldb::StopShowColumn GetStopShowColumn() const
static void ReportSymbolChange(const ModuleSpec &module_spec)
static void ReportError(std::string message, std::optional< lldb::user_id_t > debugger_id=std::nullopt, std::once_flag *once=nullptr)
Report error events.
bool SetPrintDecls(bool b)
bool SetScriptLanguage(lldb::ScriptLanguage script_lang)
bool LoadPlugin(const FileSpec &spec, Status &error)
void SetOutputFile(lldb::FileSP file)
uint64_t GetStopSourceLineCount(bool before) const
void EnableForwardEvents(const lldb::ListenerSP &listener_sp)
@ eBroadcastBitEventThreadIsListening
static lldb::DebuggerSP FindDebuggerWithID(lldb::user_id_t id)
void HandleBreakpointEvent(const lldb::EventSP &event_sp)
void JoinIOHandlerThread()
bool CheckTopIOHandlerTypes(IOHandler::Type top_type, IOHandler::Type second_top_type)
Target & GetDummyTarget()
const FormatEntity::Entry * GetFrameFormat() const
lldb::ListenerSP GetListener()
static void Destroy(lldb::DebuggerSP &debugger_sp)
SourceManager::SourceFileCache m_source_file_cache
llvm::StringRef GetPromptAnsiPrefix() const
std::optional< uint64_t > m_current_event_id
void RunIOHandlerSync(const lldb::IOHandlerSP &reader_sp)
Run the given IO handler and block until it's complete.
const FormatEntity::Entry * GetThreadFormat() const
Broadcaster & GetBroadcaster()
Get the public broadcaster for this debugger.
llvm::StringRef GetStopShowLineMarkerAnsiPrefix() const
bool GetShowDontUsePoHint() const
uint64_t GetTabSize() const
lldb::StreamFileSP m_output_stream_sp
bool GetShowProgress() const
llvm::StringRef GetRegexMatchAnsiPrefix() const
void HandleDestroyCallback()
std::mutex m_output_flush_mutex
llvm::StringRef GetStopShowLineMarkerAnsiSuffix() const
bool SetUseColor(bool use_color)
lldb_private::DebuggerDestroyCallback m_destroy_callback
const char * GetIOHandlerHelpPrologue()
Status SetInputString(const char *data)
bool GetUseAutosuggestion() const
Target & GetSelectedOrDummyTarget(bool prefer_dummy=false)
void HandleProcessEvent(const lldb::EventSP &event_sp)
IOHandlerStack m_io_handler_stack
repro::DataRecorder * m_input_recorder
Used for shadowing the input file when capturing a reproducer.
lldb::StreamFileSP GetOutputStreamSP()
llvm::once_flag m_clear_once
void AdoptTopIOHandlerFilesIfInvalid(lldb::FileSP &in, lldb::StreamFileSP &out, lldb::StreamFileSP &err)
static void SettingsTerminate()
lldb::LanguageType GetREPLLanguage() const
ScriptInterpreter * GetScriptInterpreter(bool can_create=true, std::optional< lldb::ScriptLanguage > language={})
void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton)
bool SetTerminalWidth(uint64_t term_width)
Debugger(lldb::LogOutputCallback m_log_callback, void *baton)
llvm::StringRef GetExternalEditor() const
void HandleThreadEvent(const lldb::EventSP &event_sp)
static size_t GetNumDebuggers()
uint32_t m_interrupt_requested
Tracks interrupt requests.
lldb::DWIMPrintVerbosity GetDWIMPrintVerbosity() const
lldb::thread_result_t DefaultEventHandler()
void PrintAsync(const char *s, size_t len, bool is_stdout)
bool IsForwardingEvents()
llvm::StringRef GetPrompt() const
bool GetNotifyVoid() const
llvm::StringRef GetShowProgressAnsiPrefix() const
const FormatEntity::Entry * GetFrameFormatUnique() const
llvm::StringRef GetTopIOHandlerControlSequence(char ch)
void FlushProcessOutput(Process &process, bool flush_stdout, bool flush_stderr)
Force flushing the process's pending stdout and stderr to the debugger's asynchronous stdout and stde...
void CancelInterruptRequest()
Decrement the "interrupt requested" counter.
std::vector< lldb::DebuggerSP > DebuggerList
bool SetAutoIndent(bool b)
llvm::StringRef GetStopShowColumnAnsiPrefix() const
static DebuggerList DebuggersRequestingInterruption()
void Dump(Stream *s) const override
static const DiagnosticEventData * GetEventDataFromEvent(const Event *event_ptr)
CallbackID AddCallback(Callback callback)
void Report(llvm::StringRef message)
void RemoveCallback(CallbackID id)
static Diagnostics & Instance()
static const void * GetBytesFromEvent(const Event *event_ptr)
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr)
static lldb::StructuredDataPluginSP GetPluginFromEvent(const Event *event_ptr)
static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr)
Execution context objects refer to objects in the execution of the program that is being debugged.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
Target & GetTargetRef() const
Returns a reference to the target object.
FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
llvm::StringRef GetFileNameExtension() const
Extract the extension of the file.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
void EnumerateDirectory(llvm::Twine path, bool find_directories, bool find_files, bool find_other, EnumerateDirectoryCallbackType callback, void *callback_baton)
@ eEnumerateDirectoryResultEnter
Recurse into the current entry if it is a directory or symlink, or next if not.
@ eEnumerateDirectoryResultNext
Enumerate next entry in the current directory.
@ eEnumerateDirectoryResultQuit
Stop directory enumerations at any level.
int Open(const char *path, int flags, int mode=0600)
Wraps ::open in a platform-independent way.
static FileSystem & Instance()
An abstract base class for files.
static int kInvalidDescriptor
virtual int GetDescriptor() const
Get underlying OS file descriptor for this file, or kInvalidDescriptor.
bool GetIsTerminalWithColors()
Return true if this file is a terminal which supports colors.
Status Close() override
Flush any buffers and release any resources owned by the file.
bool GetIsInteractive()
Return true if this file is interactive.
const Mangled & GetMangled() const
Status Join(lldb::thread_result_t *result)
bool EqualsThread(lldb::thread_t thread) const
static lldb::thread_t GetCurrentThread()
Get the thread token (the one returned by ThreadCreate when the thread was created) for the calling t...
const char * GetTopIOHandlerHelpPrologue()
bool PrintAsync(const char *s, size_t len, bool is_stdout)
llvm::StringRef GetTopIOHandlerControlSequence(char ch)
bool IsTop(const lldb::IOHandlerSP &io_handler_sp) const
void Push(const lldb::IOHandlerSP &sp)
std::recursive_mutex & GetMutex()
bool CheckTopIOHandlerTypes(IOHandler::Type top_type, IOHandler::Type second_top_type)
const char * GetTopIOHandlerCommandPrefix()
static llvm::StringRef GetSettingName()
static LanguageSet GetLanguagesSupportingREPLs()
static const char * GetNameForLanguageType(lldb::LanguageType language)
static LanguageProperties & GetGlobalLanguageProperties()
static lldb::ListenerSP MakeListener(const char *name)
static bool EnableLogChannel(const std::shared_ptr< LogHandler > &log_handler_sp, uint32_t log_options, llvm::StringRef channel, llvm::ArrayRef< const char * > categories, llvm::raw_ostream &error_stream)
void PutString(llvm::StringRef str)
static ModuleListProperties & GetGlobalModuleListProperties()
void SetMinimumValue(int64_t v)
void SetMaximumValue(int64_t v)
static lldb::ScriptInterpreterSP GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang, Debugger &debugger)
static void DebuggerInitialize(Debugger &debugger)
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr)
static lldb::StateType GetStateFromEvent(const Event *event_ptr)
A plug-in interface definition class for debugging a process.
static bool HandleProcessStateChangedEvent(const lldb::EventSP &event_sp, Stream *stream, SelectMostRelevant select_most_relevant, bool &pop_process_io_handler)
Centralize the code that handles and prints descriptions for process state changes.
@ eBroadcastBitStructuredData
@ eBroadcastBitStateChanged
static llvm::StringRef GetStaticBroadcasterClass()
virtual size_t GetSTDERR(char *buf, size_t buf_size, Status &error)
Get any available STDERR.
virtual size_t GetSTDOUT(char *buf, size_t buf_size, Status &error)
Get any available STDOUT.
static const ProgressEventData * GetEventDataFromEvent(const Event *event_ptr)
lldb::OptionValuePropertiesSP m_collection_sp
virtual Status SetPropertyValue(const ExecutionContext *exe_ctx, VarSetOperationType op, llvm::StringRef property_path, llvm::StringRef value)
bool SetPropertyAtIndex(uint32_t idx, T t, const ExecutionContext *exe_ctx=nullptr) const
virtual lldb::OptionValuePropertiesSP GetValueProperties() const
static lldb::REPLSP Create(Status &Status, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options)
Get a REPL with an existing target (or, failing that, a debugger to use), and (optional) extra argume...
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
bool Success() const
Test for success condition.
void Flush() override
Flush the stream.
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
virtual void Flush()=0
Flush the stream.
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
Symbol * symbol
The Symbol for a given query.
bool Compare(ConstString name, lldb::SymbolType type) const
ConstString GetName() const
lldb::SymbolType GetType() const
lldb::TargetSP GetSelectedTarget()
static void SettingsTerminate()
@ eBroadcastBitBreakpointChanged
static llvm::StringRef GetStaticBroadcasterClass()
static TargetProperties & GetGlobalProperties()
static ArchSpec GetDefaultArchitecture()
static void SettingsInitialize()
bool Save(Terminal term, bool save_process_group)
Save the TTY state for fd.
bool Restore() const
Restore the TTY state to the cached state.
static llvm::Expected< HostThread > LaunchThread(llvm::StringRef name, std::function< lldb::thread_result_t()> thread_function, size_t min_stack_byte_size=0)
static lldb::ThreadSP GetThreadFromEvent(const Event *event_ptr)
@ eBroadcastBitThreadSelected
@ eBroadcastBitStackChanged
static llvm::StringRef GetStaticBroadcasterClass()
@ SelectMostRelevantFrame
#define LLDB_INVALID_HOST_THREAD
std::string FormatAnsiTerminalCodes(llvm::StringRef format, bool do_color=true)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
@ eLoadScriptFromSymFileTrue
@ eLoadScriptFromSymFileFalse
@ eLoadScriptFromSymFileWarn
void(* DebuggerDestroyCallback)(lldb::user_id_t debugger_id, void *baton)
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
llvm::sys::DynamicLibrary(* LoadPluginCallbackType)(const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, Status &error)
VarSetOperationType
Settable state variable types.
ScriptLanguage
Script interpreter types.
std::shared_ptr< lldb_private::IOHandler > IOHandlerSP
std::shared_ptr< lldb_private::Thread > ThreadSP
std::shared_ptr< lldb_private::Platform > PlatformSP
DWIMPrintVerbosity
Enum to control the verbosity level of dwim-print execution.
@ eDWIMPrintVerbosityFull
Always print a message indicating how dwim-print is evaluating its expression.
@ eDWIMPrintVerbosityNone
Run dwim-print with no verbosity.
@ eDWIMPrintVerbosityExpression
Print a message when dwim-print uses expression evaluation.
StateType
Process and Thread States.
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
std::shared_ptr< lldb_private::Stream > StreamSP
std::shared_ptr< lldb_private::Breakpoint > BreakpointSP
std::shared_ptr< lldb_private::StructuredDataPlugin > StructuredDataPluginSP
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::Debugger > DebuggerSP
@ eStopShowColumnAnsiOrCaret
std::shared_ptr< lldb_private::Event > EventSP
std::shared_ptr< lldb_private::Listener > ListenerSP
std::shared_ptr< lldb_private::StreamFile > StreamFileSP
void(* LogOutputCallback)(const char *, void *baton)
std::shared_ptr< lldb_private::Target > TargetSP
std::shared_ptr< lldb_private::File > FileSP
std::shared_ptr< lldb_private::REPL > REPLSP
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
std::optional< lldb::LanguageType > GetSingularLanguage()
If the set contains a single language only, return it.
A mix in class that contains a generic user ID.
lldb::user_id_t GetID() const
Get accessor for the user ID.