Author: Jonas Devlieghere Date: 2025-03-26T14:41:05-07:00 New Revision: 9c18edc62123e778d1d713df44aa05c91e7bbbae
URL: https://github.com/llvm/llvm-project/commit/9c18edc62123e778d1d713df44aa05c91e7bbbae DIFF: https://github.com/llvm/llvm-project/commit/9c18edc62123e778d1d713df44aa05c91e7bbbae.diff LOG: [lldb] Implement a statusline in LLDB (#121860) Add a statusline to command-line LLDB to display information about the current state of the debugger. The statusline is a dedicated area displayed at the bottom of the screen. The information displayed is configurable through a setting consisting of LLDB’s format strings. Enablement ---------- The statusline is enabled by default, but can be disabled with the following setting: ``` (lldb) settings set show-statusline false ``` Configuration ------------- The statusline is configurable through the `statusline-format` setting. The default configuration shows the target name, the current file, the stop reason and any ongoing progress events. ``` (lldb) settings show statusline-format statusline-format (format-string) = "${ansi.bg.blue}${ansi.fg.black}{${target.file.basename}}{ | ${line.file.basename}:${line.number}:${line.column}}{ | ${thread.stop-reason}}{ | {${progress.count} }${progress.message}}" ``` The statusline supersedes the current progress reporting implementation. Consequently, the following settings no longer have any effect (but continue to exist to not break anyone's `.lldbinit`): ``` show-progress -- Whether to show progress or not if the debugger's output is an interactive color-enabled terminal. show-progress-ansi-prefix -- When displaying progress in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the progress message. show-progress-ansi-suffix -- When displaying progress in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the progress message. ``` Format Strings -------------- LLDB's format strings are documented in the LLDB documentation and on the website: https://lldb.llvm.org/use/formatting.html#format-strings. The current implementation is relatively limited but various improvements have been discussed in the RFC. One such improvement is being to display a string when a format string is empty. Right now, when launching LLDB without a target, the statusline will be empty, which is expected, but looks rather odd. RFC --- The full RFC can be found on Discourse: https://discourse.llvm.org/t/rfc-lldb-statusline/83948 Added: lldb/include/lldb/Core/Statusline.h lldb/source/Core/Statusline.cpp lldb/test/API/functionalities/statusline/Makefile lldb/test/API/functionalities/statusline/TestStatusline.py lldb/test/API/functionalities/statusline/main.c Modified: lldb/include/lldb/Core/Debugger.h lldb/include/lldb/Core/FormatEntity.h lldb/include/lldb/Core/IOHandler.h lldb/include/lldb/Host/Editline.h lldb/packages/Python/lldbsuite/test/lldbtest.py lldb/source/Core/CMakeLists.txt lldb/source/Core/CoreProperties.td lldb/source/Core/Debugger.cpp lldb/source/Core/FormatEntity.cpp lldb/source/Core/IOHandler.cpp lldb/source/Host/common/Editline.cpp Removed: lldb/test/API/functionalities/progress_reporting/TestTrimmedProgressReporting.py ################################################################################ diff --git a/lldb/include/lldb/Core/Debugger.h b/lldb/include/lldb/Core/Debugger.h index 6ebc6147800e1..c79a75ab61564 100644 --- a/lldb/include/lldb/Core/Debugger.h +++ b/lldb/include/lldb/Core/Debugger.h @@ -19,6 +19,7 @@ #include "lldb/Core/FormatEntity.h" #include "lldb/Core/IOHandler.h" #include "lldb/Core/SourceManager.h" +#include "lldb/Core/Statusline.h" #include "lldb/Core/UserSettingsController.h" #include "lldb/Host/HostThread.h" #include "lldb/Host/StreamFile.h" @@ -303,6 +304,10 @@ class Debugger : public std::enable_shared_from_this<Debugger>, bool SetShowProgress(bool show_progress); + bool GetShowStatusline() const; + + const FormatEntity::Entry *GetStatuslineFormat() const; + llvm::StringRef GetShowProgressAnsiPrefix() const; llvm::StringRef GetShowProgressAnsiSuffix() const; @@ -412,6 +417,9 @@ class Debugger : public std::enable_shared_from_this<Debugger>, /// Decrement the "interrupt requested" counter. void CancelInterruptRequest(); + /// Redraw the statusline if enabled. + void RedrawStatusline(bool update = true); + /// This is the correct way to query the state of Interruption. /// If you are on the RunCommandInterpreter thread, it will check the /// command interpreter state, and if it is on another thread it will @@ -599,11 +607,20 @@ class Debugger : public std::enable_shared_from_this<Debugger>, return m_source_file_cache; } + struct ProgressReport { + uint64_t id; + uint64_t completed; + uint64_t total; + std::string message; + }; + std::optional<ProgressReport> GetCurrentProgressReport() const; + protected: friend class CommandInterpreter; friend class REPL; friend class Progress; friend class ProgressManager; + friend class Statusline; /// Report progress events. /// @@ -656,6 +673,8 @@ class Debugger : public std::enable_shared_from_this<Debugger>, lldb::LockableStreamFileSP GetErrorStreamSP() { return m_error_stream_sp; } /// @} + bool StatuslineSupported(); + void PushIOHandler(const lldb::IOHandlerSP &reader_sp, bool cancel_top_handler = true); @@ -732,7 +751,7 @@ class Debugger : public std::enable_shared_from_this<Debugger>, IOHandlerStack m_io_handler_stack; std::recursive_mutex m_io_handler_synchronous_mutex; - std::optional<uint64_t> m_current_event_id; + std::optional<Statusline> m_statusline; llvm::StringMap<std::weak_ptr<LogHandler>> m_stream_handlers; std::shared_ptr<CallbackLogHandler> m_callback_handler_sp; @@ -749,6 +768,12 @@ class Debugger : public std::enable_shared_from_this<Debugger>, lldb::TargetSP m_dummy_target_sp; Diagnostics::CallbackID m_diagnostics_callback_id; + /// Bookkeeping for command line progress events. + /// @{ + llvm::SmallVector<ProgressReport, 4> m_progress_reports; + mutable std::mutex m_progress_reports_mutex; + /// @} + std::mutex m_destroy_callback_mutex; lldb::callback_token_t m_destroy_callback_next_token = 0; struct DestroyCallbackInfo { diff --git a/lldb/include/lldb/Core/FormatEntity.h b/lldb/include/lldb/Core/FormatEntity.h index c9d5af1f31673..51e9ce37e54e7 100644 --- a/lldb/include/lldb/Core/FormatEntity.h +++ b/lldb/include/lldb/Core/FormatEntity.h @@ -100,7 +100,9 @@ struct Entry { LineEntryColumn, LineEntryStartAddress, LineEntryEndAddress, - CurrentPCArrow + CurrentPCArrow, + ProgressCount, + ProgressMessage, }; struct Definition { diff --git a/lldb/include/lldb/Core/IOHandler.h b/lldb/include/lldb/Core/IOHandler.h index fc0c676883b4a..794d229bc1337 100644 --- a/lldb/include/lldb/Core/IOHandler.h +++ b/lldb/include/lldb/Core/IOHandler.h @@ -406,6 +406,8 @@ class IOHandlerEditline : public IOHandler { std::optional<std::string> SuggestionCallback(llvm::StringRef line); void AutoCompleteCallback(CompletionRequest &request); + + void RedrawCallback(); #endif protected: diff --git a/lldb/include/lldb/Core/Statusline.h b/lldb/include/lldb/Core/Statusline.h new file mode 100644 index 0000000000000..c1449f0f69081 --- /dev/null +++ b/lldb/include/lldb/Core/Statusline.h @@ -0,0 +1,67 @@ +//===-- Statusline.h -----------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLDB_CORE_STATUSLINE_H +#define LLDB_CORE_STATUSLINE_H + +#include "lldb/lldb-forward.h" +#include "llvm/ADT/StringRef.h" +#include <csignal> +#include <cstdint> +#include <string> + +namespace lldb_private { +class Statusline { +public: + Statusline(Debugger &debugger); + ~Statusline(); + + /// Reduce the scroll window and draw the statusline. + void Enable(); + + /// Hide the statusline and extend the scroll window. + void Disable(); + + /// Redraw the statusline. If update is false, this will redraw the last + /// string. + void Redraw(bool update = true); + + /// Inform the statusline that the terminal dimensions have changed. + void TerminalSizeChanged(); + +protected: + /// Pad and trim the given string to fit to the given width. + static std::string TrimAndPad(std::string str, size_t width); + +private: + /// Draw the statusline with the given text. + void Draw(std::string msg); + + /// Update terminal dimensions. + void UpdateTerminalProperties(); + + enum ScrollWindowMode { + ScrollWindowExtend, + ScrollWindowShrink, + }; + + /// Set the scroll window for the given mode. + void UpdateScrollWindow(ScrollWindowMode mode); + + /// Clear the statusline (without redrawing the background). + void Reset(); + + Debugger &m_debugger; + std::string m_last_str; + + volatile std::sig_atomic_t m_terminal_size_has_changed = 1; + uint64_t m_terminal_width = 0; + uint64_t m_terminal_height = 0; +}; +} // namespace lldb_private +#endif // LLDB_CORE_STATUSLINE_H diff --git a/lldb/include/lldb/Host/Editline.h b/lldb/include/lldb/Host/Editline.h index 8964d37be8823..705ec9c49f7c7 100644 --- a/lldb/include/lldb/Host/Editline.h +++ b/lldb/include/lldb/Host/Editline.h @@ -102,6 +102,8 @@ using SuggestionCallbackType = using CompleteCallbackType = llvm::unique_function<void(CompletionRequest &)>; +using RedrawCallbackType = llvm::unique_function<void()>; + /// Status used to decide when and how to start editing another line in /// multi-line sessions. enum class EditorStatus { @@ -194,6 +196,11 @@ class Editline { m_suggestion_callback = std::move(callback); } + /// Register a callback for redrawing the statusline. + void SetRedrawCallback(RedrawCallbackType callback) { + m_redraw_callback = std::move(callback); + } + /// Register a callback for the tab key void SetAutoCompleteCallback(CompleteCallbackType callback) { m_completion_callback = std::move(callback); @@ -409,6 +416,7 @@ class Editline { CompleteCallbackType m_completion_callback; SuggestionCallbackType m_suggestion_callback; + RedrawCallbackType m_redraw_callback; bool m_color; std::string m_prompt_ansi_prefix; diff --git a/lldb/packages/Python/lldbsuite/test/lldbtest.py b/lldb/packages/Python/lldbsuite/test/lldbtest.py index f117aea001e27..a055314673d18 100644 --- a/lldb/packages/Python/lldbsuite/test/lldbtest.py +++ b/lldb/packages/Python/lldbsuite/test/lldbtest.py @@ -772,7 +772,10 @@ def setUpCommands(cls): 'settings set symbols.clang-modules-cache-path "{}"'.format( configuration.lldb_module_cache_dir ), + # Disable colors by default. "settings set use-color false", + # Disable the statusline by default. + "settings set show-statusline false", ] # Set any user-overridden settings. diff --git a/lldb/source/Core/CMakeLists.txt b/lldb/source/Core/CMakeLists.txt index d5d8a9d5088fc..e8bdb0613b3ff 100644 --- a/lldb/source/Core/CMakeLists.txt +++ b/lldb/source/Core/CMakeLists.txt @@ -46,6 +46,7 @@ add_lldb_library(lldbCore Opcode.cpp PluginManager.cpp Progress.cpp + Statusline.cpp RichManglingContext.cpp SearchFilter.cpp Section.cpp diff --git a/lldb/source/Core/CoreProperties.td b/lldb/source/Core/CoreProperties.td index d3816c3070bbc..01a04f9e79095 100644 --- a/lldb/source/Core/CoreProperties.td +++ b/lldb/source/Core/CoreProperties.td @@ -172,6 +172,14 @@ let Definition = "debugger" in { Global, DefaultStringValue<"${ansi.normal}">, Desc<"When displaying progress in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the progress message.">; + def ShowStatusline: Property<"show-statusline", "Boolean">, + Global, + DefaultTrue, + Desc<"Whether to show a statusline at the bottom of the terminal.">; + def StatuslineFormat: Property<"statusline-format", "FormatEntity">, + Global, + DefaultStringValue<"${ansi.bg.blue}${ansi.fg.black}{${target.file.basename}}{ | ${line.file.basename}:${line.number}:${line.column}}{ | ${thread.stop-reason}}{ | {${progress.count} }${progress.message}}">, + Desc<"The default statusline format string.">; def UseSourceCache: Property<"use-source-cache", "Boolean">, Global, DefaultTrue, diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp index 8c705f889983a..f3e98b3ab2d39 100644 --- a/lldb/source/Core/Debugger.cpp +++ b/lldb/source/Core/Debugger.cpp @@ -247,6 +247,18 @@ Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx, // Prompt colors changed. Ping the prompt so it can reset the ansi // terminal codes. SetPrompt(GetPrompt()); + } else if (property_path == + g_debugger_properties[ePropertyShowStatusline].name) { + // Statusline setting changed. If we have a statusline instance, update it + // now. Otherwise it will get created in the default event handler. + if (StatuslineSupported()) + m_statusline.emplace(*this); + else + m_statusline.reset(); + } else if (property_path == + g_debugger_properties[ePropertyStatuslineFormat].name) { + // Statusline format changed. Redraw the statusline. + RedrawStatusline(); } else if (property_path == g_debugger_properties[ePropertyUseSourceCache].name) { // use-source-cache changed. Wipe out the cache contents if it was @@ -379,6 +391,8 @@ bool Debugger::SetTerminalWidth(uint64_t term_width) { if (auto handler_sp = m_io_handler_stack.Top()) handler_sp->TerminalSizeChanged(); + if (m_statusline) + m_statusline->TerminalSizeChanged(); return success; } @@ -395,6 +409,8 @@ bool Debugger::SetTerminalHeight(uint64_t term_height) { if (auto handler_sp = m_io_handler_stack.Top()) handler_sp->TerminalSizeChanged(); + if (m_statusline) + m_statusline->TerminalSizeChanged(); return success; } @@ -457,6 +473,17 @@ llvm::StringRef Debugger::GetShowProgressAnsiSuffix() const { idx, g_debugger_properties[idx].default_cstr_value); } +bool Debugger::GetShowStatusline() const { + const uint32_t idx = ePropertyShowStatusline; + return GetPropertyAtIndexAs<bool>( + idx, g_debugger_properties[idx].default_uint_value != 0); +} + +const FormatEntity::Entry *Debugger::GetStatuslineFormat() const { + constexpr uint32_t idx = ePropertyStatuslineFormat; + return GetPropertyAtIndexAs<const FormatEntity::Entry *>(idx); +} + bool Debugger::GetUseAutosuggestion() const { const uint32_t idx = ePropertyShowAutosuggestion; return GetPropertyAtIndexAs<bool>( @@ -1114,12 +1141,23 @@ void Debugger::SetErrorFile(FileSP file_sp) { } void Debugger::SaveInputTerminalState() { + if (m_statusline) + m_statusline->Disable(); int fd = GetInputFile().GetDescriptor(); if (fd != File::kInvalidDescriptor) m_terminal_state.Save(fd, true); } -void Debugger::RestoreInputTerminalState() { m_terminal_state.Restore(); } +void Debugger::RestoreInputTerminalState() { + m_terminal_state.Restore(); + if (m_statusline) + m_statusline->Enable(); +} + +void Debugger::RedrawStatusline(bool update) { + if (m_statusline) + m_statusline->Redraw(update); +} ExecutionContext Debugger::GetSelectedExecutionContext() { bool adopt_selected = true; @@ -1943,6 +1981,17 @@ void Debugger::CancelForwardEvents(const ListenerSP &listener_sp) { m_forward_listener_sp.reset(); } +bool Debugger::StatuslineSupported() { + if (GetShowStatusline()) { + if (lldb::LockableStreamFileSP stream_sp = GetOutputStreamSP()) { + File &file = stream_sp->GetUnlockedFile(); + return file.GetIsInteractive() && file.GetIsRealTerminal() && + file.GetIsTerminalWithColors(); + } + } + return false; +} + lldb::thread_result_t Debugger::DefaultEventHandler() { ListenerSP listener_sp(GetListener()); ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass()); @@ -1982,6 +2031,9 @@ lldb::thread_result_t Debugger::DefaultEventHandler() { // are now listening to all required events so no events get missed m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening); + if (!m_statusline && StatuslineSupported()) + m_statusline.emplace(*this); + bool done = false; while (!done) { EventSP event_sp; @@ -2036,8 +2088,13 @@ lldb::thread_result_t Debugger::DefaultEventHandler() { if (m_forward_listener_sp) m_forward_listener_sp->AddEvent(event_sp); } + RedrawStatusline(); } } + + if (m_statusline) + m_statusline.reset(); + return {}; } @@ -2100,84 +2157,37 @@ void Debugger::HandleProgressEvent(const lldb::EventSP &event_sp) { if (!data) return; - // Do some bookkeeping for the current event, regardless of whether we're - // going to show the progress. - const uint64_t id = data->GetID(); - if (m_current_event_id) { - Log *log = GetLog(LLDBLog::Events); - if (log && log->GetVerbose()) { - StreamString log_stream; - log_stream.AsRawOstream() - << static_cast<void *>(this) << " Debugger(" << GetID() - << ")::HandleProgressEvent( m_current_event_id = " - << *m_current_event_id << ", data = { "; - data->Dump(&log_stream); - log_stream << " } )"; - log->PutString(log_stream.GetString()); - } - if (id != *m_current_event_id) - return; - if (data->GetCompleted() == data->GetTotal()) - m_current_event_id.reset(); - } else { - m_current_event_id = id; - } - - // Decide whether we actually are going to show the progress. This decision - // can change between iterations so check it inside the loop. - if (!GetShowProgress()) - return; + // Make a local copy of the incoming progress report that we'll store. + ProgressReport progress_report{data->GetID(), data->GetCompleted(), + data->GetTotal(), data->GetMessage()}; - // Determine whether the current output file is an interactive terminal with - // color support. We assume that if we support ANSI escape codes we support - // vt100 escape codes. - FileSP file_sp = GetOutputFileSP(); - if (!file_sp->GetIsInteractive() || !file_sp->GetIsTerminalWithColors()) - return; - - StreamUP output = GetAsyncOutputStream(); - - // Print over previous line, if any. - output->Printf("\r"); - - if (data->GetCompleted() == data->GetTotal()) { - // Clear the current line. - output->Printf("\x1B[2K"); - output->Flush(); - return; + // Do some bookkeeping regardless of whether we're going to display + // progress reports. + { + std::lock_guard<std::mutex> guard(m_progress_reports_mutex); + auto it = std::find_if( + m_progress_reports.begin(), m_progress_reports.end(), + [&](const auto &report) { return report.id == progress_report.id; }); + if (it != m_progress_reports.end()) { + const bool complete = data->GetCompleted() == data->GetTotal(); + if (complete) + m_progress_reports.erase(it); + else + *it = progress_report; + } else { + m_progress_reports.push_back(progress_report); + } } - // Trim the progress message if it exceeds the window's width and print it. - std::string message = data->GetMessage(); - if (data->IsFinite()) - message = llvm::formatv("[{0}/{1}] {2}", data->GetCompleted(), - data->GetTotal(), message) - .str(); - - // Trim the progress message if it exceeds the window's width and print it. - const uint32_t term_width = GetTerminalWidth(); - const uint32_t ellipsis = 3; - if (message.size() + ellipsis >= term_width) - message.resize(term_width - ellipsis); - - const bool use_color = GetUseColor(); - llvm::StringRef ansi_prefix = GetShowProgressAnsiPrefix(); - if (!ansi_prefix.empty()) - output->Printf( - "%s", ansi::FormatAnsiTerminalCodes(ansi_prefix, use_color).c_str()); - - output->Printf("%s...", message.c_str()); - - llvm::StringRef ansi_suffix = GetShowProgressAnsiSuffix(); - if (!ansi_suffix.empty()) - output->Printf( - "%s", ansi::FormatAnsiTerminalCodes(ansi_suffix, use_color).c_str()); - - // Clear until the end of the line. - output->Printf("\x1B[K\r"); + RedrawStatusline(); +} - // Flush the output. - output->Flush(); +std::optional<Debugger::ProgressReport> +Debugger::GetCurrentProgressReport() const { + std::lock_guard<std::mutex> guard(m_progress_reports_mutex); + if (m_progress_reports.empty()) + return std::nullopt; + return m_progress_reports.back(); } void Debugger::HandleDiagnosticEvent(const lldb::EventSP &event_sp) { diff --git a/lldb/source/Core/FormatEntity.cpp b/lldb/source/Core/FormatEntity.cpp index 7fe22994d7f7e..04dea7efde54d 100644 --- a/lldb/source/Core/FormatEntity.cpp +++ b/lldb/source/Core/FormatEntity.cpp @@ -166,6 +166,10 @@ constexpr Definition g_target_child_entries[] = { Entry::DefinitionWithChildren("file", EntryType::TargetFile, g_file_child_entries)}; +constexpr Definition g_progress_child_entries[] = { + Definition("count", EntryType::ProgressCount), + Definition("message", EntryType::ProgressMessage)}; + #define _TO_STR2(_val) #_val #define _TO_STR(_val) _TO_STR2(_val) @@ -259,7 +263,10 @@ constexpr Definition g_top_level_entries[] = { Entry::DefinitionWithChildren("target", EntryType::Invalid, g_target_child_entries), Entry::DefinitionWithChildren("var", EntryType::Variable, - g_var_child_entries, true)}; + g_var_child_entries, true), + Entry::DefinitionWithChildren("progress", EntryType::Invalid, + g_progress_child_entries), +}; constexpr Definition g_root = Entry::DefinitionWithChildren( "<root>", EntryType::Root, g_top_level_entries); @@ -358,6 +365,8 @@ const char *FormatEntity::Entry::TypeToCString(Type t) { ENUM_TO_CSTR(LineEntryStartAddress); ENUM_TO_CSTR(LineEntryEndAddress); ENUM_TO_CSTR(CurrentPCArrow); + ENUM_TO_CSTR(ProgressCount); + ENUM_TO_CSTR(ProgressMessage); } return "???"; } @@ -1198,12 +1207,10 @@ bool FormatEntity::Format(const Entry &entry, Stream &s, // FormatEntity::Entry::Definition encoding return false; case Entry::Type::EscapeCode: - if (exe_ctx) { - if (Target *target = exe_ctx->GetTargetPtr()) { - Debugger &debugger = target->GetDebugger(); - if (debugger.GetUseColor()) { - s.PutCString(entry.string); - } + if (Target *target = Target::GetTargetFromContexts(exe_ctx, sc)) { + Debugger &debugger = target->GetDebugger(); + if (debugger.GetUseColor()) { + s.PutCString(entry.string); } } // Always return true, so colors being disabled is transparent. @@ -1912,7 +1919,28 @@ bool FormatEntity::Format(const Entry &entry, Stream &s, return true; } return false; + + case Entry::Type::ProgressCount: + if (Target *target = Target::GetTargetFromContexts(exe_ctx, sc)) { + if (auto progress = target->GetDebugger().GetCurrentProgressReport()) { + if (progress->total != UINT64_MAX) { + s.Format("[{0}/{1}]", progress->completed, progress->total); + return true; + } + } + } + return false; + + case Entry::Type::ProgressMessage: + if (Target *target = Target::GetTargetFromContexts(exe_ctx, sc)) { + if (auto progress = target->GetDebugger().GetCurrentProgressReport()) { + s.PutCString(progress->message); + return true; + } + } + return false; } + return false; } diff --git a/lldb/source/Core/IOHandler.cpp b/lldb/source/Core/IOHandler.cpp index 98d14758f1987..d336cb0592d5b 100644 --- a/lldb/source/Core/IOHandler.cpp +++ b/lldb/source/Core/IOHandler.cpp @@ -258,6 +258,7 @@ IOHandlerEditline::IOHandlerEditline( m_editline_up->SetAutoCompleteCallback([this](CompletionRequest &request) { this->AutoCompleteCallback(request); }); + m_editline_up->SetRedrawCallback([this]() { this->RedrawCallback(); }); if (debugger.GetUseAutosuggestion()) { m_editline_up->SetSuggestionCallback([this](llvm::StringRef line) { @@ -439,6 +440,11 @@ IOHandlerEditline::SuggestionCallback(llvm::StringRef line) { void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request) { m_delegate.IOHandlerComplete(*this, request); } + +void IOHandlerEditline::RedrawCallback() { + m_debugger.RedrawStatusline(/*update=*/false); +} + #endif const char *IOHandlerEditline::GetPrompt() { diff --git a/lldb/source/Core/Statusline.cpp b/lldb/source/Core/Statusline.cpp new file mode 100644 index 0000000000000..2418a03ba40c5 --- /dev/null +++ b/lldb/source/Core/Statusline.cpp @@ -0,0 +1,163 @@ +//===-- Statusline.cpp ---------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "lldb/Core/Statusline.h" +#include "lldb/Core/Debugger.h" +#include "lldb/Core/FormatEntity.h" +#include "lldb/Host/StreamFile.h" +#include "lldb/Interpreter/CommandInterpreter.h" +#include "lldb/Symbol/SymbolContext.h" +#include "lldb/Target/StackFrame.h" +#include "lldb/Utility/AnsiTerminal.h" +#include "lldb/Utility/StreamString.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Locale.h" + +#define ESCAPE "\x1b" +#define ANSI_NORMAL ESCAPE "[0m" +#define ANSI_SAVE_CURSOR ESCAPE "7" +#define ANSI_RESTORE_CURSOR ESCAPE "8" +#define ANSI_CLEAR_BELOW ESCAPE "[J" +#define ANSI_CLEAR_LINE "\r\x1B[2K" +#define ANSI_SET_SCROLL_ROWS ESCAPE "[0;%ur" +#define ANSI_TO_START_OF_ROW ESCAPE "[%u;0f" +#define ANSI_UP_ROWS ESCAPE "[%dA" + +using namespace lldb; +using namespace lldb_private; + +Statusline::Statusline(Debugger &debugger) : m_debugger(debugger) { Enable(); } + +Statusline::~Statusline() { Disable(); } + +void Statusline::TerminalSizeChanged() { + m_terminal_size_has_changed = 1; + + // This definitely isn't signal safe, but the best we can do, until we + // have proper signal-catching thread. + Redraw(/*update=*/false); +} + +void Statusline::Enable() { + UpdateTerminalProperties(); + + // Reduce the scroll window to make space for the status bar below. + UpdateScrollWindow(ScrollWindowShrink); + + // Draw the statusline. + Redraw(); +} + +void Statusline::Disable() { + UpdateTerminalProperties(); + + // Extend the scroll window to cover the status bar. + UpdateScrollWindow(ScrollWindowExtend); +} + +void Statusline::Draw(std::string str) { + lldb::LockableStreamFileSP stream_sp = m_debugger.GetOutputStreamSP(); + if (!stream_sp) + return; + + UpdateTerminalProperties(); + + m_last_str = str; + + str = ansi::TrimAndPad(str, m_terminal_width); + + LockedStreamFile locked_stream = stream_sp->Lock(); + locked_stream << ANSI_SAVE_CURSOR; + locked_stream.Printf(ANSI_TO_START_OF_ROW, + static_cast<unsigned>(m_terminal_height)); + locked_stream << ANSI_CLEAR_LINE; + locked_stream << str; + locked_stream << ANSI_NORMAL; + locked_stream << ANSI_RESTORE_CURSOR; +} + +void Statusline::Reset() { + lldb::LockableStreamFileSP stream_sp = m_debugger.GetOutputStreamSP(); + if (!stream_sp) + return; + + LockedStreamFile locked_stream = stream_sp->Lock(); + locked_stream << ANSI_SAVE_CURSOR; + locked_stream.Printf(ANSI_TO_START_OF_ROW, + static_cast<unsigned>(m_terminal_height)); + locked_stream << ANSI_CLEAR_LINE; + locked_stream << ANSI_RESTORE_CURSOR; +} + +void Statusline::UpdateTerminalProperties() { + if (m_terminal_size_has_changed == 0) + return; + + // Clear the previous statusline using the previous dimensions. + Reset(); + + m_terminal_width = m_debugger.GetTerminalWidth(); + m_terminal_height = m_debugger.GetTerminalHeight(); + + // Set the scroll window based on the new terminal height. + UpdateScrollWindow(ScrollWindowShrink); + + // Clear the flag. + m_terminal_size_has_changed = 0; +} + +void Statusline::UpdateScrollWindow(ScrollWindowMode mode) { + lldb::LockableStreamFileSP stream_sp = m_debugger.GetOutputStreamSP(); + if (!stream_sp) + return; + + const unsigned scroll_height = + (mode == ScrollWindowExtend) ? m_terminal_height : m_terminal_height - 1; + + LockedStreamFile locked_stream = stream_sp->Lock(); + locked_stream << ANSI_SAVE_CURSOR; + locked_stream.Printf(ANSI_SET_SCROLL_ROWS, scroll_height); + locked_stream << ANSI_RESTORE_CURSOR; + switch (mode) { + case ScrollWindowExtend: + // Clear the screen below to hide the old statusline. + locked_stream << ANSI_CLEAR_BELOW; + break; + case ScrollWindowShrink: + // Move everything on the screen up. + locked_stream.Printf(ANSI_UP_ROWS, 1); + locked_stream << '\n'; + break; + } +} + +void Statusline::Redraw(bool update) { + if (!update) { + Draw(m_last_str); + return; + } + + StreamString stream; + ExecutionContext exe_ctx = + m_debugger.GetCommandInterpreter().GetExecutionContext(); + + // For colors and progress events, the format entity needs access to the + // debugger, which requires a target in the execution context. + if (!exe_ctx.HasTargetScope()) + exe_ctx.SetTargetPtr(&m_debugger.GetSelectedOrDummyTarget()); + + SymbolContext symbol_ctx; + if (auto frame_sp = exe_ctx.GetFrameSP()) + symbol_ctx = frame_sp->GetSymbolContext(eSymbolContextEverything); + + if (auto *format = m_debugger.GetStatuslineFormat()) + FormatEntity::Format(*format, stream, &symbol_ctx, &exe_ctx, nullptr, + nullptr, false, false); + + Draw(std::string(stream.GetString())); +} diff --git a/lldb/source/Host/common/Editline.cpp b/lldb/source/Host/common/Editline.cpp index 5f7a8b0190a1d..29abaf7c65f28 100644 --- a/lldb/source/Host/common/Editline.cpp +++ b/lldb/source/Host/common/Editline.cpp @@ -567,6 +567,9 @@ int Editline::GetCharacter(EditLineGetCharType *c) { m_needs_prompt_repaint = false; } + if (m_redraw_callback) + m_redraw_callback(); + if (m_multiline_enabled) { // Detect when the number of rows used for this input line changes due to // an edit diff --git a/lldb/test/API/functionalities/progress_reporting/TestTrimmedProgressReporting.py b/lldb/test/API/functionalities/progress_reporting/TestTrimmedProgressReporting.py deleted file mode 100644 index 3cf7b9d210089..0000000000000 --- a/lldb/test/API/functionalities/progress_reporting/TestTrimmedProgressReporting.py +++ /dev/null @@ -1,51 +0,0 @@ -""" -Test trimming long progress report in tiny terminal windows -""" - -import os -import tempfile -import re - -import lldb -from lldbsuite.test.decorators import * -from lldbsuite.test.lldbtest import * -from lldbsuite.test.lldbpexpect import PExpectTest - - -class TestTrimmedProgressReporting(PExpectTest): - def do_test(self, term_width, pattern_list): - self.build() - # Start with a small window - self.launch(use_colors=True) - self.expect("set set show-progress true") - self.expect( - "set show show-progress", substrs=["show-progress (boolean) = true"] - ) - self.expect("set set term-width " + str(term_width)) - self.expect( - "set show term-width", - substrs=["term-width (unsigned) = " + str(term_width)], - ) - - self.child.send("file " + self.getBuildArtifact("a.out") + "\n") - self.child.expect(pattern_list) - - # PExpect uses many timeouts internally and doesn't play well - # under ASAN on a loaded machine.. - @skipIfAsan - @skipIfEditlineSupportMissing - def test_trimmed_progress_message(self): - self.do_test(19, ["Locating e...", "Parsing sy..."]) - - # PExpect uses many timeouts internally and doesn't play well - # under ASAN on a loaded machine.. - @skipIfAsan - @skipIfEditlineSupportMissing - def test_long_progress_message(self): - self.do_test( - 80, - [ - "Locating external symbol file", - "Parsing symbol table", - ], - ) diff --git a/lldb/test/API/functionalities/statusline/Makefile b/lldb/test/API/functionalities/statusline/Makefile new file mode 100644 index 0000000000000..10495940055b6 --- /dev/null +++ b/lldb/test/API/functionalities/statusline/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/lldb/test/API/functionalities/statusline/TestStatusline.py b/lldb/test/API/functionalities/statusline/TestStatusline.py new file mode 100644 index 0000000000000..a58dc5470ed6d --- /dev/null +++ b/lldb/test/API/functionalities/statusline/TestStatusline.py @@ -0,0 +1,57 @@ +import lldb +import re + +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test.lldbpexpect import PExpectTest + + +class TestStatusline(PExpectTest): + def do_setup(self): + # Create a target and run to a breakpoint. + exe = self.getBuildArtifact("a.out") + self.expect( + "target create {}".format(exe), substrs=["Current executable set to"] + ) + self.expect('breakpoint set -p "Break here"', substrs=["Breakpoint 1"]) + self.expect("run", substrs=["stop reason"]) + + # PExpect uses many timeouts internally and doesn't play well + # under ASAN on a loaded machine.. + @skipIfAsan + def test(self): + """Basic test for the statusline.""" + self.build() + self.launch() + self.do_setup() + + # Change the terminal dimensions. + terminal_height = 10 + terminal_width = 60 + self.child.setwinsize(terminal_height, terminal_width) + + # Enable the statusline and check for the control character and that we + # can see the target, the location and the stop reason. + self.expect( + "set set show-statusline true", + [ + "\x1b[0;{}r".format(terminal_height - 1), + "a.out | main.c:2:11 | breakpoint 1.1 ", + ], + ) + + # Change the terminal dimensions and make sure it's reflected immediately. + self.child.setwinsize(terminal_height, 25) + self.child.expect(re.escape("a.out | main.c:2:11 | bre")) + self.child.setwinsize(terminal_height, terminal_width) + + # Change the format. + self.expect( + 'set set statusline-format "target = {${target.file.basename}}"', + ["target = a.out"], + ) + + # Hide the statusline and check or the control character. + self.expect( + "set set show-statusline false", ["\x1b[0;{}r".format(terminal_height)] + ) diff --git a/lldb/test/API/functionalities/statusline/main.c b/lldb/test/API/functionalities/statusline/main.c new file mode 100644 index 0000000000000..7182181ba2492 --- /dev/null +++ b/lldb/test/API/functionalities/statusline/main.c @@ -0,0 +1,9 @@ +int foo(int f) { + int b = f * f; // Break here + return b; +} + +int main() { + int f = foo(42); + return f; +} _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
