Implement breakpoint enable/disable improvements

- Consolidate context menu: replace Enable/Disable/Toggle with single Toggle action
- Add Enable All, Disable All, and Solo Breakpoint context menu actions
- Update render layer to only show enabled breakpoints
- Add context menu actions in debugger for enable/disable with dynamic visibility
- Make Python API DebugBreakpoint.enabled field read-only
- Add enable_breakpoint() and disable_breakpoint() to Python API

Co-authored-by: xusheng6 <94503187+xusheng6@users.noreply.github.com>

Author: Copilot

api/python/debuggercontroller.py

@@ -260,7 +260,7 @@ class DebugBreakpoint:
     * ``module``: the name of the module for which the breakpoint is in
     * ``offset``: the offset of the breakpoint to the start of the module
     * ``address``: the absolute address of the breakpoint
-    * ``enabled``: not used
+    * ``enabled``: whether the breakpoint is enabled (read-only)
 
     """
     def __init__(self, module, offset, address, enabled):
@@ -281,7 +281,7 @@ def __ne__(self, other):
         return not (self == other)
 
     def __hash__(self):
-        return hash((self.module, self.offset, self.address. self.enabled))
+        return hash((self.module, self.offset, self.address, self.enabled))
 
     def __setattr__(self, name, value):
         try:
@@ -290,7 +290,8 @@ def __setattr__(self, name, value):
             raise AttributeError(f"attribute '{name}' is read only")
 
     def __repr__(self):
-        return f"<DebugBreakpoint: {self.module}:{self.offset:#x}, {self.address:#x}>"
+        status = "enabled" if self.enabled else "disabled"
+        return f"<DebugBreakpoint: {self.module}:{self.offset:#x}, {self.address:#x}, {status}>"
 
 
 class ModuleNameAndOffset:
@@ -1958,6 +1959,38 @@ def has_breakpoint(self, address) -> bool:
         else:
             raise NotImplementedError
 
+    def enable_breakpoint(self, address):
+        """
+        Enable a breakpoint
+
+        The input can be either an absolute address, or a ModuleNameAndOffset, which specifies a relative address to the
+        start of a module. The latter is useful for ASLR.
+
+        :param address: the address of breakpoint to enable
+        """
+        if isinstance(address, int):
+            dbgcore.BNDebuggerEnableAbsoluteBreakpoint(self.handle, address)
+        elif isinstance(address, ModuleNameAndOffset):
+            dbgcore.BNDebuggerEnableRelativeBreakpoint(self.handle, address.module, address.offset)
+        else:
+            raise NotImplementedError
+
+    def disable_breakpoint(self, address):
+        """
+        Disable a breakpoint
+
+        The input can be either an absolute address, or a ModuleNameAndOffset, which specifies a relative address to the
+        start of a module. The latter is useful for ASLR.
+
+        :param address: the address of breakpoint to disable
+        """
+        if isinstance(address, int):
+            dbgcore.BNDebuggerDisableAbsoluteBreakpoint(self.handle, address)
+        elif isinstance(address, ModuleNameAndOffset):
+            dbgcore.BNDebuggerDisableRelativeBreakpoint(self.handle, address.module, address.offset)
+        else:
+            raise NotImplementedError
+
     @property
     def ip(self) -> int:
         """

ui/breakpointswidget.cpp

@@ -292,23 +292,29 @@ DebugBreakpointsWidget::DebugBreakpointsWidget(ViewFrame* view, BinaryViewRef da
 	m_actionHandler.bindAction(
 		addBreakpointActionName, UIAction([&]() { add(); }));
 
-	QString enableBreakpointActionName = QString::fromStdString("Enable Breakpoint");
-	UIAction::registerAction(enableBreakpointActionName);
-	m_menu->addAction(enableBreakpointActionName, "Options", MENU_ORDER_NORMAL);
+	QString toggleBreakpointActionName = QString::fromStdString("Toggle Breakpoint");
+	UIAction::registerAction(toggleBreakpointActionName, QKeySequence("Ctrl+Shift+B"));
+	m_menu->addAction(toggleBreakpointActionName, "Options", MENU_ORDER_NORMAL);
 	m_actionHandler.bindAction(
-		enableBreakpointActionName, UIAction([&]() { enableSelected(); }, [&]() { return selectionNotEmpty(); }));
+		toggleBreakpointActionName, UIAction([&]() { toggleSelected(); }, [&]() { return selectionNotEmpty(); }));
 
-	QString disableBreakpointActionName = QString::fromStdString("Disable Breakpoint");
-	UIAction::registerAction(disableBreakpointActionName);
-	m_menu->addAction(disableBreakpointActionName, "Options", MENU_ORDER_NORMAL);
+	QString enableAllActionName = QString::fromStdString("Enable All Breakpoints");
+	UIAction::registerAction(enableAllActionName);
+	m_menu->addAction(enableAllActionName, "Options", MENU_ORDER_NORMAL);
 	m_actionHandler.bindAction(
-		disableBreakpointActionName, UIAction([&]() { disableSelected(); }, [&]() { return selectionNotEmpty(); }));
+		enableAllActionName, UIAction([&]() { enableAll(); }));
 
-	QString toggleBreakpointActionName = QString::fromStdString("Toggle Breakpoint Enable/Disable");
-	UIAction::registerAction(toggleBreakpointActionName, QKeySequence("Ctrl+Shift+B"));
-	m_menu->addAction(toggleBreakpointActionName, "Options", MENU_ORDER_NORMAL);
+	QString disableAllActionName = QString::fromStdString("Disable All Breakpoints");
+	UIAction::registerAction(disableAllActionName);
+	m_menu->addAction(disableAllActionName, "Options", MENU_ORDER_NORMAL);
 	m_actionHandler.bindAction(
-		toggleBreakpointActionName, UIAction([&]() { toggleSelected(); }, [&]() { return selectionNotEmpty(); }));
+		disableAllActionName, UIAction([&]() { disableAll(); }));
+
+	QString soloBreakpointActionName = QString::fromStdString("Solo Breakpoint");
+	UIAction::registerAction(soloBreakpointActionName);
+	m_menu->addAction(soloBreakpointActionName, "Options", MENU_ORDER_NORMAL);
+	m_actionHandler.bindAction(
+		soloBreakpointActionName, UIAction([&]() { soloSelected(); }, [&]() { return selectionNotEmpty(); }));
 
 	connect(this, &QTableView::doubleClicked, this, &DebugBreakpointsWidget::onDoubleClicked);
 
@@ -456,39 +462,67 @@ void DebugBreakpointsWidget::add()
 }
 
 
-void DebugBreakpointsWidget::enableSelected()
+void DebugBreakpointsWidget::toggleSelected()
 {
 	QModelIndexList sel = selectionModel()->selectedRows();
 	for (const QModelIndex& index : sel)
 	{
 		BreakpointItem bp = m_model->getRow(index.row());
-		m_controller->EnableBreakpoint(bp.location());
+		if (bp.enabled())
+			m_controller->DisableBreakpoint(bp.location());
+		else
+			m_controller->EnableBreakpoint(bp.location());
 	}
 }
 
 
-void DebugBreakpointsWidget::disableSelected()
+void DebugBreakpointsWidget::enableAll()
 {
-	QModelIndexList sel = selectionModel()->selectedRows();
-	for (const QModelIndex& index : sel)
+	std::vector<DebugBreakpoint> breakpoints = m_controller->GetBreakpoints();
+	for (const DebugBreakpoint& bp : breakpoints)
 	{
-		BreakpointItem bp = m_model->getRow(index.row());
-		m_controller->DisableBreakpoint(bp.location());
+		ModuleNameAndOffset info;
+		info.module = bp.module;
+		info.offset = bp.offset;
+		m_controller->EnableBreakpoint(info);
 	}
 }
 
 
-void DebugBreakpointsWidget::toggleSelected()
+void DebugBreakpointsWidget::disableAll()
+{
+	std::vector<DebugBreakpoint> breakpoints = m_controller->GetBreakpoints();
+	for (const DebugBreakpoint& bp : breakpoints)
+	{
+		ModuleNameAndOffset info;
+		info.module = bp.module;
+		info.offset = bp.offset;
+		m_controller->DisableBreakpoint(info);
+	}
+}
+
+
+void DebugBreakpointsWidget::soloSelected()
 {
 	QModelIndexList sel = selectionModel()->selectedRows();
-	for (const QModelIndex& index : sel)
+	if (sel.empty())
+		return;
+
+	// Get the selected breakpoint location
+	BreakpointItem selectedBp = m_model->getRow(sel[0].row());
+	
+	// Disable all breakpoints first
+	std::vector<DebugBreakpoint> breakpoints = m_controller->GetBreakpoints();
+	for (const DebugBreakpoint& bp : breakpoints)
 	{
-		BreakpointItem bp = m_model->getRow(index.row());
-		if (bp.enabled())
-			m_controller->DisableBreakpoint(bp.location());
-		else
-			m_controller->EnableBreakpoint(bp.location());
+		ModuleNameAndOffset info;
+		info.module = bp.module;
+		info.offset = bp.offset;
+		m_controller->DisableBreakpoint(info);
 	}
+	
+	// Enable the selected breakpoint
+	m_controller->EnableBreakpoint(selectedBp.location());
 }
 
 

ui/breakpointswidget.h

@@ -149,9 +149,10 @@ private slots:
 	void remove();
 	void onDoubleClicked();
 	void add();
-	void enableSelected();
-	void disableSelected();
 	void toggleSelected();
+	void enableAll();
+	void disableAll();
+	void soloSelected();
 
 public slots:
 	void updateContent();

ui/renderlayer.cpp

@@ -17,6 +17,7 @@ limitations under the License.
 #include "renderlayer.h"
 #include "ttdcoveragerenderlayer.h"
 #include "debuggerapi.h"
+#include <map>
 
 using namespace BinaryNinja;
 using namespace BinaryNinjaDebuggerAPI;
@@ -37,14 +38,27 @@ void DebuggerRenderLayer::ApplyToBlock(Ref<BasicBlock> block, std::vector<Disass
 	uint64_t ipAddr = controller->IP();
 	bool paused = controller->GetTargetStatus() == DebugAdapterPausedStatus;
 
+	// Get all breakpoints with their enabled state
+	std::vector<DebugBreakpoint> breakpoints = controller->GetBreakpoints();
+	std::map<uint64_t, bool> breakpointEnabledMap;
+	for (const auto& bp : breakpoints)
+	{
+		breakpointEnabledMap[bp.address] = bp.enabled;
+	}
+
 	for (auto& line : lines)
 	{
 		// Do not draw the tags on an empty line, e.g., those separating the basic blocks in the linear view
 		if (line.tokens.empty() || (line.tokens[0].type == CommentToken))
 			continue;
 
 		bool hasPC = (line.addr == ipAddr) && paused;
-		bool hasBreakpoint = controller->ContainsBreakpoint(line.addr);
+		// Only render enabled breakpoints
+		bool hasBreakpoint = false;
+		if (breakpointEnabledMap.count(line.addr) > 0)
+		{
+			hasBreakpoint = breakpointEnabledMap[line.addr];
+		}
 
 		if (hasPC && hasBreakpoint)
 		{
@@ -141,11 +155,24 @@ void DebuggerRenderLayer::ApplyToHighLevelILBody(Ref<Function> function, std::ve
 	uint64_t ipAddr = controller->IP();
 	bool paused = controller->GetTargetStatus() == DebugAdapterPausedStatus;
 
+	// Get all breakpoints with their enabled state
+	std::vector<DebugBreakpoint> breakpoints = controller->GetBreakpoints();
+	std::map<uint64_t, bool> breakpointEnabledMap;
+	for (const auto& bp : breakpoints)
+	{
+		breakpointEnabledMap[bp.address] = bp.enabled;
+	}
+
 	for (auto& linearLine : lines)
 	{
 		DisassemblyTextLine& line = linearLine.contents;
 		bool hasPC = (line.addr == ipAddr) && paused;
-		bool hasBreakpoint = controller->ContainsBreakpoint(line.addr);
+		// Only render enabled breakpoints
+		bool hasBreakpoint = false;
+		if (breakpointEnabledMap.count(line.addr) > 0)
+		{
+			hasBreakpoint = breakpointEnabledMap[line.addr];
+		}
 
 		if (hasPC && hasBreakpoint)
 		{

ui/ui.cpp

@@ -811,6 +811,94 @@ void GlobalDebuggerUI::SetupMenu(UIContext* context)
 			requireBinaryView));
 	debuggerMenu->addAction("Toggle Breakpoint", "Breakpoint");
 
+	// Helper function to check if there's an enabled breakpoint at the current address
+	auto hasEnabledBreakpoint = [](BinaryView* view, uint64_t addr) -> bool {
+		auto controller = DebuggerController::GetController(view);
+		if (!controller)
+			return false;
+		
+		std::vector<DebugBreakpoint> breakpoints = controller->GetBreakpoints();
+		for (const auto& bp : breakpoints)
+		{
+			if (bp.address == addr)
+				return bp.enabled;
+		}
+		return false;
+	};
+
+	// Helper function to check if there's a disabled breakpoint at the current address
+	auto hasDisabledBreakpoint = [](BinaryView* view, uint64_t addr) -> bool {
+		auto controller = DebuggerController::GetController(view);
+		if (!controller)
+			return false;
+		
+		std::vector<DebugBreakpoint> breakpoints = controller->GetBreakpoints();
+		for (const auto& bp : breakpoints)
+		{
+			if (bp.address == addr)
+				return !bp.enabled;
+		}
+		return false;
+	};
+
+	// Register "Enable Breakpoint" action (shown when breakpoint is disabled)
+	UIAction::registerAction("Enable Breakpoint");
+	context->globalActions()->bindAction("Enable Breakpoint",
+		UIAction(
+			[=](const UIActionContext& ctxt) {
+				if (!ctxt.binaryView)
+					return;
+				auto controller = DebuggerController::GetController(ctxt.binaryView);
+				if (!controller)
+					return;
+
+				bool isAbsoluteAddress = controller->IsConnected();
+				if (isAbsoluteAddress)
+				{
+					controller->EnableBreakpoint(ctxt.address);
+				}
+				else
+				{
+					std::string filename = controller->GetInputFile();
+					uint64_t offset = ctxt.address - controller->GetViewFileSegmentsStart();
+					ModuleNameAndOffset info = {filename, offset};
+					controller->EnableBreakpoint(info);
+				}
+			},
+			[=](const UIActionContext& ctxt) {
+				return ctxt.binaryView && hasDisabledBreakpoint(ctxt.binaryView, ctxt.address);
+			}));
+	debuggerMenu->addAction("Enable Breakpoint", "Breakpoint");
+
+	// Register "Disable Breakpoint" action (shown when breakpoint is enabled)
+	UIAction::registerAction("Disable Breakpoint");
+	context->globalActions()->bindAction("Disable Breakpoint",
+		UIAction(
+			[=](const UIActionContext& ctxt) {
+				if (!ctxt.binaryView)
+					return;
+				auto controller = DebuggerController::GetController(ctxt.binaryView);
+				if (!controller)
+					return;
+
+				bool isAbsoluteAddress = controller->IsConnected();
+				if (isAbsoluteAddress)
+				{
+					controller->DisableBreakpoint(ctxt.address);
+				}
+				else
+				{
+					std::string filename = controller->GetInputFile();
+					uint64_t offset = ctxt.address - controller->GetViewFileSegmentsStart();
+					ModuleNameAndOffset info = {filename, offset};
+					controller->DisableBreakpoint(info);
+				}
+			},
+			[=](const UIActionContext& ctxt) {
+				return ctxt.binaryView && hasEnabledBreakpoint(ctxt.binaryView, ctxt.address);
+			}));
+	debuggerMenu->addAction("Disable Breakpoint", "Breakpoint");
+
 	UIAction::registerAction("Connect to Debug Server");
 	context->globalActions()->bindAction("Connect to Debug Server",
 		UIAction(