Fix compilation

xusheng6 · xusheng6 · commit 3229306d1f24 · 2026-01-07T15:54:35.000+08:00
diff --git a/core/debuggercontroller.cpp b/core/debuggercontroller.cpp
@@ -226,7 +226,7 @@ bool DebuggerController::SetBreakpointCondition(uint64_t address, const std::str
 	if (result)
 	{
 		DebuggerEvent event;
-		event.type = AbsoluteBreakpointConditionChangedEvent;
+		event.type = BreakpointChangedEvent;
 		event.data.absoluteAddress = address;
 		PostDebuggerEvent(event);
 	}
@@ -240,7 +240,7 @@ bool DebuggerController::SetBreakpointCondition(const ModuleNameAndOffset& addre
 	if (result)
 	{
 		DebuggerEvent event;
-		event.type = RelativeBreakpointConditionChangedEvent;
+		event.type = BreakpointChangedEvent;
 		event.data.relativeAddress = address;
 		PostDebuggerEvent(event);
 	}
diff --git a/core/debuggerstate.cpp b/core/debuggerstate.cpp
@@ -527,15 +527,15 @@ std::vector<BreakpointEntry>::iterator DebuggerBreakpoints::FindBreakpoint(const
 		const uint64_t targetAbsolute = m_state->GetModules()->RelativeAddressToAbsolute(address);
 		for (auto it = m_breakpoints.begin(); it != m_breakpoints.end(); ++it)
 		{
-			if (m_state->GetModules()->RelativeAddressToAbsolute(it->address) == targetAbsolute)
+			if (m_state->GetModules()->RelativeAddressToAbsolute(it->location) == targetAbsolute)
 				return it;
 		}
 	}
 	else
 	{
 		for (auto it = m_breakpoints.begin(); it != m_breakpoints.end(); ++it)
 		{
-			if (it->address == address)
+			if (it->location == address)
 				return it;
 		}
 	}
@@ -611,7 +611,7 @@ bool DebuggerBreakpoints::RemoveOffset(const ModuleNameAndOffset& address)
 	if (it == m_breakpoints.end())
 		return false;
 
-	ModuleNameAndOffset actualAddr = it->address;
+	ModuleNameAndOffset actualAddr = it->location;
 	m_breakpoints.erase(it);
 	SerializeMetadata();
 
@@ -642,7 +642,7 @@ bool DebuggerBreakpoints::EnableOffset(const ModuleNameAndOffset& address)
 
 	if (m_state->GetAdapter() && m_state->IsConnected())
 	{
-		uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->address);
+		uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->location);
 		m_state->GetAdapter()->AddBreakpoint(remoteAddress);
 	}
 	return true;
@@ -667,7 +667,7 @@ bool DebuggerBreakpoints::DisableOffset(const ModuleNameAndOffset& address)
 
 	if (m_state->GetAdapter() && m_state->IsConnected())
 	{
-		uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->address);
+		uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->location);
 		m_state->GetAdapter()->RemoveBreakpoint(remoteAddress);
 	}
 	return true;
@@ -704,9 +704,8 @@ bool DebuggerBreakpoints::ContainsAbsolute(uint64_t address)
 
 	for (const auto& bp : m_breakpoints)
 	{
-		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)
+		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)
 			return true;
-		}
 	}
 	return false;
 }
@@ -735,7 +734,7 @@ std::string DebuggerBreakpoints::GetConditionAbsolute(const uint64_t address)
 {
 	for (const auto& bp : m_breakpoints)
 	{
-		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)
+		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)
 			return bp.condition;
 	}
 	return "";
@@ -753,7 +752,7 @@ bool DebuggerBreakpoints::HasConditionAbsolute(const uint64_t address)
 {
 	for (const auto& bp : m_breakpoints)
 	{
-		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)
+		if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)
 			return !bp.condition.empty();
 	}
 	return false;
@@ -793,8 +792,13 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(uint64_t address, DebugBreakpoin
 	// Add to internal storage (either adapter succeeded, or no adapter connected yet)
 	// Convert absolute address to module+offset for ASLR-safe storage (like AddAbsolute does for software breakpoints)
 	ModuleNameAndOffset info = m_state->GetModules()->AbsoluteAddressToRelative(address);
-	BreakpointInfo bp(info, type, size);
+	BreakpointEntry bp;
+	bp.location = info;
+	bp.enabled = true;
+	bp.type = type;
+	bp.size = size;
 	bp.address = address;
+	bp.isRelative = true;
 	m_breakpoints.push_back(bp);
 	SerializeMetadata();
 
@@ -844,7 +848,7 @@ bool DebuggerBreakpoints::ContainsHardwareBreakpoint(uint64_t address, DebugBrea
 {
 	// Similar to ContainsAbsolute, we need to handle both relative and absolute hardware breakpoints
 	// For relative hardware breakpoints, convert to absolute and compare
-	for (const BreakpointInfo& breakpoint : m_breakpoints)
+	for (const BreakpointEntry& breakpoint : m_breakpoints)
 	{
 		if (breakpoint.IsHardware() && breakpoint.type == type && breakpoint.size == size)
 		{
@@ -959,7 +963,12 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(const ModuleNameAndOffset& locat
 	}
 
 	// Add to internal storage (either adapter succeeded, or no adapter connected yet)
-	BreakpointInfo bp(location, type, size);  // Uses the constructor for module+offset
+	BreakpointEntry bp;
+	bp.location = location;
+	bp.enabled = true;
+	bp.type = type;
+	bp.size = size;
+	bp.isRelative = true;
 	m_breakpoints.push_back(bp);
 	SerializeMetadata();
 
@@ -969,10 +978,10 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(const ModuleNameAndOffset& locat
 
 bool DebuggerBreakpoints::RemoveHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size)
 {
-	BreakpointInfo toFind(location, type, size);
-
 	// Remove from our list
-	auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);
+	auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {
+		return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;
+	});
 	if (iter != m_breakpoints.end())
 	{
 		m_breakpoints.erase(iter);
@@ -992,8 +1001,9 @@ bool DebuggerBreakpoints::RemoveHardwareBreakpoint(const ModuleNameAndOffset& lo
 
 bool DebuggerBreakpoints::ContainsHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size)
 {
-	BreakpointInfo toFind(location, type, size);
-	return std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind) != m_breakpoints.end();
+	return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {
+		return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;
+	}) != m_breakpoints.end();
 }
 
 
@@ -1003,8 +1013,9 @@ bool DebuggerBreakpoints::EnableHardwareBreakpoint(const ModuleNameAndOffset& lo
 		return false;
 
 	// Find and enable the hardware breakpoint
-	BreakpointInfo toFind(location, type, size);
-	auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);
+	auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {
+		return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;
+	});
 	if (iter != m_breakpoints.end())
 	{
 		iter->enabled = true;
@@ -1027,8 +1038,9 @@ bool DebuggerBreakpoints::DisableHardwareBreakpoint(const ModuleNameAndOffset& l
 		return false;
 
 	// Find and disable the hardware breakpoint
-	BreakpointInfo toFind(location, type, size);
-	auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);
+	auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {
+		return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;
+	});
 	if (iter != m_breakpoints.end())
 	{
 		iter->enabled = false;
@@ -1045,28 +1057,14 @@ bool DebuggerBreakpoints::DisableHardwareBreakpoint(const ModuleNameAndOffset& l
 }
 
 
-std::vector<ModuleNameAndOffset> DebuggerBreakpoints::GetSoftwareBreakpointList() const
-{
-	std::vector<ModuleNameAndOffset> result;
-	for (const BreakpointInfo& bp : m_breakpoints)
-	{
-		if (bp.IsSoftware())
-		{
-			result.push_back(bp.location);
-		}
-	}
-	return result;
-}
-
-
 void DebuggerBreakpoints::SerializeMetadata()
 {
 	std::vector<Ref<Metadata>> breakpoints;
 	for (const auto& bp : m_breakpoints)
 	{
 		std::map<std::string, Ref<Metadata>> info;
-		info["module"] = new Metadata(bp.address.module);
-		info["offset"] = new Metadata(bp.address.offset);
+		info["module"] = new Metadata(bp.location.module);
+		info["offset"] = new Metadata(bp.location.offset);
 		info["enabled"] = new Metadata(bp.enabled);
 
 		if (!bp.condition.empty())
@@ -1099,8 +1097,8 @@ void DebuggerBreakpoints::UnserializedMetadata()
 			continue;
 
 		BreakpointEntry bp;
-		bp.address.module = info["module"]->GetString();
-		bp.address.offset = info["offset"]->GetUnsignedInteger();
+		bp.location.module = info["module"]->GetString();
+		bp.location.offset = info["offset"]->GetUnsignedInteger();
 		bp.enabled = (info["enabled"] && info["enabled"]->IsBoolean()) ? info["enabled"]->GetBoolean() : true;
 		bp.condition = (info["condition"] && info["condition"]->IsString()) ? info["condition"]->GetString() : "";
 
@@ -1114,7 +1112,7 @@ void DebuggerBreakpoints::Apply()
 	if (!m_state->GetAdapter())
 		return;
 
-	for (const BreakpointInfo& bp : m_breakpoints)
+	for (const auto& bp : m_breakpoints)
 	{
 		if (bp.IsSoftware())
 		{
diff --git a/core/debuggerstate.h b/core/debuggerstate.h
@@ -84,10 +84,14 @@ namespace BinaryNinjaDebugger {
 		bool enabled = true;
 		std::string condition;
 
-		uint64_t address;              // Absolute address (for absolute addressing or resolved relative)
-		DebugBreakpointType type;      // Breakpoint type (Software, HardwareExecute, etc.)
-		size_t size;                   // Size for hardware watchpoints
-		bool isRelative;               // True if using module+offset, false if using absolute address
+		uint64_t address = 0;          // Absolute address (for absolute addressing or resolved relative)
+		DebugBreakpointType type = SoftwareBreakpoint;  // Breakpoint type (Software, HardwareExecute, etc.)
+		size_t size = 1;               // Size for hardware watchpoints
+		bool isRelative = true;        // True if using module+offset, false if using absolute address
+
+		// Helper methods
+		bool IsSoftware() const { return type == SoftwareBreakpoint; }
+		bool IsHardware() const { return type != SoftwareBreakpoint; }
 	};
 
 	class DebuggerBreakpoints
@@ -122,16 +126,7 @@ namespace BinaryNinjaDebugger {
 		bool HasConditionAbsolute(uint64_t address);
 		bool HasConditionOffset(const ModuleNameAndOffset& address);
 
-	private:
-		// Find breakpoint by address, handling module name differences via absolute address comparison
-		std::vector<BreakpointEntry>::iterator FindBreakpoint(const ModuleNameAndOffset& address);
-		std::vector<BreakpointEntry>::const_iterator FindBreakpoint(const ModuleNameAndOffset& address) const;
-
-		// Get only software breakpoints (for backward compatibility)
-		std::vector<ModuleNameAndOffset> GetSoftwareBreakpointList() const;
-
 		// Hardware breakpoint methods
-		// Hardware breakpoint methods - absolute address
 		bool AddHardwareBreakpoint(uint64_t address, DebugBreakpointType type, size_t size);
 		bool RemoveHardwareBreakpoint(uint64_t address, DebugBreakpointType type, size_t size);
 		bool EnableHardwareBreakpoint(uint64_t address, DebugBreakpointType type, size_t size);
@@ -144,6 +139,11 @@ namespace BinaryNinjaDebugger {
 		bool EnableHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size);
 		bool DisableHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size);
 		bool ContainsHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size);
+
+	private:
+		// Find breakpoint by address, handling module name differences via absolute address comparison
+		std::vector<BreakpointEntry>::iterator FindBreakpoint(const ModuleNameAndOffset& address);
+		std::vector<BreakpointEntry>::const_iterator FindBreakpoint(const ModuleNameAndOffset& address) const;
 	};
 
 
diff --git a/core/ffi.cpp b/core/ffi.cpp
@@ -825,7 +825,7 @@ BNDebugBreakpoint* BNDebuggerGetBreakpoints(BNDebuggerController* controller, si
 		result[i].enabled = breakpoints[i].enabled;
 		result[i].type = (BNDebugBreakpointType)breakpoints[i].type;
 		result[i].size = breakpoints[i].size;
-		result[i].condition = breakpoints[i].condition.empty() ? nullptr : BNDebuggerAllocString(bp.condition.c_str());
+		result[i].condition = breakpoints[i].condition.empty() ? nullptr : BNDebuggerAllocString(breakpoints[i].condition.c_str());
 	}
 	return result;
 }

Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ bool DebuggerController::SetBreakpointCondition(uint64_t address, const std::str`
`226`	`226`	`if (result)`
`227`	`227`	`{`
`228`	`228`	`DebuggerEvent event;`
`229`		`- event.type = AbsoluteBreakpointConditionChangedEvent;`
	`229`	`+ event.type = BreakpointChangedEvent;`
`230`	`230`	`event.data.absoluteAddress = address;`
`231`	`231`	`PostDebuggerEvent(event);`
`232`	`232`	`}`
`@@ -240,7 +240,7 @@ bool DebuggerController::SetBreakpointCondition(const ModuleNameAndOffset& addre`
`240`	`240`	`if (result)`
`241`	`241`	`{`
`242`	`242`	`DebuggerEvent event;`
`243`		`- event.type = RelativeBreakpointConditionChangedEvent;`
	`243`	`+ event.type = BreakpointChangedEvent;`
`244`	`244`	`event.data.relativeAddress = address;`
`245`	`245`	`PostDebuggerEvent(event);`
`246`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -527,15 +527,15 @@ std::vector<BreakpointEntry>::iterator DebuggerBreakpoints::FindBreakpoint(const`
`527`	`527`	`const uint64_t targetAbsolute = m_state->GetModules()->RelativeAddressToAbsolute(address);`
`528`	`528`	`for (auto it = m_breakpoints.begin(); it != m_breakpoints.end(); ++it)`
`529`	`529`	`{`
`530`		`- if (m_state->GetModules()->RelativeAddressToAbsolute(it->address) == targetAbsolute)`
	`530`	`+ if (m_state->GetModules()->RelativeAddressToAbsolute(it->location) == targetAbsolute)`
`531`	`531`	`return it;`
`532`	`532`	`}`
`533`	`533`	`}`
`534`	`534`	`else`
`535`	`535`	`{`
`536`	`536`	`for (auto it = m_breakpoints.begin(); it != m_breakpoints.end(); ++it)`
`537`	`537`	`{`
`538`		`- if (it->address == address)`
	`538`	`+ if (it->location == address)`
`539`	`539`	`return it;`
`540`	`540`	`}`
`541`	`541`	`}`
`@@ -611,7 +611,7 @@ bool DebuggerBreakpoints::RemoveOffset(const ModuleNameAndOffset& address)`
`611`	`611`	`if (it == m_breakpoints.end())`
`612`	`612`	`return false;`
`613`	`613`
`614`		`- ModuleNameAndOffset actualAddr = it->address;`
	`614`	`+ ModuleNameAndOffset actualAddr = it->location;`
`615`	`615`	`m_breakpoints.erase(it);`
`616`	`616`	`SerializeMetadata();`
`617`	`617`
`@@ -642,7 +642,7 @@ bool DebuggerBreakpoints::EnableOffset(const ModuleNameAndOffset& address)`
`642`	`642`
`643`	`643`	`if (m_state->GetAdapter() && m_state->IsConnected())`
`644`	`644`	`{`
`645`		`- uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->address);`
	`645`	`+ uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->location);`
`646`	`646`	`m_state->GetAdapter()->AddBreakpoint(remoteAddress);`
`647`	`647`	`}`
`648`	`648`	`return true;`
`@@ -667,7 +667,7 @@ bool DebuggerBreakpoints::DisableOffset(const ModuleNameAndOffset& address)`
`667`	`667`
`668`	`668`	`if (m_state->GetAdapter() && m_state->IsConnected())`
`669`	`669`	`{`
`670`		`- uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->address);`
	`670`	`+ uint64_t remoteAddress = m_state->GetModules()->RelativeAddressToAbsolute(it->location);`
`671`	`671`	`m_state->GetAdapter()->RemoveBreakpoint(remoteAddress);`
`672`	`672`	`}`
`673`	`673`	`return true;`
`@@ -704,9 +704,8 @@ bool DebuggerBreakpoints::ContainsAbsolute(uint64_t address)`
`704`	`704`
`705`	`705`	`for (const auto& bp : m_breakpoints)`
`706`	`706`	`{`
`707`		`- if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)`
	`707`	`+ if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)`
`708`	`708`	`return true;`
`709`		`- }`
`710`	`709`	`}`
`711`	`710`	`return false;`
`712`	`711`	`}`
`@@ -735,7 +734,7 @@ std::string DebuggerBreakpoints::GetConditionAbsolute(const uint64_t address)`
`735`	`734`	`{`
`736`	`735`	`for (const auto& bp : m_breakpoints)`
`737`	`736`	`{`
`738`		`- if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)`
	`737`	`+ if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)`
`739`	`738`	`return bp.condition;`
`740`	`739`	`}`
`741`	`740`	`return "";`
`@@ -753,7 +752,7 @@ bool DebuggerBreakpoints::HasConditionAbsolute(const uint64_t address)`
`753`	`752`	`{`
`754`	`753`	`for (const auto& bp : m_breakpoints)`
`755`	`754`	`{`
`756`		`- if (m_state->GetModules()->RelativeAddressToAbsolute(bp.address) == address)`
	`755`	`+ if (m_state->GetModules()->RelativeAddressToAbsolute(bp.location) == address)`
`757`	`756`	`return !bp.condition.empty();`
`758`	`757`	`}`
`759`	`758`	`return false;`
`@@ -793,8 +792,13 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(uint64_t address, DebugBreakpoin`
`793`	`792`	`// Add to internal storage (either adapter succeeded, or no adapter connected yet)`
`794`	`793`	`// Convert absolute address to module+offset for ASLR-safe storage (like AddAbsolute does for software breakpoints)`
`795`	`794`	`ModuleNameAndOffset info = m_state->GetModules()->AbsoluteAddressToRelative(address);`
`796`		`- BreakpointInfo bp(info, type, size);`
	`795`	`+ BreakpointEntry bp;`
	`796`	`+ bp.location = info;`
	`797`	`+ bp.enabled = true;`
	`798`	`+ bp.type = type;`
	`799`	`+ bp.size = size;`
`797`	`800`	`bp.address = address;`
	`801`	`+ bp.isRelative = true;`
`798`	`802`	`m_breakpoints.push_back(bp);`
`799`	`803`	`SerializeMetadata();`
`800`	`804`
`@@ -844,7 +848,7 @@ bool DebuggerBreakpoints::ContainsHardwareBreakpoint(uint64_t address, DebugBrea`
`844`	`848`	`{`
`845`	`849`	`// Similar to ContainsAbsolute, we need to handle both relative and absolute hardware breakpoints`
`846`	`850`	`// For relative hardware breakpoints, convert to absolute and compare`
`847`		`- for (const BreakpointInfo& breakpoint : m_breakpoints)`
	`851`	`+ for (const BreakpointEntry& breakpoint : m_breakpoints)`
`848`	`852`	`{`
`849`	`853`	`if (breakpoint.IsHardware() && breakpoint.type == type && breakpoint.size == size)`
`850`	`854`	`{`
`@@ -959,7 +963,12 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(const ModuleNameAndOffset& locat`
`959`	`963`	`}`
`960`	`964`
`961`	`965`	`// Add to internal storage (either adapter succeeded, or no adapter connected yet)`
`962`		`- BreakpointInfo bp(location, type, size); // Uses the constructor for module+offset`
	`966`	`+ BreakpointEntry bp;`
	`967`	`+ bp.location = location;`
	`968`	`+ bp.enabled = true;`
	`969`	`+ bp.type = type;`
	`970`	`+ bp.size = size;`
	`971`	`+ bp.isRelative = true;`
`963`	`972`	`m_breakpoints.push_back(bp);`
`964`	`973`	`SerializeMetadata();`
`965`	`974`
`@@ -969,10 +978,10 @@ bool DebuggerBreakpoints::AddHardwareBreakpoint(const ModuleNameAndOffset& locat`
`969`	`978`
`970`	`979`	`bool DebuggerBreakpoints::RemoveHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size)`
`971`	`980`	`{`
`972`		`- BreakpointInfo toFind(location, type, size);`
`973`		`-`
`974`	`981`	`// Remove from our list`
`975`		`- auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);`
	`982`	`+ auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {`
	`983`	`+ return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;`
	`984`	`+ });`
`976`	`985`	`if (iter != m_breakpoints.end())`
`977`	`986`	`{`
`978`	`987`	`m_breakpoints.erase(iter);`
`@@ -992,8 +1001,9 @@ bool DebuggerBreakpoints::RemoveHardwareBreakpoint(const ModuleNameAndOffset& lo`
`992`	`1001`
`993`	`1002`	`bool DebuggerBreakpoints::ContainsHardwareBreakpoint(const ModuleNameAndOffset& location, DebugBreakpointType type, size_t size)`
`994`	`1003`	`{`
`995`		`- BreakpointInfo toFind(location, type, size);`
`996`		`- return std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind) != m_breakpoints.end();`
	`1004`	`+ return std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {`
	`1005`	`+ return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;`
	`1006`	`+ }) != m_breakpoints.end();`
`997`	`1007`	`}`
`998`	`1008`
`999`	`1009`
`@@ -1003,8 +1013,9 @@ bool DebuggerBreakpoints::EnableHardwareBreakpoint(const ModuleNameAndOffset& lo`
`1003`	`1013`	`return false;`
`1004`	`1014`
`1005`	`1015`	`// Find and enable the hardware breakpoint`
`1006`		`- BreakpointInfo toFind(location, type, size);`
`1007`		`- auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);`
	`1016`	`+ auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {`
	`1017`	`+ return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;`
	`1018`	`+ });`
`1008`	`1019`	`if (iter != m_breakpoints.end())`
`1009`	`1020`	`{`
`1010`	`1021`	`iter->enabled = true;`
`@@ -1027,8 +1038,9 @@ bool DebuggerBreakpoints::DisableHardwareBreakpoint(const ModuleNameAndOffset& l`
`1027`	`1038`	`return false;`
`1028`	`1039`
`1029`	`1040`	`// Find and disable the hardware breakpoint`
`1030`		`- BreakpointInfo toFind(location, type, size);`
`1031`		`- auto iter = std::find(m_breakpoints.begin(), m_breakpoints.end(), toFind);`
	`1041`	`+ auto iter = std::find_if(m_breakpoints.begin(), m_breakpoints.end(), [&](const BreakpointEntry& bp) {`
	`1042`	`+ return bp.IsHardware() && bp.location == location && bp.type == type && bp.size == size;`
	`1043`	`+ });`
`1032`	`1044`	`if (iter != m_breakpoints.end())`
`1033`	`1045`	`{`
`1034`	`1046`	`iter->enabled = false;`
`@@ -1045,28 +1057,14 @@ bool DebuggerBreakpoints::DisableHardwareBreakpoint(const ModuleNameAndOffset& l`
`1045`	`1057`	`}`
`1046`	`1058`
`1047`	`1059`
`1048`		`-std::vector<ModuleNameAndOffset> DebuggerBreakpoints::GetSoftwareBreakpointList() const`
`1049`		`-{`
`1050`		`- std::vector<ModuleNameAndOffset> result;`
`1051`		`- for (const BreakpointInfo& bp : m_breakpoints)`
`1052`		`- {`
`1053`		`- if (bp.IsSoftware())`
`1054`		`- {`
`1055`		`- result.push_back(bp.location);`
`1056`		`- }`
`1057`		`- }`
`1058`		`- return result;`
`1059`		`-}`
`1060`		`-`
`1061`		`-`
`1062`	`1060`	`void DebuggerBreakpoints::SerializeMetadata()`
`1063`	`1061`	`{`
`1064`	`1062`	`std::vector<Ref<Metadata>> breakpoints;`
`1065`	`1063`	`for (const auto& bp : m_breakpoints)`
`1066`	`1064`	`{`
`1067`	`1065`	`std::map<std::string, Ref<Metadata>> info;`
`1068`		`- info["module"] = new Metadata(bp.address.module);`
`1069`		`- info["offset"] = new Metadata(bp.address.offset);`
	`1066`	`+ info["module"] = new Metadata(bp.location.module);`
	`1067`	`+ info["offset"] = new Metadata(bp.location.offset);`
`1070`	`1068`	`info["enabled"] = new Metadata(bp.enabled);`
`1071`	`1069`
`1072`	`1070`	`if (!bp.condition.empty())`
`@@ -1099,8 +1097,8 @@ void DebuggerBreakpoints::UnserializedMetadata()`
`1099`	`1097`	`continue;`
`1100`	`1098`
`1101`	`1099`	`BreakpointEntry bp;`
`1102`		`- bp.address.module = info["module"]->GetString();`
`1103`		`- bp.address.offset = info["offset"]->GetUnsignedInteger();`
	`1100`	`+ bp.location.module = info["module"]->GetString();`
	`1101`	`+ bp.location.offset = info["offset"]->GetUnsignedInteger();`
`1104`	`1102`	`bp.enabled = (info["enabled"] && info["enabled"]->IsBoolean()) ? info["enabled"]->GetBoolean() : true;`
`1105`	`1103`	`bp.condition = (info["condition"] && info["condition"]->IsString()) ? info["condition"]->GetString() : "";`
`1106`	`1104`
`@@ -1114,7 +1112,7 @@ void DebuggerBreakpoints::Apply()`
`1114`	`1112`	`if (!m_state->GetAdapter())`
`1115`	`1113`	`return;`
`1116`	`1114`
`1117`		`- for (const BreakpointInfo& bp : m_breakpoints)`
	`1115`	`+ for (const auto& bp : m_breakpoints)`
`1118`	`1116`	`{`
`1119`	`1117`	`if (bp.IsSoftware())`
`1120`	`1118`	`{`
Original file line number	Diff line number	Diff line change
`@@ -825,7 +825,7 @@ BNDebugBreakpoint* BNDebuggerGetBreakpoints(BNDebuggerController* controller, si`
`825`	`825`	`result[i].enabled = breakpoints[i].enabled;`
`826`	`826`	`result[i].type = (BNDebugBreakpointType)breakpoints[i].type;`
`827`	`827`	`result[i].size = breakpoints[i].size;`
`828`		`- result[i].condition = breakpoints[i].condition.empty() ? nullptr : BNDebuggerAllocString(bp.condition.c_str());`
	`828`	`+ result[i].condition = breakpoints[i].condition.empty() ? nullptr : BNDebuggerAllocString(breakpoints[i].condition.c_str());`
`829`	`829`	`}`
`830`	`830`	`return result;`
`831`	`831`	`}`