Enhance MemoryMap bindings and add support to re-enable disabled regions in the UI.

Author: bpotchik

binaryninjaapi.h

@@ -8211,6 +8211,34 @@ namespace BinaryNinja {
 	    segmentation is automatically managed. If multiple regions overlap, the most recently added region takes
 	    precedence by default.
 	*/
+
+	struct MemoryRegionInfo
+	{
+		std::string name;
+		std::string displayName;
+		uint64_t start;
+		uint64_t length;
+		uint32_t flags;
+		bool enabled;
+		bool rebaseable;
+		uint8_t fill;
+		bool hasTarget;
+		bool absoluteAddressMode;
+		bool local;
+	};
+
+	struct ResolvedMemoryRange
+	{
+		uint64_t start;
+		uint64_t length;
+		std::vector<MemoryRegionInfo> regions;
+
+		uint64_t End() const { return start + length; }
+		const MemoryRegionInfo* ActiveRegion() const { return regions.empty() ? nullptr : &regions.front(); }
+		std::string Name() const { auto* r = ActiveRegion(); return r ? r->name : std::string(); }
+		uint32_t Flags() const { auto* r = ActiveRegion(); return r ? r->flags : 0; }
+	};
+
 	class MemoryMap
 	{
 		BNBinaryView* m_object;
@@ -8336,6 +8364,103 @@ namespace BinaryNinja {
 			return BNIsMemoryRegionLocal(m_object, name.c_str());
 		}
 
+		std::optional<MemoryRegionInfo> GetMemoryRegionInfo(const std::string& name)
+		{
+			BNMemoryRegionInfo info;
+			if (!BNGetMemoryRegionInfo(m_object, name.c_str(), &info))
+				return std::nullopt;
+			MemoryRegionInfo result {info.name, info.displayName, info.start, info.length,
+				info.flags, info.enabled, info.rebaseable, info.fill,
+				info.hasTarget, info.absoluteAddressMode, info.local};
+			BNFreeMemoryRegionInfo(&info);
+			return result;
+		}
+
+		std::optional<MemoryRegionInfo> GetActiveMemoryRegionInfoAt(uint64_t addr)
+		{
+			BNMemoryRegionInfo info;
+			if (!BNGetActiveMemoryRegionInfoAt(m_object, addr, &info))
+				return std::nullopt;
+			MemoryRegionInfo result {info.name, info.displayName, info.start, info.length,
+				info.flags, info.enabled, info.rebaseable, info.fill,
+				info.hasTarget, info.absoluteAddressMode, info.local};
+			BNFreeMemoryRegionInfo(&info);
+			return result;
+		}
+
+		std::optional<ResolvedMemoryRange> GetResolvedMemoryRangeAt(uint64_t addr)
+		{
+			BNResolvedMemoryRange raw;
+			if (!BNGetResolvedMemoryRangeAt(m_object, addr, &raw))
+				return std::nullopt;
+			ResolvedMemoryRange result;
+			result.start = raw.start;
+			result.length = raw.length;
+			result.regions.reserve(raw.regionCount);
+			for (size_t j = 0; j < raw.regionCount; j++)
+			{
+				auto& r = raw.regions[j];
+				result.regions.push_back({r.name, r.displayName, r.start, r.length,
+					r.flags, r.enabled, r.rebaseable, r.fill,
+					r.hasTarget, r.absoluteAddressMode, r.local});
+			}
+			BNFreeResolvedMemoryRange(&raw);
+			return result;
+		}
+
+		std::vector<MemoryRegionInfo> GetMemoryRegions()
+		{
+			size_t count = 0;
+			BNMemoryRegionInfo* regions = BNGetMemoryRegions(m_object, &count);
+			std::vector<MemoryRegionInfo> result;
+			result.reserve(count);
+			for (size_t i = 0; i < count; i++)
+			{
+				result.push_back({
+					regions[i].name,
+					regions[i].displayName,
+					regions[i].start,
+					regions[i].length,
+					regions[i].flags,
+					regions[i].enabled,
+					regions[i].rebaseable,
+					regions[i].fill,
+					regions[i].hasTarget,
+					regions[i].absoluteAddressMode,
+					regions[i].local,
+				});
+			}
+			BNFreeMemoryRegions(regions, count);
+			return result;
+		}
+
+		std::vector<ResolvedMemoryRange> GetResolvedRanges()
+		{
+			size_t count = 0;
+			BNResolvedMemoryRange* ranges = BNGetResolvedMemoryRanges(m_object, &count);
+			std::vector<ResolvedMemoryRange> result;
+			result.reserve(count);
+			for (size_t i = 0; i < count; i++)
+			{
+				ResolvedMemoryRange range;
+				range.start = ranges[i].start;
+				range.length = ranges[i].length;
+				range.regions.reserve(ranges[i].regionCount);
+				for (size_t j = 0; j < ranges[i].regionCount; j++)
+				{
+					auto& r = ranges[i].regions[j];
+					range.regions.push_back({
+						r.name, r.displayName, r.start, r.length,
+						r.flags, r.enabled, r.rebaseable, r.fill,
+						r.hasTarget, r.absoluteAddressMode, r.local,
+					});
+				}
+				result.push_back(std::move(range));
+			}
+			BNFreeResolvedMemoryRanges(ranges, count);
+			return result;
+		}
+
 		void Reset()
 		{
 			BNResetMemoryMap(m_object);
@@ -20044,7 +20169,7 @@ namespace BinaryNinja {
 			\return True if the type library was successfully decompressed
 		*/
 		bool DecompressToFile(const std::string& path);
-		
+
 		/*! The Architecture this type library is associated with
 
 			\return

binaryninjacore.h

@@ -37,14 +37,14 @@
 // Current ABI version for linking to the core. This is incremented any time
 // there are changes to the API that affect linking, including new functions,
 // new types, or modifications to existing functions or types.
-#define BN_CURRENT_CORE_ABI_VERSION 158
+#define BN_CURRENT_CORE_ABI_VERSION 159
 
 // Minimum ABI version that is supported for loading of plugins. Plugins that
 // are linked to an ABI version less than this will not be able to load and
 // will require rebuilding. The minimum version is increased when there are
 // incompatible changes that break binary compatibility, such as changes to
 // existing types or functions.
-#define BN_MINIMUM_CORE_ABI_VERSION 158
+#define BN_MINIMUM_CORE_ABI_VERSION 159
 
 #ifdef __GNUC__
 	#ifdef BINARYNINJACORE_LIBRARY
@@ -3803,6 +3803,27 @@ extern "C"
 		uint64_t infoData;
 	} BNSectionInfo;
 
+	typedef struct BNMemoryRegionInfo {
+		char* name;
+		char* displayName;
+		uint64_t start;
+		uint64_t length;
+		uint32_t flags;
+		bool enabled;
+		bool rebaseable;
+		uint8_t fill;
+		bool hasTarget;
+		bool absoluteAddressMode;
+		bool local;
+	} BNMemoryRegionInfo;
+
+	typedef struct BNResolvedMemoryRange {
+		uint64_t start;
+		uint64_t length;
+		BNMemoryRegionInfo* regions;
+		size_t regionCount;
+	} BNResolvedMemoryRange;
+
 	typedef bool(*BNCollaborationAnalysisConflictHandler)(void*, const char** keys, BNAnalysisMergeConflict** conflicts, size_t conflictCount);
 	typedef bool(*BNCollaborationNameChangesetFunction)(void*, BNCollaborationChangeset*);
 
@@ -4531,6 +4552,15 @@ extern "C"
 	BINARYNINJACOREAPI char* BNGetMemoryRegionDisplayName(BNBinaryView* view, const char* name);
 	BINARYNINJACOREAPI bool BNSetMemoryRegionDisplayName(BNBinaryView* view, const char* name, const char* displayName);
 	BINARYNINJACOREAPI bool BNIsMemoryRegionLocal(BNBinaryView* view, const char* name);
+	BINARYNINJACOREAPI bool BNGetMemoryRegionInfo(BNBinaryView* view, const char* name, BNMemoryRegionInfo* result);
+	BINARYNINJACOREAPI bool BNGetActiveMemoryRegionInfoAt(BNBinaryView* view, uint64_t addr, BNMemoryRegionInfo* result);
+	BINARYNINJACOREAPI bool BNGetResolvedMemoryRangeAt(BNBinaryView* view, uint64_t addr, BNResolvedMemoryRange* result);
+	BINARYNINJACOREAPI void BNFreeMemoryRegionInfo(BNMemoryRegionInfo* info);
+	BINARYNINJACOREAPI void BNFreeResolvedMemoryRange(BNResolvedMemoryRange* range);
+	BINARYNINJACOREAPI BNMemoryRegionInfo* BNGetMemoryRegions(BNBinaryView* view, size_t* count);
+	BINARYNINJACOREAPI void BNFreeMemoryRegions(BNMemoryRegionInfo* regions, size_t count);
+	BINARYNINJACOREAPI BNResolvedMemoryRange* BNGetResolvedMemoryRanges(BNBinaryView* view, size_t* count);
+	BINARYNINJACOREAPI void BNFreeResolvedMemoryRanges(BNResolvedMemoryRange* ranges, size_t count);
 	BINARYNINJACOREAPI void BNResetMemoryMap(BNBinaryView* view);
 
 	// Binary view access