Unify SettingsCache and MemoryMap access under immutable snapshots for consistent, lock-free AnalysisContext queries.

Author: bpotchik

binaryninjaapi.h

@@ -8129,6 +8129,22 @@ namespace BinaryNinja {
 		std::optional<std::pair<std::string, BNStringType>> StringifyUnicodeData(Architecture* arch, const DataBuffer& buffer, bool nullTerminates = true, bool allowShortStrings = false);
 	};
 
+	/*! MemoryMap provides access to the system-level memory map describing how a BinaryView is loaded into memory.
+
+	    \note Architecture: This API-side MemoryMap class is a proxy that accesses the BinaryView's current
+	    MemoryMap state through the core API. The proxy provides a simple mutable interface: when you call
+	    modification operations (AddMemoryRegion, RemoveMemoryRegion, etc.), the proxy automatically accesses
+	    the updated MemoryMap. Internally, the core uses immutable copy-on-write data structures, but the proxy
+	    abstracts this away.
+
+	    When you access a BinaryView's MemoryMap, you always see the current state. For lock-free access during
+	    analysis, AnalysisContext provides memory layout query methods (IsValidOffset, IsOffsetReadable, GetStart,
+	    GetLength, etc.) that operate on an immutable snapshot of the MemoryMap cached when the analysis was initiated.
+
+	    A MemoryMap can contain multiple, arbitrarily overlapping memory regions. When modified, address space
+	    segmentation is automatically managed. If multiple regions overlap, the most recently added region takes
+	    precedence by default.
+	*/
 	class MemoryMap
 	{
 		BNBinaryView* m_object;
@@ -8142,6 +8158,22 @@ namespace BinaryNinja {
 			BNSetLogicalMemoryMapEnabled(m_object, enabled);
 		}
 
+		/*! Returns true if this MemoryMap represents a parsed BinaryView with real segments.
+
+		    This is determined by whether the BinaryView has a parent view - parsed views
+		    (ELF, PE, Mach-O, etc.) have a parent Raw view, while Raw views have no parent.
+
+		    Returns true for parsed BinaryViews (ELF, PE, Mach-O, etc.) with segments from
+		    binary format parsing. Returns false for Raw BinaryViews (flat file view with
+		    synthetic MemoryMap) or views that failed to parse segments.
+
+		    Use this to gate features that require parsed binary structure (sections, imports,
+		    relocations, etc.). For basic analysis queries (GetStart, IsOffsetReadable,
+		    GetLength, etc.), use the MemoryMap directly regardless of activation state - all
+		    BinaryViews have a usable MemoryMap.
+
+		    \return True if this is an activated (parsed) memory map, false otherwise
+		*/
 		bool IsActivated()
 		{
 			return BNIsMemoryMapActivated(m_object);
@@ -11420,8 +11452,52 @@ namespace BinaryNinja {
 			request.Accept(writer);
 			return Inform(buffer.GetString());
 		}
+
+		// Settings cache access - lock-free access to cached settings
+		/*! Get a setting value from the cached settings
+
+			\code{.cpp}
+			bool enabled = analysisContext->GetSetting<bool>("analysis.conservative");
+			\endcode
+
+			\tparam T type for the value you are retrieving
+			\param key Key for the setting
+			\return Value for the setting, with type T
+		*/
+		template <typename T>
+		T GetSetting(const std::string& key);
+
+		// Memory map access - lock-free access to cached MemoryMap
+		bool IsValidOffset(uint64_t offset);
+		bool IsOffsetReadable(uint64_t offset);
+		bool IsOffsetWritable(uint64_t offset);
+		bool IsOffsetExecutable(uint64_t offset);
+		bool IsOffsetBackedByFile(uint64_t offset);
+		uint64_t GetStart();
+		uint64_t GetEnd();
+		uint64_t GetLength();
+		uint64_t GetNextValidOffset(uint64_t offset);
+		uint64_t GetNextMappedAddress(uint64_t addr, uint32_t flags = 0);
+		uint64_t GetNextBackedAddress(uint64_t addr, uint32_t flags = 0);
+		Ref<Segment> GetSegmentAt(uint64_t addr);
+		std::vector<BNAddressRange> GetMappedAddressRanges();
+		std::vector<BNAddressRange> GetBackedAddressRanges();
 	};
 
+	// Explicit template specialization declarations for AnalysisContext::GetSetting<T>
+	template <>
+	bool AnalysisContext::GetSetting<bool>(const std::string& key);
+	template <>
+	double AnalysisContext::GetSetting<double>(const std::string& key);
+	template <>
+	int64_t AnalysisContext::GetSetting<int64_t>(const std::string& key);
+	template <>
+	uint64_t AnalysisContext::GetSetting<uint64_t>(const std::string& key);
+	template <>
+	std::string AnalysisContext::GetSetting<std::string>(const std::string& key);
+	template <>
+	std::vector<std::string> AnalysisContext::GetSetting<std::vector<std::string>>(const std::string& key);
+
 	/*!
 		\ingroup workflow
 	*/

binaryninjacore.h

@@ -37,7 +37,7 @@
 // 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 147
+#define BN_CURRENT_CORE_ABI_VERSION 148
 
 // 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
@@ -5930,6 +5930,30 @@ extern "C"
 	    BNAnalysisContext* analysisContext, BNHighLevelILFunction* highLevelIL);
 	BINARYNINJACOREAPI bool BNAnalysisContextInform(BNAnalysisContext* analysisContext, const char* request);
 
+	// Settings cache access
+	BINARYNINJACOREAPI bool BNAnalysisContextGetSettingBool(BNAnalysisContext* analysisContext, const char* key);
+	BINARYNINJACOREAPI double BNAnalysisContextGetSettingDouble(BNAnalysisContext* analysisContext, const char* key);
+	BINARYNINJACOREAPI int64_t BNAnalysisContextGetSettingInt64(BNAnalysisContext* analysisContext, const char* key);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetSettingUInt64(BNAnalysisContext* analysisContext, const char* key);
+	BINARYNINJACOREAPI char* BNAnalysisContextGetSettingString(BNAnalysisContext* analysisContext, const char* key);
+	BINARYNINJACOREAPI char** BNAnalysisContextGetSettingStringList(BNAnalysisContext* analysisContext, const char* key, size_t* count);
+
+	// Memory map access
+	BINARYNINJACOREAPI bool BNAnalysisContextIsValidOffset(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetReadable(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetWritable(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetExecutable(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetBackedByFile(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetStart(BNAnalysisContext* analysisContext);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetEnd(BNAnalysisContext* analysisContext);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetLength(BNAnalysisContext* analysisContext);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetNextValidOffset(BNAnalysisContext* analysisContext, uint64_t offset);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetNextMappedAddress(BNAnalysisContext* analysisContext, uint64_t addr, uint32_t flags);
+	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetNextBackedAddress(BNAnalysisContext* analysisContext, uint64_t addr, uint32_t flags);
+	BINARYNINJACOREAPI BNSegment* BNAnalysisContextGetSegmentAt(BNAnalysisContext* analysisContext, uint64_t addr);
+	BINARYNINJACOREAPI BNAddressRange* BNAnalysisContextGetMappedAddressRanges(BNAnalysisContext* analysisContext, size_t* count);
+	BINARYNINJACOREAPI BNAddressRange* BNAnalysisContextGetBackedAddressRanges(BNAnalysisContext* analysisContext, size_t* count);
+
 	// Activity
 	BINARYNINJACOREAPI BNActivity* BNCreateActivity(const char* configuration, void* ctxt, void (*action)(void*, BNAnalysisContext*));
 	BINARYNINJACOREAPI BNActivity* BNCreateActivityWithEligibility(const char* configuration, void* ctxt, void (*action)(void*, BNAnalysisContext*), bool (*eligibilityHandler)(void*, BNActivity*, BNAnalysisContext*));

python/binaryview.py

@@ -2457,8 +2457,19 @@ def __iter__(self):
 
 class MemoryMap:
 	r"""
-		The MemoryMap object describes a system-level memory map into which a BinaryView is loaded. Each BinaryView
-		exposes its portion of the MemoryMap through the Segments defined within that view.
+		The MemoryMap object provides access to the system-level memory map describing how a BinaryView is loaded
+		into memory. Each BinaryView exposes its portion of the MemoryMap through the Segments defined within that view.
+
+		**Architecture Note:** This Python MemoryMap object is a proxy that accesses the BinaryView's current
+		MemoryMap state through the FFI boundary. The proxy provides a simple mutable interface: when you call
+		modification operations (``add_memory_region``, ``remove_memory_region``, etc.), the proxy automatically
+		accesses the updated MemoryMap. Internally, the core uses immutable copy-on-write data structures, but
+		the proxy abstracts this away.
+
+		When you access ``view.memory_map``, you always see the current state. For lock-free access during analysis,
+		AnalysisContext provides memory layout query methods (``is_valid_offset()``, ``is_offset_readable()``,
+		``get_start()``, ``get_length()``, etc.) that operate on an immutable snapshot of the MemoryMap cached when
+		the analysis was initiated.
 
 		A MemoryMap can contain multiple, arbitrarily overlapping memory regions. When modified, address space
 		segmentation is automatically managed. If multiple regions overlap, the most recently added region takes
@@ -2615,7 +2626,24 @@ def set_logical_memory_map_enabled(self, enabled: bool) -> None:
 
 	@property
 	def is_activated(self):
-		"""Whether the memory map is activated for the associated view."""
+		"""
+		Whether the memory map is activated for the associated view.
+
+		Returns ``True`` if this MemoryMap represents a parsed BinaryView with real segments
+		(ELF, PE, Mach-O, etc.). Returns ``False`` for Raw BinaryViews or views that failed
+		to parse segments.
+
+		This is determined by whether the BinaryView has a parent view - parsed views have a
+		parent Raw view, while Raw views have no parent.
+
+		Use this to gate features that require parsed binary structure (sections, imports,
+		relocations, etc.). For basic analysis queries (start, length, is_offset_readable, etc.),
+		use the MemoryMap directly regardless of activation state - all BinaryViews have a
+		usable MemoryMap.
+
+		:return: True if this is an activated (parsed) memory map, False otherwise
+		:rtype: bool
+		"""
 		return core.BNIsMemoryMapActivated(self.handle)
 
 	def add_memory_region(self, name: str, start: int, source: Optional[Union['os.PathLike', str, bytes, bytearray, 'BinaryView', 'databuffer.DataBuffer', 'fileaccessor.FileAccessor']] = None, flags: SegmentFlag = 0, fill: int = 0, length: Optional[int] = None) -> bool:

python/workflow.py

@@ -188,6 +188,204 @@ def basic_blocks(self, value: '_function.BasicBlockList') -> None:
 	def inform(self, request: str) -> bool:
 		return core.BNAnalysisContextInform(self.handle, request)
 
+	def get_setting_bool(self, key: str) -> bool:
+		"""
+		Get a boolean setting from the cached settings.
+
+		:param key: Setting key
+		:return: Boolean setting value
+		"""
+		return core.BNAnalysisContextGetSettingBool(self.handle, key)
+
+	def get_setting_double(self, key: str) -> float:
+		"""
+		Get a double setting from the cached settings.
+
+		:param key: Setting key
+		:return: Double setting value
+		"""
+		return core.BNAnalysisContextGetSettingDouble(self.handle, key)
+
+	def get_setting_int64(self, key: str) -> int:
+		"""
+		Get a 64-bit signed integer setting from the cached settings.
+
+		:param key: Setting key
+		:return: Int64 setting value
+		"""
+		return core.BNAnalysisContextGetSettingInt64(self.handle, key)
+
+	def get_setting_uint64(self, key: str) -> int:
+		"""
+		Get a 64-bit unsigned integer setting from the cached settings.
+
+		:param key: Setting key
+		:return: UInt64 setting value
+		"""
+		return core.BNAnalysisContextGetSettingUInt64(self.handle, key)
+
+	def get_setting_string(self, key: str) -> str:
+		"""
+		Get a string setting from the cached settings.
+
+		:param key: Setting key
+		:return: String setting value
+		"""
+		return core.BNAnalysisContextGetSettingString(self.handle, key)
+
+	def get_setting_string_list(self, key: str) -> List[str]:
+		"""
+		Get a string list setting from the cached settings.
+
+		:param key: Setting key
+		:return: List of strings
+		"""
+		count = ctypes.c_size_t()
+		result = core.BNAnalysisContextGetSettingStringList(self.handle, key, ctypes.byref(count))
+		out_list = []
+		for i in range(count.value):
+			out_list.append(result[i].decode('utf-8'))
+		core.BNFreeStringList(result, count.value)
+		return out_list
+
+	def is_valid_offset(self, offset: int) -> bool:
+		"""
+		Check if an offset is mapped in the cached memory map.
+
+		:param offset: Offset to check
+		:return: True if offset is mapped
+		"""
+		return core.BNAnalysisContextIsValidOffset(self.handle, offset)
+
+	def is_offset_readable(self, offset: int) -> bool:
+		"""
+		Check if an offset is readable in the cached memory map.
+
+		:param offset: Offset to check
+		:return: True if offset is readable
+		"""
+		return core.BNAnalysisContextIsOffsetReadable(self.handle, offset)
+
+	def is_offset_writable(self, offset: int) -> bool:
+		"""
+		Check if an offset is writable in the cached memory map.
+
+		:param offset: Offset to check
+		:return: True if offset is writable
+		"""
+		return core.BNAnalysisContextIsOffsetWritable(self.handle, offset)
+
+	def is_offset_executable(self, offset: int) -> bool:
+		"""
+		Check if an offset is executable in the cached memory map.
+
+		:param offset: Offset to check
+		:return: True if offset is executable
+		"""
+		return core.BNAnalysisContextIsOffsetExecutable(self.handle, offset)
+
+	def is_offset_backed_by_file(self, offset: int) -> bool:
+		"""
+		Check if an offset is backed by the file in the cached memory map.
+
+		:param offset: Offset to check
+		:return: True if offset is backed by file
+		"""
+		return core.BNAnalysisContextIsOffsetBackedByFile(self.handle, offset)
+
+	def get_start(self) -> int:
+		"""
+		Get the start address from the cached memory map.
+
+		:return: Start address
+		"""
+		return core.BNAnalysisContextGetStart(self.handle)
+
+	def get_end(self) -> int:
+		"""
+		Get the end address from the cached memory map.
+
+		:return: End address
+		"""
+		return core.BNAnalysisContextGetEnd(self.handle)
+
+	def get_length(self) -> int:
+		"""
+		Get the length of the cached memory map.
+
+		:return: Length
+		"""
+		return core.BNAnalysisContextGetLength(self.handle)
+
+	def get_next_valid_offset(self, offset: int) -> int:
+		"""
+		Get the next valid offset after the given offset from the cached memory map.
+
+		:param offset: Starting offset
+		:return: Next valid offset
+		"""
+		return core.BNAnalysisContextGetNextValidOffset(self.handle, offset)
+
+	def get_next_mapped_address(self, addr: int, flags: int = 0) -> int:
+		"""
+		Get the next mapped address after the given address from the cached memory map.
+
+		:param addr: Starting address
+		:param flags: Optional flags to filter by
+		:return: Next mapped address
+		"""
+		return core.BNAnalysisContextGetNextMappedAddress(self.handle, addr, flags)
+
+	def get_next_backed_address(self, addr: int, flags: int = 0) -> int:
+		"""
+		Get the next backed address after the given address from the cached memory map.
+
+		:param addr: Starting address
+		:param flags: Optional flags to filter by
+		:return: Next backed address
+		"""
+		return core.BNAnalysisContextGetNextBackedAddress(self.handle, addr, flags)
+
+	def get_segment_at(self, addr: int) -> Optional['binaryview.Segment']:
+		"""
+		Get the segment containing the given address from the cached memory map.
+
+		:param addr: Address to query
+		:return: Segment containing the address, or None
+		"""
+		segment = core.BNAnalysisContextGetSegmentAt(self.handle, addr)
+		if not segment:
+			return None
+		return binaryview.Segment(segment)
+
+	def get_mapped_address_ranges(self) -> List[tuple]:
+		"""
+		Get all mapped address ranges from the cached memory map.
+
+		:return: List of (start, end) tuples
+		"""
+		count = ctypes.c_size_t()
+		ranges = core.BNAnalysisContextGetMappedAddressRanges(self.handle, ctypes.byref(count))
+		result = []
+		for i in range(count.value):
+			result.append((ranges[i].start, ranges[i].end))
+		core.BNFreeAddressRanges(ranges)
+		return result
+
+	def get_backed_address_ranges(self) -> List[tuple]:
+		"""
+		Get all backed address ranges from the cached memory map.
+
+		:return: List of (start, end) tuples
+		"""
+		count = ctypes.c_size_t()
+		ranges = core.BNAnalysisContextGetBackedAddressRanges(self.handle, ctypes.byref(count))
+		result = []
+		for i in range(count.value):
+			result.append((ranges[i].start, ranges[i].end))
+		core.BNFreeAddressRanges(ranges)
+		return result
+
 
 class Activity(object):
 	"""