61#include "llvm/ADT/STLExtras.h"
62#include "llvm/ADT/StringRef.h"
63#include "llvm/ADT/iterator.h"
64#include "llvm/Support/DynamicLibrary.h"
65#include "llvm/Support/FileSystem.h"
66#include "llvm/Support/Process.h"
67#include "llvm/Support/ThreadPool.h"
68#include "llvm/Support/Threading.h"
69#include "llvm/Support/raw_ostream.h"
80#include <system_error>
100#pragma mark Static Functions
112 "Never show disassembly when displaying a stop context.",
117 "Show disassembly when there is no debug information.",
122 "Show disassembly when there is no source information, or the source "
124 "is missing when displaying a stop context.",
129 "Always show disassembly when displaying a stop context.",
137 "Disable scripting languages.",
142 "Select python as the default scripting language.",
147 "Select the lldb default as the default scripting language.",
153 "Use no verbosity when running dwim-print."},
155 "Use partial verbosity when running dwim-print - display a message when "
156 "`expression` evaluation is used."},
158 "Use full verbosity when running dwim-print."},
165 "Highlight the stop column with ANSI terminal codes when color/ANSI "
166 "mode is enabled; otherwise, fall back to using a text-only caret (^) "
167 "as if \"caret-only\" mode was selected.",
172 "Highlight the stop column with ANSI terminal codes when running LLDB "
173 "with color/ANSI enabled.",
178 "Highlight the stop column with a caret character (^) underneath the "
179 "stop column. This method introduces a new line in source listings "
180 "that display thread stop locations.",
185 "Do not highlight the stop column.",
189#define LLDB_PROPERTIES_debugger
190#include "CoreProperties.inc"
193#define LLDB_PROPERTIES_debugger
194#include "CorePropertiesEnum.inc"
201 llvm::StringRef property_path,
202 llvm::StringRef value) {
203 bool is_load_script =
204 (property_path ==
"target.load-script-from-symbol-file");
206 bool invalidate_data_vis = (property_path ==
"escape-non-printables");
207 invalidate_data_vis |=
208 (property_path ==
"target.max-zero-padding-in-float-format");
209 if (invalidate_data_vis) {
215 if (is_load_script && exe_ctx && exe_ctx->
GetTargetSP()) {
217 load_script_old_value =
218 target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
221 if (
error.Success()) {
223 if (property_path == g_debugger_properties[ePropertyPrompt].name) {
224 llvm::StringRef new_prompt =
GetPrompt();
230 auto bytes = std::make_unique<EventDataBytes>(new_prompt);
231 auto prompt_change_event_sp = std::make_shared<Event>(
234 }
else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
238 }
else if (property_path ==
239 g_debugger_properties[ePropertyPromptAnsiPrefix].name ||
241 g_debugger_properties[ePropertyPromptAnsiSuffix].name) {
245 }
else if (property_path ==
246 g_debugger_properties[ePropertyUseSourceCache].name) {
252 }
else if (is_load_script && target_sp &&
254 if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
256 std::list<Status> errors;
258 if (!target_sp->LoadScriptingResources(errors, feedback_stream)) {
260 for (
auto error : errors) {
273 constexpr uint32_t idx = ePropertyAutoConfirm;
274 return GetPropertyAtIndexAs<bool>(
275 idx, g_debugger_properties[idx].default_uint_value != 0);
279 constexpr uint32_t idx = ePropertyDisassemblyFormat;
280 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
284 constexpr uint32_t idx = ePropertyFrameFormat;
285 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
289 constexpr uint32_t idx = ePropertyFrameFormatUnique;
290 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
294 constexpr uint32_t idx = ePropertyStopDisassemblyMaxSize;
295 return GetPropertyAtIndexAs<uint64_t>(
296 idx, g_debugger_properties[idx].default_uint_value);
300 constexpr uint32_t idx = ePropertyNotiftVoid;
301 return GetPropertyAtIndexAs<uint64_t>(
302 idx, g_debugger_properties[idx].default_uint_value != 0);
306 constexpr uint32_t idx = ePropertyPrompt;
307 return GetPropertyAtIndexAs<llvm::StringRef>(
308 idx, g_debugger_properties[idx].default_cstr_value);
312 const uint32_t idx = ePropertyPromptAnsiPrefix;
313 return GetPropertyAtIndexAs<llvm::StringRef>(
314 idx, g_debugger_properties[idx].default_cstr_value);
318 const uint32_t idx = ePropertyPromptAnsiSuffix;
319 return GetPropertyAtIndexAs<llvm::StringRef>(
320 idx, g_debugger_properties[idx].default_cstr_value);
324 constexpr uint32_t idx = ePropertyPrompt;
326 llvm::StringRef new_prompt =
GetPrompt();
335 constexpr uint32_t idx = ePropertyThreadFormat;
336 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
340 constexpr uint32_t idx = ePropertyThreadStopFormat;
341 return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx);
345 const uint32_t idx = ePropertyScriptLanguage;
346 return GetPropertyAtIndexAs<lldb::ScriptLanguage>(
348 g_debugger_properties[idx].default_uint_value));
352 const uint32_t idx = ePropertyScriptLanguage;
357 const uint32_t idx = ePropertyREPLLanguage;
358 return GetPropertyAtIndexAs<LanguageType>(idx, {});
362 const uint32_t idx = ePropertyREPLLanguage;
367 const uint32_t idx = ePropertyTerminalWidth;
368 return GetPropertyAtIndexAs<int64_t>(
369 idx, g_debugger_properties[idx].default_uint_value);
374 handler_sp->TerminalSizeChanged();
376 const uint32_t idx = ePropertyTerminalWidth;
381 const uint32_t idx = ePropertyUseExternalEditor;
382 return GetPropertyAtIndexAs<bool>(
383 idx, g_debugger_properties[idx].default_uint_value != 0);
387 const uint32_t idx = ePropertyUseExternalEditor;
392 const uint32_t idx = ePropertyExternalEditor;
393 return GetPropertyAtIndexAs<llvm::StringRef>(
394 idx, g_debugger_properties[idx].default_cstr_value);
398 const uint32_t idx = ePropertyExternalEditor;
403 const uint32_t idx = ePropertyUseColor;
404 return GetPropertyAtIndexAs<bool>(
405 idx, g_debugger_properties[idx].default_uint_value != 0);
409 const uint32_t idx = ePropertyUseColor;
416 const uint32_t idx = ePropertyShowProgress;
417 return GetPropertyAtIndexAs<bool>(
418 idx, g_debugger_properties[idx].default_uint_value != 0);
422 const uint32_t idx = ePropertyShowProgress;
427 const uint32_t idx = ePropertyShowProgressAnsiPrefix;
428 return GetPropertyAtIndexAs<llvm::StringRef>(
429 idx, g_debugger_properties[idx].default_cstr_value);
433 const uint32_t idx = ePropertyShowProgressAnsiSuffix;
434 return GetPropertyAtIndexAs<llvm::StringRef>(
435 idx, g_debugger_properties[idx].default_cstr_value);
439 const uint32_t idx = ePropertyShowAutosuggestion;
440 return GetPropertyAtIndexAs<bool>(
441 idx, g_debugger_properties[idx].default_uint_value != 0);
445 const uint32_t idx = ePropertyShowAutosuggestionAnsiPrefix;
446 return GetPropertyAtIndexAs<llvm::StringRef>(
447 idx, g_debugger_properties[idx].default_cstr_value);
451 const uint32_t idx = ePropertyShowAutosuggestionAnsiSuffix;
452 return GetPropertyAtIndexAs<llvm::StringRef>(
453 idx, g_debugger_properties[idx].default_cstr_value);
457 const uint32_t idx = ePropertyShowDontUsePoHint;
458 return GetPropertyAtIndexAs<bool>(
459 idx, g_debugger_properties[idx].default_uint_value != 0);
463 const uint32_t idx = ePropertyUseSourceCache;
464 return GetPropertyAtIndexAs<bool>(
465 idx, g_debugger_properties[idx].default_uint_value != 0);
469 const uint32_t idx = ePropertyUseSourceCache;
477 const uint32_t idx = ePropertyHighlightSource;
478 return GetPropertyAtIndexAs<bool>(
479 idx, g_debugger_properties[idx].default_uint_value != 0);
483 const uint32_t idx = ePropertyStopShowColumn;
484 return GetPropertyAtIndexAs<lldb::StopShowColumn>(
486 g_debugger_properties[idx].default_uint_value));
490 const uint32_t idx = ePropertyStopShowColumnAnsiPrefix;
491 return GetPropertyAtIndexAs<llvm::StringRef>(
492 idx, g_debugger_properties[idx].default_cstr_value);
496 const uint32_t idx = ePropertyStopShowColumnAnsiSuffix;
497 return GetPropertyAtIndexAs<llvm::StringRef>(
498 idx, g_debugger_properties[idx].default_cstr_value);
502 const uint32_t idx = ePropertyStopShowLineMarkerAnsiPrefix;
503 return GetPropertyAtIndexAs<llvm::StringRef>(
504 idx, g_debugger_properties[idx].default_cstr_value);
508 const uint32_t idx = ePropertyStopShowLineMarkerAnsiSuffix;
509 return GetPropertyAtIndexAs<llvm::StringRef>(
510 idx, g_debugger_properties[idx].default_cstr_value);
515 before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
516 return GetPropertyAtIndexAs<uint64_t>(
517 idx, g_debugger_properties[idx].default_uint_value);
521 const uint32_t idx = ePropertyStopDisassemblyDisplay;
522 return GetPropertyAtIndexAs<Debugger::StopDisassemblyType>(
524 g_debugger_properties[idx].default_uint_value));
528 const uint32_t idx = ePropertyStopDisassemblyCount;
529 return GetPropertyAtIndexAs<uint64_t>(
530 idx, g_debugger_properties[idx].default_uint_value);
534 const uint32_t idx = ePropertyAutoOneLineSummaries;
535 return GetPropertyAtIndexAs<bool>(
536 idx, g_debugger_properties[idx].default_uint_value != 0);
540 const uint32_t idx = ePropertyEscapeNonPrintables;
541 return GetPropertyAtIndexAs<bool>(
542 idx, g_debugger_properties[idx].default_uint_value != 0);
546 const uint32_t idx = ePropertyAutoIndent;
547 return GetPropertyAtIndexAs<bool>(
548 idx, g_debugger_properties[idx].default_uint_value != 0);
552 const uint32_t idx = ePropertyAutoIndent;
557 const uint32_t idx = ePropertyPrintDecls;
558 return GetPropertyAtIndexAs<bool>(
559 idx, g_debugger_properties[idx].default_uint_value != 0);
563 const uint32_t idx = ePropertyPrintDecls;
568 const uint32_t idx = ePropertyTabSize;
569 return GetPropertyAtIndexAs<uint64_t>(
570 idx, g_debugger_properties[idx].default_uint_value);
574 const uint32_t idx = ePropertyTabSize;
579 const uint32_t idx = ePropertyDWIMPrintVerbosity;
580 return GetPropertyAtIndexAs<lldb::DWIMPrintVerbosity>(
582 g_debugger_properties[idx].default_uint_value));
596 "Debugger::Initialize called more than once!");
599 g_thread_pool =
new llvm::ThreadPool(llvm::optimal_concurrency());
605 "Debugger::Terminate called without a matching Debugger::Initialize!");
610 debugger->HandleDestroyCallback();
635 llvm::sys::DynamicLibrary dynlib =
637 if (dynlib.isValid()) {
645 error.SetErrorString(
"Public API layer is not available");
652 llvm::StringRef path) {
655 static constexpr llvm::StringLiteral g_dylibext(
".dylib");
656 static constexpr llvm::StringLiteral g_solibext(
".so");
663 namespace fs = llvm::sys::fs;
668 if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
669 ft == fs::file_type::type_unknown) {
679 debugger->
LoadPlugin(plugin_file_spec, plugin_load_error);
682 }
else if (ft == fs::file_type::directory_file ||
683 ft == fs::file_type::symlink_file ||
684 ft == fs::file_type::type_unknown) {
696 const bool find_directories =
true;
697 const bool find_files =
true;
698 const bool find_other =
true;
700 if (
FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
702 dir_spec.GetPath(dir_path,
sizeof(dir_path))) {
704 find_files, find_other,
709 if (
FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
711 dir_spec.GetPath(dir_path,
sizeof(dir_path))) {
713 find_files, find_other,
728 debugger_sp->InstanceInitialize();
743 debugger_sp->HandleDestroyCallback();
750 (*debugger_sp->GetAsyncOutputStream()) << result.
GetOutputData() <<
'\n';
752 (*debugger_sp->GetAsyncErrorStream()) << result.
GetErrorData() <<
'\n';
755 debugger_sp->Clear();
761 if ((*pos).get() == debugger_sp.get()) {
779 if (llvm::StringRef(debugger_sp->GetInstanceName()) == instance_name)
791 target_sp = (*pos)->GetTargetList().FindTargetWithProcessID(pid);
805 target_sp = (*pos)->GetTargetList().FindTargetWithProcess(process);
821 m_input_file_sp(std::make_shared<
NativeFile>(stdin, false)),
822 m_output_stream_sp(std::make_shared<
StreamFile>(stdout, false)),
823 m_error_stream_sp(std::make_shared<
StreamFile>(stderr, false)),
824 m_input_recorder(nullptr),
826 m_terminal_state(), m_target_list(*this), m_platform_list(),
827 m_listener_sp(
Listener::MakeListener(
"lldb.Debugger")),
828 m_source_manager_up(), m_source_file_cache(),
829 m_command_interpreter_up(
831 m_io_handler_stack(),
832 m_instance_name(
llvm::formatv(
"debugger_{0}", GetID()).str()),
833 m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
834 m_sync_broadcaster(nullptr,
"lldb.debugger.sync"),
835 m_broadcaster(m_broadcaster_manager_sp,
836 GetStaticBroadcasterClass().AsCString()),
837 m_forward_listener_sp(), m_clear_once() {
842 "target",
"Settings specify to debugging targets.",
true,
845 "platform",
"Platform settings.",
true,
848 "symbols",
"Symbol lookup and cache settings.",
true,
853 "Settings specify to the debugger's command interpreter.",
true,
858 std::make_shared<CallbackLogHandler>(log_callback, baton);
862 assert(default_platform_sp);
869 arch = HostInfo::GetArchitecture();
870 assert(arch.
IsValid() &&
"No valid default or host archspec");
871 const bool is_dummy_target =
true;
873 new Target(*
this, arch, default_platform_sp, is_dummy_target));
879 ePropertyTerminalWidth);
884 const char *term = getenv(
"TERM");
885 if (term && !strcmp(term,
"dumb"))
893 [
this](
const FileSpec &dir) -> llvm::Error {
895 llvm::StringRef log_path = entry.first();
896 llvm::StringRef file_name = llvm::sys::path::filename(log_path);
899 llvm::sys::fs::copy_file(log_path, destination.
GetPath());
901 return llvm::errorCodeToError(ec);
903 return llvm::Error::success();
907#if defined(_WIN32) && defined(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
910 llvm::sys::Process::UseANSIEscapeCodes(
true);
932 if (
ProcessSP process_sp = target_sp->GetProcessSP())
933 process_sp->Finalize();
934 target_sp->Destroy();
961static inline int OpenPipe(
int fds[2], std::size_t size) {
963 return _pipe(fds, size, O_BINARY);
973 int fds[2] = {-1, -1};
975 if (data ==
nullptr) {
980 size_t size = strlen(data);
988 "can't create pipe file descriptors for LLDB commands");
992 int r = write(fds[
WRITE], data, size);
996 llvm::sys::Process::SafelyCloseFileDescriptor(fds[
WRITE]);
1000 FILE *commands_file = fdopen(fds[
READ],
"rb");
1001 if (commands_file ==
nullptr) {
1003 "when trying to open LLDB commands pipe",
1005 llvm::sys::Process::SafelyCloseFileDescriptor(fds[
READ]);
1014 assert(file_sp && file_sp->IsValid());
1022 assert(file_sp && file_sp->IsValid());
1027 assert(file_sp && file_sp->IsValid());
1040 bool adopt_selected =
true;
1049 reader_sp->Interrupt();
1056 reader_sp->GotEOF();
1078 std::lock_guard<std::recursive_mutex> guard(
1084 if (top_reader_sp && top_reader_sp->GetIsDone())
1101 while (top_reader_sp) {
1105 top_reader_sp->Run();
1108 if (top_reader_sp.get() == reader_sp.get()) {
1117 if (top_reader_sp && top_reader_sp->GetIsDone()) {
1120 if (top_reader_sp.get() == reader_sp.get())
1143 stream->Write(s, len);
1164 bool cancel_top_handler) {
1178 if (!in || !in->IsValid()) {
1180 in = top_reader_sp->GetInputFileSP();
1185 in = std::make_shared<NativeFile>(stdin,
false);
1188 if (!out || !out->GetFile().IsValid()) {
1190 out = top_reader_sp->GetOutputStreamFileSP();
1195 out = std::make_shared<StreamFile>(stdout,
false);
1198 if (!err || !err->GetFile().IsValid()) {
1200 err = top_reader_sp->GetErrorStreamFileSP();
1205 err = std::make_shared<StreamFile>(stderr,
false);
1210 bool cancel_top_handler) {
1220 if (reader_sp == top_reader_sp)
1225 reader_sp->Activate();
1229 if (top_reader_sp) {
1230 top_reader_sp->Deactivate();
1231 if (cancel_top_handler)
1232 top_reader_sp->Cancel();
1249 if (pop_reader_sp != reader_sp)
1252 reader_sp->Deactivate();
1253 reader_sp->Cancel();
1258 reader_sp->Activate();
1264 return std::make_shared<StreamAsynchronousIO>(*
this,
true,
GetUseColor());
1268 return std::make_shared<StreamAsynchronousIO>(*
this,
false,
GetUseColor());
1295 std::string function_name,
const llvm::formatv_object_base &payload)
1296 : m_function_name(std::move(function_name)),
1297 m_interrupt_time(std::chrono::system_clock::now()),
1298 m_thread_id(
llvm::get_threadid()) {
1300 desc << payload <<
"\n";
1314 if (debugger_sp->InterruptRequested())
1315 result.push_back(debugger_sp);
1334 if (index < g_debugger_list_ptr->size())
1348 if ((*pos)->GetID() ==
id) {
1364 if (format ==
nullptr) {
1367 if (format ==
nullptr) {
1369 format = &format_entry;
1372 bool function_changed =
false;
1373 bool initial_function =
false;
1379 function_changed =
true;
1383 function_changed =
true;
1393 initial_function =
true;
1396 function_changed, initial_function);
1400 llvm::StringRef backtrace,
1401 llvm::StringRef prompt) {
1403 llvm::formatv(
"{0}\n{1}{2}", message, backtrace, prompt).str());
1412 std::make_shared<CallbackLogHandler>(log_callback, baton);
1422 std::string title, std::string details,
1423 uint64_t completed, uint64_t total,
1424 bool is_debugger_specific) {
1432 completed, total, is_debugger_specific)));
1437 std::string details, uint64_t completed,
1439 std::optional<lldb::user_id_t> debugger_id) {
1447 std::move(details), completed, total,
1464 std::string message,
1465 bool debugger_specific) {
1466 uint32_t event_type = 0;
1469 assert(
false &&
"DiagnosticEventData::Type::Info should not be broadcast");
1485 event_data.
Dump(stream.get());
1488 EventSP event_sp = std::make_shared<Event>(
1495 std::string message,
1496 std::optional<lldb::user_id_t> debugger_id,
1497 std::once_flag *once) {
1498 auto ReportDiagnosticLambda = [&]() {
1527 std::call_once(*once, ReportDiagnosticLambda);
1529 ReportDiagnosticLambda();
1533 std::optional<lldb::user_id_t> debugger_id,
1534 std::once_flag *once) {
1540 std::optional<lldb::user_id_t> debugger_id,
1541 std::once_flag *once) {
1547 std::optional<lldb::user_id_t> debugger_id,
1548 std::once_flag *once) {
1557 EventSP event_sp = std::make_shared<Event>(
1560 debugger_sp->GetBroadcaster().BroadcastEvent(event_sp);
1565static std::shared_ptr<LogHandler>
1567 size_t buffer_size) {
1568 switch (log_handler_kind) {
1570 return std::make_shared<StreamLogHandler>(fd, should_close, buffer_size);
1572 return std::make_shared<RotatingLogHandler>(buffer_size);
1574 return std::make_shared<SystemLogHandler>();
1582 llvm::ArrayRef<const char *> categories,
1583 llvm::StringRef log_file, uint32_t log_options,
1585 llvm::raw_ostream &error_stream) {
1587 std::shared_ptr<LogHandler> log_handler_sp;
1593 }
else if (log_file.empty()) {
1596 false, buffer_size);
1600 log_handler_sp = pos->second.lock();
1601 if (!log_handler_sp) {
1609 FileSpec(log_file), flags, lldb::eFilePermissionsFileDefault,
false);
1611 error_stream <<
"Unable to open log file '" << log_file
1612 <<
"': " << llvm::toString(file.takeError()) <<
"\n";
1622 assert(log_handler_sp);
1624 if (log_options == 0)
1633 std::optional<lldb::ScriptLanguage> language) {
1656 using namespace lldb;
1657 const uint32_t event_type =
1674 if (event_type & eBreakpointEventTypeLocationsAdded) {
1675 uint32_t num_new_locations =
1678 if (num_new_locations > 0) {
1683 output_sp->Printf(
"%d location%s added to breakpoint %d\n",
1684 num_new_locations, num_new_locations == 1 ?
"" :
"s",
1685 breakpoint->GetID());
1703 bool flush_stderr) {
1704 const auto &flush = [&](
Stream &stream,
1709 while ((len = (process.*get)(buffer,
sizeof(buffer),
error)) > 0)
1710 stream.
Write(buffer, len);
1723 using namespace lldb;
1724 const uint32_t event_type = event_sp->GetType();
1735 bool pop_process_io_handler =
false;
1738 bool state_is_stopped =
false;
1739 const bool got_state_changed =
1743 const bool got_structured_data =
1746 if (got_state_changed) {
1753 if (got_state_changed && !state_is_stopped) {
1758 pop_process_io_handler);
1763 got_stderr || got_state_changed);
1766 if (got_structured_data) {
1770 auto structured_data_sp =
1772 if (output_stream_sp) {
1775 plugin_sp->GetDescription(structured_data_sp, content_stream);
1776 if (
error.Success()) {
1777 if (!content_stream.
GetString().empty()) {
1780 content_stream.
Flush();
1783 output_stream_sp->PutCString(content_stream.
GetString());
1786 error_stream_sp->Format(
"Failed to print structured "
1787 "data with plugin {0}: {1}",
1788 plugin_sp->GetPluginName(),
error);
1795 if (got_state_changed && state_is_stopped) {
1798 pop_process_io_handler);
1801 output_stream_sp->Flush();
1802 error_stream_sp->Flush();
1804 if (pop_process_io_handler)
1805 process_sp->PopProcessIOHandler();
1812 using namespace lldb;
1813 const uint32_t event_type = event_sp->GetType();
1814 const bool stop_format =
true;
1844 broadcaster_class_process,
1855 process_event_spec);
1858 listener_sp->StartListeningForEvents(
1864 listener_sp->StartListeningForEvents(
1875 if (listener_sp->GetEvent(event_sp, std::nullopt)) {
1877 Broadcaster *broadcaster = event_sp->GetBroadcaster();
1879 uint32_t event_type = event_sp->GetType();
1881 if (broadcaster_class == broadcaster_class_process) {
1883 }
else if (broadcaster_class == broadcaster_class_target) {
1888 }
else if (broadcaster_class == broadcaster_class_thread) {
1894 }
else if (event_type &
1896 const char *data =
static_cast<const char *
>(
1898 if (data && data[0]) {
1901 error_sp->PutCString(data);
1906 eBroadcastBitAsynchronousOutputData) {
1907 const char *data =
static_cast<const char *
>(
1909 if (data && data[0]) {
1912 output_sp->PutCString(data);
1941 ConstString full_name(
"lldb.debugger.event-handler");
1946 llvm::StringRef thread_name =
1947 full_name.
GetLength() < llvm::get_max_thread_name_length()
1949 :
"dbg.evt-handler";
1952 llvm::Expected<HostThread> event_handler_thread =
1957 if (event_handler_thread) {
1961 "failed to launch host thread: {0}");
1970 listener_sp->GetEvent(event_sp, std::nullopt);
1996 const uint64_t
id = data->GetID();
2002 <<
static_cast<void *
>(
this) <<
" Debugger(" <<
GetID()
2003 <<
")::HandleProgressEvent( m_current_event_id = "
2005 data->Dump(&log_stream);
2006 log_stream <<
" } )";
2011 if (data->GetCompleted() == data->GetTotal())
2032 output->Printf(
"\r");
2034 if (data->GetCompleted() == data->GetTotal()) {
2036 output->Printf(
"\x1B[2K");
2042 std::string message = data->GetMessage();
2043 if (data->IsFinite())
2044 message = llvm::formatv(
"[{0}/{1}] {2}", data->GetCompleted(),
2045 data->GetTotal(), message)
2050 const uint32_t ellipsis = 3;
2051 if (message.size() + ellipsis >= term_width)
2052 message = message.substr(0, term_width - ellipsis);
2056 if (!ansi_prefix.empty())
2060 output->Printf(
"%s...", message.c_str());
2063 if (!ansi_suffix.empty())
2068 output->Printf(
"\x1B[K\r");
2080 data->Dump(stream.get());
2098 if (io_handler_thread) {
2102 "failed to launch host thread: {0}");
2130 if (!prefer_dummy) {
2148 language = *single_lang;
2149 }
else if (repl_languages.
Empty()) {
2151 "LLDB isn't configured with REPL support for any languages.");
2155 "Multiple possible REPL languages. Please specify a language.");
2175 repl_sp->SetCompilerOptions(repl_options);
2183 "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 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)
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)
static llvm::ThreadPool * g_thread_pool
#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)
static llvm::ThreadPool & GetThreadPool()
Shared thread poll. Use only with ThreadPoolTaskGroup.
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)
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()
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
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)
Report progress events.
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
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 LanguageSet GetLanguagesSupportingREPLs()
static const char * GetNameForLanguageType(lldb::LanguageType language)
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 SetMaximumValue(int64_t v)
void SetMinimumValue(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.