Remove ActivityContext accessors for SectionMap

Author: emesare

binaryninjaapi.h

@@ -11394,6 +11394,8 @@ namespace BinaryNinja {
 		*/
 		Ref<BinaryView> GetBinaryView();
 
+		Ref<SectionMap> GetSectionMap();
+
 		/*! Get the Function for the current AnalysisContext
 
 			\return The function for the current context

binaryninjacore.h

@@ -5958,19 +5958,14 @@ extern "C"
 	BINARYNINJACOREAPI char* BNAnalysisContextGetSettingString(BNAnalysisContext* analysisContext, const char* key);
 	BINARYNINJACOREAPI char** BNAnalysisContextGetSettingStringList(BNAnalysisContext* analysisContext, const char* key, size_t* count);
 
+	BINARYNINJACOREAPI BNSectionMap* BNAnalysisContextGetSectionMap(BNAnalysisContext* analysisContext);
+	
 	// 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 bool BNAnalysisContextIsOffsetCodeSemantics(BNAnalysisContext* analysisContext, uint64_t offset);
-	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetExternSemantics(BNAnalysisContext* analysisContext, uint64_t offset);
-	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetWritableSemantics(BNAnalysisContext* analysisContext, uint64_t offset);
-	BINARYNINJACOREAPI bool BNAnalysisContextIsOffsetReadOnlySemantics(BNAnalysisContext* analysisContext, uint64_t offset);
-	BINARYNINJACOREAPI BNSection** BNAnalysisContextGetSections(BNAnalysisContext* analysisContext, size_t* count);
-	BINARYNINJACOREAPI BNSection* BNAnalysisContextGetSectionByName(BNAnalysisContext* analysisContext, const char* name);
-	BINARYNINJACOREAPI BNSection** BNAnalysisContextGetSectionsAt(BNAnalysisContext* analysisContext, uint64_t addr, size_t* count);
 	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetStart(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetEnd(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI uint64_t BNAnalysisContextGetLength(BNAnalysisContext* analysisContext);

python/workflow.py

@@ -62,6 +62,16 @@ def view(self) -> Optional['binaryview.BinaryView']:
 			return None
 		return binaryview.BinaryView(handle=result)
 
+	@property
+	def section_map(self) -> Optional['binaryview.SectionMap']:
+		"""
+		SectionMap for the current AnalysisContext (read-only)
+		"""
+		result = core.BNAnalysisContextGetSectionMap(self.handle)
+		if not result:
+			return None
+		return binaryview.SectionMap(handle=result)
+
 	@property
 	def function(self) -> Optional['_function.Function']:
 		"""
@@ -293,83 +303,6 @@ def is_offset_backed_by_file(self, offset: int) -> bool:
 		"""
 		return core.BNAnalysisContextIsOffsetBackedByFile(self.handle, offset)
 
-	def is_offset_code_semantics(self, offset: int) -> bool:
-		"""
-		Check if an offset has code semantics in the cached section map.
-
-		:param offset: Offset to check
-		:return: True if offset has code semantics
-		"""
-		return core.BNAnalysisContextIsOffsetCodeSemantics(self.handle, offset)
-
-	def is_offset_extern_semantics(self, offset: int) -> bool:
-		"""
-		Check if an offset has external semantics in the cached section map.
-
-		:param offset: Offset to check
-		:return: True if offset has external semantics
-		"""
-		return core.BNAnalysisContextIsOffsetExternSemantics(self.handle, offset)
-
-	def is_offset_writable_semantics(self, offset: int) -> bool:
-		"""
-		Check if an offset has writable semantics in the cached section map.
-
-		:param offset: Offset to check
-		:return: True if offset has writable semantics
-		"""
-		return core.BNAnalysisContextIsOffsetWritableSemantics(self.handle, offset)
-
-	def is_offset_readonly_semantics(self, offset: int) -> bool:
-		"""
-		Check if an offset has read-only semantics in the cached section map.
-
-		:param offset: Offset to check
-		:return: True if offset has read-only semantics
-		"""
-		return core.BNAnalysisContextIsOffsetReadOnlySemantics(self.handle, offset)
-
-	def get_sections(self) -> List['binaryninja.binaryview.Section']:
-		"""
-		Get all sections from the cached section map.
-
-		:return: List of all sections
-		"""
-		count = ctypes.c_ulonglong()
-		sections = core.BNAnalysisContextGetSections(self.handle, count)
-		result = []
-		for i in range(count.value):
-			result.append(binaryninja.binaryview.Section(core.BNNewSectionReference(sections[i])))
-		core.BNFreeSectionList(sections, count.value)
-		return result
-
-	def get_section_by_name(self, name: str) -> Optional['binaryninja.binaryview.Section']:
-		"""
-		Get a section by name from the cached section map.
-
-		:param name: Section name
-		:return: Section with the given name, or None if not found
-		"""
-		section = core.BNAnalysisContextGetSectionByName(self.handle, name)
-		if not section:
-			return None
-		return binaryninja.binaryview.Section(section)
-
-	def get_sections_at(self, addr: int) -> List['binaryninja.binaryview.Section']:
-		"""
-		Get all sections containing the given address from the cached section map.
-
-		:param addr: Address to query
-		:return: List of sections containing the address
-		"""
-		count = ctypes.c_ulonglong()
-		sections = core.BNAnalysisContextGetSectionsAt(self.handle, addr, count)
-		result = []
-		for i in range(count.value):
-			result.append(binaryninja.binaryview.Section(core.BNNewSectionReference(sections[i])))
-		core.BNFreeSectionList(sections, count.value)
-		return result
-
 	def get_start(self) -> int:
 		"""
 		Get the start address from the cached memory map.

rust/src/workflow.rs

@@ -12,7 +12,7 @@ use crate::high_level_il::HighLevelILFunction;
 use crate::low_level_il::{LowLevelILMutableFunction, LowLevelILRegularFunction};
 use crate::medium_level_il::MediumLevelILFunction;
 use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner, Guard, Ref, RefCountable};
-use crate::section::Section;
+use crate::section::SectionMap;
 use crate::segment::{Segment, SegmentFlags};
 use crate::string::{BnString, IntoCStr};
 use std::ffi::c_char;
@@ -40,13 +40,20 @@ impl AnalysisContext {
         Ref::new(Self { handle })
     }
 
-    /// BinaryView for the current AnalysisContext
+    /// [`BinaryView`] for the current AnalysisContext
     pub fn view(&self) -> Ref<BinaryView> {
         let result = unsafe { BNAnalysisContextGetBinaryView(self.handle.as_ptr()) };
         assert!(!result.is_null());
         unsafe { BinaryView::ref_from_raw(result) }
     }
 
+    /// [`SectionMap`] for the current AnalysisContext
+    pub fn section_map(&self) -> Ref<SectionMap> {
+        let result = unsafe { BNAnalysisContextGetSectionMap(self.handle.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe { SectionMap::ref_from_raw(result) }
+    }
+
     /// [`Function`] for the current AnalysisContext
     pub fn function(&self) -> Ref<Function> {
         let result = unsafe { BNAnalysisContextGetFunction(self.handle.as_ptr()) };
@@ -216,71 +223,6 @@ impl AnalysisContext {
         unsafe { BNAnalysisContextIsOffsetBackedByFile(self.handle.as_ptr(), offset) }
     }
 
-    /// Check if an offset has code semantics in the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::offset_has_code_semantics`].
-    pub fn is_offset_code_semantics(&self, offset: u64) -> bool {
-        unsafe { BNAnalysisContextIsOffsetCodeSemantics(self.handle.as_ptr(), offset) }
-    }
-
-    /// Check if an offset has external semantics in the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::offset_has_extern_semantics`].
-    pub fn is_offset_extern_semantics(&self, offset: u64) -> bool {
-        unsafe { BNAnalysisContextIsOffsetExternSemantics(self.handle.as_ptr(), offset) }
-    }
-
-    /// Check if an offset has writable semantics in the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::offset_has_writable_semantics`].
-    pub fn is_offset_writable_semantics(&self, offset: u64) -> bool {
-        unsafe { BNAnalysisContextIsOffsetWritableSemantics(self.handle.as_ptr(), offset) }
-    }
-
-    /// Check if an offset has read-only semantics in the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::offset_has_read_only_semantics`].
-    pub fn is_offset_readonly_semantics(&self, offset: u64) -> bool {
-        unsafe { BNAnalysisContextIsOffsetReadOnlySemantics(self.handle.as_ptr(), offset) }
-    }
-
-    /// Get all sections from the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::sections`].
-    pub fn sections(&self) -> Array<Section> {
-        unsafe {
-            let mut count = 0;
-            let sections = BNAnalysisContextGetSections(self.handle.as_ptr(), &mut count);
-            Array::new(sections, count, ())
-        }
-    }
-
-    /// Get a section by name from the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::section_by_name`].
-    pub fn section_by_name(&self, name: impl IntoCStr) -> Option<Ref<Section>> {
-        unsafe {
-            let raw_name = name.to_cstr();
-            let name_ptr = raw_name.as_ptr();
-            let raw_section_ptr = BNAnalysisContextGetSectionByName(self.handle.as_ptr(), name_ptr);
-            match raw_section_ptr.is_null() {
-                false => Some(Section::ref_from_raw(raw_section_ptr)),
-                true => None,
-            }
-        }
-    }
-
-    /// Get all sections containing the given address from the cached section map.
-    ///
-    /// NOTE: This is a lock-free alternative to [`BinaryViewExt::sections_at`].
-    pub fn sections_at(&self, addr: u64) -> Array<Section> {
-        unsafe {
-            let mut count = 0;
-            let sections = BNAnalysisContextGetSectionsAt(self.handle.as_ptr(), addr, &mut count);
-            Array::new(sections, count, ())
-        }
-    }
-
     /// Get the start address (the lowest address) from the cached [`MemoryMap`].
     ///
     /// NOTE: This is a lock-free alternative to [`BinaryView::start`].

workflow.cpp

@@ -29,6 +29,15 @@ Ref<BinaryView> AnalysisContext::GetBinaryView()
 }
 
 
+Ref<SectionMap> AnalysisContext::GetSectionMap()
+{
+	BNSectionMap* sectionMap = BNAnalysisContextGetSectionMap(m_object);
+	if (!sectionMap)
+		return nullptr;
+	return new SectionMap(sectionMap);
+}
+
+
 Ref<Function> AnalysisContext::GetFunction()
 {
 	BNFunction* func = BNAnalysisContextGetFunction(m_object);
@@ -235,65 +244,6 @@ bool AnalysisContext::IsOffsetBackedByFile(uint64_t offset)
 }
 
 
-bool AnalysisContext::IsOffsetCodeSemantics(uint64_t offset)
-{
-	return BNAnalysisContextIsOffsetCodeSemantics(m_object, offset);
-}
-
-
-bool AnalysisContext::IsOffsetExternSemantics(uint64_t offset)
-{
-	return BNAnalysisContextIsOffsetExternSemantics(m_object, offset);
-}
-
-
-bool AnalysisContext::IsOffsetWritableSemantics(uint64_t offset)
-{
-	return BNAnalysisContextIsOffsetWritableSemantics(m_object, offset);
-}
-
-
-bool AnalysisContext::IsOffsetReadOnlySemantics(uint64_t offset)
-{
-	return BNAnalysisContextIsOffsetReadOnlySemantics(m_object, offset);
-}
-
-
-vector<Ref<Section>> AnalysisContext::GetSections()
-{
-	size_t count;
-	BNSection** sections = BNAnalysisContextGetSections(m_object, &count);
-	vector<Ref<Section>> result;
-	result.reserve(count);
-	for (size_t i = 0; i < count; i++)
-		result.push_back(new Section(BNNewSectionReference(sections[i])));
-	BNFreeSectionList(sections, count);
-	return result;
-}
-
-
-Ref<Section> AnalysisContext::GetSectionByName(const string& name)
-{
-	BNSection* section = BNAnalysisContextGetSectionByName(m_object, name.c_str());
-	if (!section)
-		return nullptr;
-	return new Section(section);
-}
-
-
-vector<Ref<Section>> AnalysisContext::GetSectionsAt(uint64_t addr)
-{
-	size_t count;
-	BNSection** sections = BNAnalysisContextGetSectionsAt(m_object, addr, &count);
-	vector<Ref<Section>> result;
-	result.reserve(count);
-	for (size_t i = 0; i < count; i++)
-		result.push_back(new Section(BNNewSectionReference(sections[i])));
-	BNFreeSectionList(sections, count);
-	return result;
-}
-
-
 uint64_t AnalysisContext::GetStart()
 {
 	return BNAnalysisContextGetStart(m_object);