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);
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().AsCString()),
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) {
1121 top_reader_sp->Run();
1124 if (top_reader_sp.get() == reader_sp.get()) {
1133 if (top_reader_sp && top_reader_sp->GetIsDone()) {
1136 if (top_reader_sp.get() == reader_sp.get())
1159 stream->Write(s, len);
1180 bool cancel_top_handler) {
1194 if (!in || !in->IsValid()) {
1196 in = top_reader_sp->GetInputFileSP();
1201 in = std::make_shared<NativeFile>(stdin,
false);
1204 if (!out || !out->GetFile().IsValid()) {
1206 out = top_reader_sp->GetOutputStreamFileSP();
1211 out = std::make_shared<StreamFile>(stdout,
false);
1214 if (!err || !err->GetFile().IsValid()) {
1216 err = top_reader_sp->GetErrorStreamFileSP();
1221 err = std::make_shared<StreamFile>(stderr,
false);
1226 bool cancel_top_handler) {
1236 if (reader_sp == top_reader_sp)
1241 reader_sp->Activate();
1245 if (top_reader_sp) {
1246 top_reader_sp->Deactivate();
1247 if (cancel_top_handler)
1248 top_reader_sp->Cancel();
1265 if (pop_reader_sp != reader_sp)
1268 reader_sp->Deactivate();
1269 reader_sp->Cancel();
1274 reader_sp->Activate();
1280 return std::make_shared<StreamAsynchronousIO>(*
this,
true,
GetUseColor());
1284 return std::make_shared<StreamAsynchronousIO>(*
this,
false,
GetUseColor());
1311 std::string function_name,
const llvm::formatv_object_base &payload)
1312 : m_function_name(std::move(function_name)),
1313 m_interrupt_time(std::chrono::system_clock::now()),
1314 m_thread_id(
llvm::get_threadid()) {
1316 desc << payload <<
"\n";
1330 if (debugger_sp->InterruptRequested())
1331 result.push_back(debugger_sp);
1350 if (index < g_debugger_list_ptr->size())
1364 if ((*pos)->GetID() ==
id) {
1380 if (format ==
nullptr) {
1383 if (format ==
nullptr) {
1385 format = &format_entry;
1388 bool function_changed =
false;
1389 bool initial_function =
false;
1395 function_changed =
true;
1399 function_changed =
true;
1409 initial_function =
true;
1412 function_changed, initial_function);
1416 llvm::StringRef backtrace,
1417 llvm::StringRef prompt) {
1419 llvm::formatv(
"{0}\n{1}{2}", message, backtrace, prompt).str());
1428 std::make_shared<CallbackLogHandler>(log_callback, baton);
1438 std::string title, std::string details,
1439 uint64_t completed, uint64_t total,
1440 bool is_debugger_specific,
1441 uint32_t progress_broadcast_bit) {
1447 progress_broadcast_bit,
1449 completed, total, is_debugger_specific)));
1454 std::string details, uint64_t completed,
1456 std::optional<lldb::user_id_t> debugger_id,
1457 uint32_t progress_category_bit) {
1465 std::move(details), completed, total,
1467 progress_category_bit);
1478 progress_category_bit);
1484 std::string message,
1485 bool debugger_specific) {
1486 uint32_t event_type = 0;
1489 assert(
false &&
"DiagnosticEventData::Type::Info should not be broadcast");
1505 event_data.
Dump(stream.get());
1508 EventSP event_sp = std::make_shared<Event>(
1515 std::string message,
1516 std::optional<lldb::user_id_t> debugger_id,
1517 std::once_flag *once) {
1518 auto ReportDiagnosticLambda = [&]() {
1547 std::call_once(*once, ReportDiagnosticLambda);
1549 ReportDiagnosticLambda();
1553 std::optional<lldb::user_id_t> debugger_id,
1554 std::once_flag *once) {
1560 std::optional<lldb::user_id_t> debugger_id,
1561 std::once_flag *once) {
1567 std::optional<lldb::user_id_t> debugger_id,
1568 std::once_flag *once) {
1577 EventSP event_sp = std::make_shared<Event>(
1580 debugger_sp->GetBroadcaster().BroadcastEvent(event_sp);
1585static std::shared_ptr<LogHandler>
1587 size_t buffer_size) {
1588 switch (log_handler_kind) {
1590 return std::make_shared<StreamLogHandler>(fd, should_close, buffer_size);
1592 return std::make_shared<RotatingLogHandler>(buffer_size);
1594 return std::make_shared<SystemLogHandler>();
1602 llvm::ArrayRef<const char *> categories,
1603 llvm::StringRef log_file, uint32_t log_options,
1605 llvm::raw_ostream &error_stream) {
1607 std::shared_ptr<LogHandler> log_handler_sp;
1613 }
else if (log_file.empty()) {
1616 false, buffer_size);
1620 log_handler_sp = pos->second.lock();
1621 if (!log_handler_sp) {
1629 FileSpec(log_file), flags, lldb::eFilePermissionsFileDefault,
false);
1631 error_stream <<
"Unable to open log file '" << log_file
1632 <<
"': " << llvm::toString(file.takeError()) <<
"\n";
1642 assert(log_handler_sp);
1644 if (log_options == 0)
1653 std::optional<lldb::ScriptLanguage> language) {
1676 using namespace lldb;
1677 const uint32_t event_type =
1694 if (event_type & eBreakpointEventTypeLocationsAdded) {
1695 uint32_t num_new_locations =
1698 if (num_new_locations > 0) {
1703 output_sp->Printf(
"%d location%s added to breakpoint %d\n",
1704 num_new_locations, num_new_locations == 1 ?
"" :
"s",
1705 breakpoint->GetID());
1723 bool flush_stderr) {
1724 const auto &flush = [&](
Stream &stream,
1729 while ((len = (process.*get)(buffer,
sizeof(buffer),
error)) > 0)
1730 stream.
Write(buffer, len);
1743 using namespace lldb;
1744 const uint32_t event_type = event_sp->GetType();
1755 bool pop_process_io_handler =
false;
1758 bool state_is_stopped =
false;
1759 const bool got_state_changed =
1763 const bool got_structured_data =
1766 if (got_state_changed) {
1773 if (got_state_changed && !state_is_stopped) {
1778 pop_process_io_handler);
1783 got_stderr || got_state_changed);
1786 if (got_structured_data) {
1790 auto structured_data_sp =
1792 if (output_stream_sp) {
1795 plugin_sp->GetDescription(structured_data_sp, content_stream);
1796 if (
error.Success()) {
1797 if (!content_stream.
GetString().empty()) {
1800 content_stream.
Flush();
1803 output_stream_sp->PutCString(content_stream.
GetString());
1806 error_stream_sp->Format(
"Failed to print structured "
1807 "data with plugin {0}: {1}",
1808 plugin_sp->GetPluginName(),
error);
1815 if (got_state_changed && state_is_stopped) {
1818 pop_process_io_handler);
1821 output_stream_sp->Flush();
1822 error_stream_sp->Flush();
1824 if (pop_process_io_handler)
1825 process_sp->PopProcessIOHandler();
1832 using namespace lldb;
1833 const uint32_t event_type = event_sp->GetType();
1834 const bool stop_format =
true;
1864 broadcaster_class_process,
1875 process_event_spec);
1878 listener_sp->StartListeningForEvents(
1884 listener_sp->StartListeningForEvents(
1895 if (listener_sp->GetEvent(event_sp, std::nullopt)) {
1897 Broadcaster *broadcaster = event_sp->GetBroadcaster();
1899 uint32_t event_type = event_sp->GetType();
1901 if (broadcaster_class == broadcaster_class_process) {
1903 }
else if (broadcaster_class == broadcaster_class_target) {
1908 }
else if (broadcaster_class == broadcaster_class_thread) {
1914 }
else if (event_type &
1916 const char *data =
static_cast<const char *
>(
1918 if (data && data[0]) {
1921 error_sp->PutCString(data);
1926 eBroadcastBitAsynchronousOutputData) {
1927 const char *data =
static_cast<const char *
>(
1929 if (data && data[0]) {
1932 output_sp->PutCString(data);
1961 ConstString full_name(
"lldb.debugger.event-handler");
1966 llvm::StringRef thread_name =
1967 full_name.
GetLength() < llvm::get_max_thread_name_length()
1969 :
"dbg.evt-handler";
1972 llvm::Expected<HostThread> event_handler_thread =
1977 if (event_handler_thread) {
1981 "failed to launch host thread: {0}");
1990 listener_sp->GetEvent(event_sp, std::nullopt);
2016 const uint64_t
id = data->GetID();
2022 <<
static_cast<void *
>(
this) <<
" Debugger(" <<
GetID()
2023 <<
")::HandleProgressEvent( m_current_event_id = "
2025 data->Dump(&log_stream);
2026 log_stream <<
" } )";
2031 if (data->GetCompleted() == data->GetTotal())
2052 output->Printf(
"\r");
2054 if (data->GetCompleted() == data->GetTotal()) {
2056 output->Printf(
"\x1B[2K");
2062 std::string message = data->GetMessage();
2063 if (data->IsFinite())
2064 message = llvm::formatv(
"[{0}/{1}] {2}", data->GetCompleted(),
2065 data->GetTotal(), message)
2070 const uint32_t ellipsis = 3;
2071 if (message.size() + ellipsis >= term_width)
2072 message = message.substr(0, term_width - ellipsis);
2076 if (!ansi_prefix.empty())
2080 output->Printf(
"%s...", message.c_str());
2083 if (!ansi_suffix.empty())
2088 output->Printf(
"\x1B[K\r");
2100 data->Dump(stream.get());
2118 if (io_handler_thread) {
2122 "failed to launch host thread: {0}");
2150 if (!prefer_dummy) {
2168 language = *single_lang;
2169 }
else if (repl_languages.
Empty()) {
2171 "LLDB isn't configured with REPL support for any languages.");
2175 "Multiple possible REPL languages. Please specify a language.");
2195 repl_sp->SetCompilerOptions(repl_options);
2203 "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 ConstString & 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
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()
static ConstString GetStaticBroadcasterClass()
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
virtual size_t GetSTDERR(char *buf, size_t buf_size, Status &error)
Get any available STDERR.
static ConstString & GetStaticBroadcasterClass()
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 ConstString & GetStaticBroadcasterClass()
static void SettingsTerminate()
@ eBroadcastBitBreakpointChanged
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)
static ConstString & GetStaticBroadcasterClass()
@ eBroadcastBitThreadSelected
@ eBroadcastBitStackChanged
@ 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.