OmarEmaraDev created this revision.
OmarEmaraDev added a reviewer: clayborg.
Herald added a reviewer: teemperor.
OmarEmaraDev requested review of this revision.
Herald added a project: LLDB.
Herald added a subscriber: lldb-commits.
This patch adds a breakpoints window that lists all breakpoints and
breakpoints locations. The window is implemented as a tree, where the
first level is the breakpoints and the second level is breakpoints
locations.
The tree delegate was hardcoded to only draw when there is a process,
which is not necessary for breakpoints, so the relevant logic was
abstracted in the TreeDelegateShouldDraw method.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D107386
Files:
lldb/source/Core/IOHandlerCursesGUI.cpp
Index: lldb/source/Core/IOHandlerCursesGUI.cpp
===================================================================
--- lldb/source/Core/IOHandlerCursesGUI.cpp
+++ lldb/source/Core/IOHandlerCursesGUI.cpp
@@ -3772,9 +3772,14 @@
TreeItem *&selected_item) {
return;
}
- virtual bool TreeDelegateItemSelected(
- TreeItem &item) = 0; // Return true if we need to update views
+ // This is invoked when a tree item is selected. If true is returned, the
+ // views are updated.
+ virtual bool TreeDelegateItemSelected(TreeItem &item) = 0;
virtual bool TreeDelegateExpandRootByDefault() { return false; }
+ // This is mostly useful for root tree delegates. If false is returned,
+ // drawing will be skipped completely. This is needed, for instance, in
+ // skipping drawing of the threads tree if there is no running process.
+ virtual bool TreeDelegateShouldDraw() { return true; }
};
typedef std::shared_ptr<TreeDelegate> TreeDelegateSP;
@@ -3989,21 +3994,6 @@
int NumVisibleRows() const { return m_max_y - m_min_y; }
bool WindowDelegateDraw(Window &window, bool force) override {
- ExecutionContext exe_ctx(
- m_debugger.GetCommandInterpreter().GetExecutionContext());
- Process *process = exe_ctx.GetProcessPtr();
-
- bool display_content = false;
- if (process) {
- StateType state = process->GetState();
- if (StateIsStoppedState(state, true)) {
- // We are stopped, so it is ok to
- display_content = true;
- } else if (StateIsRunningState(state)) {
- return true; // Don't do any updating when we are running
- }
- }
-
m_min_x = 2;
m_min_y = 1;
m_max_x = window.GetWidth() - 1;
@@ -4012,35 +4002,36 @@
window.Erase();
window.DrawTitleBox(window.GetName());
- if (display_content) {
- const int num_visible_rows = NumVisibleRows();
- m_num_rows = 0;
- m_root.CalculateRowIndexes(m_num_rows);
- m_delegate_sp->TreeDelegateUpdateSelection(m_root, m_selected_row_idx,
- m_selected_item);
-
- // If we unexpanded while having something selected our total number of
- // rows is less than the num visible rows, then make sure we show all the
- // rows by setting the first visible row accordingly.
- if (m_first_visible_row > 0 && m_num_rows < num_visible_rows)
- m_first_visible_row = 0;
-
- // Make sure the selected row is always visible
- if (m_selected_row_idx < m_first_visible_row)
- m_first_visible_row = m_selected_row_idx;
- else if (m_first_visible_row + num_visible_rows <= m_selected_row_idx)
- m_first_visible_row = m_selected_row_idx - num_visible_rows + 1;
-
- int row_idx = 0;
- int num_rows_left = num_visible_rows;
- m_root.Draw(window, m_first_visible_row, m_selected_row_idx, row_idx,
- num_rows_left);
- // Get the selected row
- m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
- } else {
+ if (!m_delegate_sp->TreeDelegateShouldDraw()) {
m_selected_item = nullptr;
+ return true;
}
+ const int num_visible_rows = NumVisibleRows();
+ m_num_rows = 0;
+ m_root.CalculateRowIndexes(m_num_rows);
+ m_delegate_sp->TreeDelegateUpdateSelection(m_root, m_selected_row_idx,
+ m_selected_item);
+
+ // If we unexpanded while having something selected our total number of
+ // rows is less than the num visible rows, then make sure we show all the
+ // rows by setting the first visible row accordingly.
+ if (m_first_visible_row > 0 && m_num_rows < num_visible_rows)
+ m_first_visible_row = 0;
+
+ // Make sure the selected row is always visible
+ if (m_selected_row_idx < m_first_visible_row)
+ m_first_visible_row = m_selected_row_idx;
+ else if (m_first_visible_row + num_visible_rows <= m_selected_row_idx)
+ m_first_visible_row = m_selected_row_idx - num_visible_rows + 1;
+
+ int row_idx = 0;
+ int num_rows_left = num_visible_rows;
+ m_root.Draw(window, m_first_visible_row, m_selected_row_idx, row_idx,
+ num_rows_left);
+ // Get the selected row
+ m_selected_item = m_root.GetItemForRowIndex(m_selected_row_idx);
+
return true; // Drawing handled
}
@@ -4332,6 +4323,18 @@
.GetProcessSP();
}
+ bool TreeDelegateShouldDraw() override {
+ ProcessSP process = GetProcess();
+ if (!process)
+ return false;
+
+ if (StateIsRunningState(process->GetState())) {
+ return false;
+ }
+
+ return true;
+ }
+
void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
ProcessSP process_sp = GetProcess();
if (process_sp && process_sp->IsAlive()) {
@@ -4423,6 +4426,134 @@
FormatEntity::Entry m_format;
};
+class BreakpointLocationTreeDelegate : public TreeDelegate {
+public:
+ BreakpointLocationTreeDelegate(Debugger &debugger)
+ : TreeDelegate(), m_debugger(debugger) {}
+
+ ~BreakpointLocationTreeDelegate() override = default;
+
+ BreakpointLocationSP GetBreakpointLocation(const TreeItem &item) {
+ Breakpoint *breakpoint = (Breakpoint *)item.GetUserData();
+ return breakpoint->GetLocationAtIndex(item.GetIdentifier());
+ }
+
+ void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
+ BreakpointLocationSP breakpoint_location = GetBreakpointLocation(item);
+ StreamString stream;
+ SymbolContext symbol_context;
+ Address address = breakpoint_location->GetAddress();
+ address.CalculateSymbolContext(&symbol_context);
+ Process *process = m_debugger.GetSelectedTarget()->GetProcessSP().get();
+ symbol_context.DumpStopContext(&stream, process, address,
+ false, /* Show full paths. */
+ false, /* Show module. */
+ false, /* Show in-lined frames. */
+ false, /* Show function arguments. */
+ true /* Show function name. */);
+ window.PutCStringTruncated(1, stream.GetString().str().c_str());
+ }
+
+ void TreeDelegateGenerateChildren(TreeItem &item) override {}
+
+ bool TreeDelegateItemSelected(TreeItem &item) override { return false; }
+
+protected:
+ Debugger &m_debugger;
+};
+
+class BreakpointTreeDelegate : public TreeDelegate {
+public:
+ BreakpointTreeDelegate(Debugger &debugger)
+ : TreeDelegate(), m_debugger(debugger),
+ m_breakpoint_location_delegate_sp() {}
+
+ ~BreakpointTreeDelegate() override = default;
+
+ BreakpointSP GetBreakpoint(const TreeItem &item) {
+ TargetSP target = m_debugger.GetSelectedTarget();
+ BreakpointList &breakpoints = target->GetBreakpointList(false);
+ return breakpoints.GetBreakpointAtIndex(item.GetIdentifier());
+ }
+
+ void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
+ BreakpointSP breakpoint = GetBreakpoint(item);
+ StreamString stream;
+ breakpoint->GetResolverDescription(&stream);
+ breakpoint->GetFilterDescription(&stream);
+ window.PutCStringTruncated(1, stream.GetString().str().c_str());
+ }
+
+ void TreeDelegateGenerateChildren(TreeItem &item) override {
+ BreakpointSP breakpoint = GetBreakpoint(item);
+
+ if (!m_breakpoint_location_delegate_sp)
+ m_breakpoint_location_delegate_sp =
+ std::make_shared<BreakpointLocationTreeDelegate>(m_debugger);
+ TreeItem breakpoint_location_tree_item(
+ &item, *m_breakpoint_location_delegate_sp, true);
+
+ item.Resize(breakpoint->GetNumLocations(), breakpoint_location_tree_item);
+ for (size_t i = 0; i < breakpoint->GetNumLocations(); i++) {
+ item[i].SetIdentifier(i);
+ item[i].SetUserData(breakpoint.get());
+ }
+ }
+
+ bool TreeDelegateItemSelected(TreeItem &item) override { return false; }
+
+protected:
+ Debugger &m_debugger;
+ std::shared_ptr<BreakpointLocationTreeDelegate>
+ m_breakpoint_location_delegate_sp;
+};
+
+class BreakpointsTreeDelegate : public TreeDelegate {
+public:
+ BreakpointsTreeDelegate(Debugger &debugger)
+ : TreeDelegate(), m_debugger(debugger), m_breakpoint_delegate_sp() {}
+
+ ~BreakpointsTreeDelegate() override = default;
+
+ bool TreeDelegateShouldDraw() override {
+ TargetSP target = m_debugger.GetSelectedTarget();
+ if (!target)
+ return false;
+
+ return true;
+ }
+
+ void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) override {
+ window.PutCString("Breakpoints");
+ }
+
+ void TreeDelegateGenerateChildren(TreeItem &item) override {
+ TargetSP target = m_debugger.GetSelectedTarget();
+
+ BreakpointList &breakpoints = target->GetBreakpointList(false);
+ std::unique_lock<std::recursive_mutex> lock;
+ breakpoints.GetListMutex(lock);
+
+ if (!m_breakpoint_delegate_sp)
+ m_breakpoint_delegate_sp =
+ std::make_shared<BreakpointTreeDelegate>(m_debugger);
+ TreeItem breakpoint_tree_item(&item, *m_breakpoint_delegate_sp, true);
+
+ item.Resize(breakpoints.GetSize(), breakpoint_tree_item);
+ for (size_t i = 0; i < breakpoints.GetSize(); i++) {
+ item[i].SetIdentifier(i);
+ }
+ }
+
+ bool TreeDelegateItemSelected(TreeItem &item) override { return false; }
+
+ bool TreeDelegateExpandRootByDefault() override { return true; }
+
+protected:
+ Debugger &m_debugger;
+ std::shared_ptr<BreakpointTreeDelegate> m_breakpoint_delegate_sp;
+};
+
class ValueObjectListDelegate : public WindowDelegate {
public:
ValueObjectListDelegate() : m_rows() {}
@@ -5224,6 +5355,7 @@
eMenuID_ViewRegisters,
eMenuID_ViewSource,
eMenuID_ViewVariables,
+ eMenuID_ViewBreakpoints,
eMenuID_Help,
eMenuID_HelpGUIHelp
@@ -5547,6 +5679,39 @@
}
return MenuActionResult::Handled;
+ case eMenuID_ViewBreakpoints: {
+ WindowSP main_window_sp = m_app.GetMainWindow();
+ WindowSP threads_window_sp = main_window_sp->FindSubWindow("Threads");
+ WindowSP breakpoints_window_sp =
+ main_window_sp->FindSubWindow("Breakpoints");
+ const Rect threads_bounds = threads_window_sp->GetBounds();
+
+ // If a breakpoints window already exists, remove it and give the area it
+ // used to occupy to the threads window. If it doesn't exist, split the
+ // threads window horizontally into two windows where the top window is
+ // the threads window and the bottom window is a newly added breakpoints
+ // window.
+ if (breakpoints_window_sp) {
+ threads_window_sp->Resize(threads_bounds.size.width,
+ threads_bounds.size.height +
+ breakpoints_window_sp->GetHeight());
+ main_window_sp->RemoveSubWindow(breakpoints_window_sp.get());
+ } else {
+ Rect new_threads_bounds, breakpoints_bounds;
+ threads_bounds.HorizontalSplitPercentage(0.70, new_threads_bounds,
+ breakpoints_bounds);
+ threads_window_sp->SetBounds(new_threads_bounds);
+ breakpoints_window_sp = main_window_sp->CreateSubWindow(
+ "Breakpoints", breakpoints_bounds, false);
+ TreeDelegateSP breakpoints_delegate_sp(
+ new BreakpointsTreeDelegate(m_debugger));
+ breakpoints_window_sp->SetDelegate(WindowDelegateSP(
+ new TreeWindowDelegate(m_debugger, breakpoints_delegate_sp)));
+ }
+ touchwin(stdscr);
+ return MenuActionResult::Handled;
+ }
+
case eMenuID_HelpGUIHelp:
m_app.GetMainWindow()->CreateHelpSubwindow();
return MenuActionResult::Handled;
@@ -6477,6 +6642,9 @@
view_menu_sp->AddSubmenu(
MenuSP(new Menu("Variables", nullptr, 'v',
ApplicationDelegate::eMenuID_ViewVariables)));
+ view_menu_sp->AddSubmenu(
+ MenuSP(new Menu("Breakpoints", nullptr, 'k',
+ ApplicationDelegate::eMenuID_ViewBreakpoints)));
MenuSP help_menu_sp(
new Menu("Help", "F6", KEY_F(6), ApplicationDelegate::eMenuID_Help));
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
