Merge remote-tracking branch 'upstream' into dev

Author: nullableVoidPtr

.gitignore

@@ -79,6 +79,7 @@ suite/binaryninja/
 build
 generator
 types/
+!/docs/guide/types/
 
 # Rust
 rust/**/*.swp

binaryninjaapi.h

@@ -3608,6 +3608,7 @@ namespace BinaryNinja {
 		Ref<ProjectFolder> GetParent() const;
 		bool SetParent(Ref<ProjectFolder> parent);
 		bool Export(const std::string& destination, const ProgressFunction& progressCallback = {}) const;
+		std::vector<Ref<ProjectFile>> GetFiles() const;
 	};
 
 	/*!
@@ -3688,6 +3689,8 @@ namespace BinaryNinja {
 		Ref<ProjectFile> GetFileById(const std::string& id) const;
 		Ref<ProjectFile> GetFileByPathOnDisk(const std::string& path) const;
 		std::vector<Ref<ProjectFile>> GetFilesByPathInProject(const std::string& path) const;
+		std::vector<Ref<ProjectFile>> GetFilesInFolder(Ref<ProjectFolder> folder) const;
+
 		bool PushFile(Ref<ProjectFile> file);
 		bool DeleteFile_(Ref<ProjectFile> file);
 
@@ -6008,8 +6011,9 @@ namespace BinaryNinja {
 		*/
 		bool IsOffsetBackedByFile(uint64_t offset) const;
 		bool IsOffsetCodeSemantics(uint64_t offset) const;
-		bool IsOffsetWritableSemantics(uint64_t offset) const;
 		bool IsOffsetExternSemantics(uint64_t offset) const;
+		bool IsOffsetWritableSemantics(uint64_t offset) const;
+		bool IsOffsetReadOnlySemantics(uint64_t offset) const;
 
 		/*! GetNextValidOffset implements a query for the next valid readable, writable, or executable virtual memory address after `offset`
 
@@ -7836,6 +7840,15 @@ namespace BinaryNinja {
 		    uint64_t entrySize = 0, const std::string& linkedSection = "", const std::string& infoSection = "",
 		    uint64_t infoData = 0);
 
+		/*! Adds multiple automatically defined sections in a batch operation
+
+			This method is more efficient than calling AddAutoSection multiple times as it only triggers
+			one SectionMap rebuild for all sections.
+
+			\param sections Vector of BNSectionInfo describing the sections to add
+		*/
+		void AddAutoSections(const std::vector<BNSectionInfo>& sections);
+
 		/*! Remove an automatically defined section by name
 
 			\param name Name of the section
@@ -7863,6 +7876,17 @@ namespace BinaryNinja {
 		    uint64_t entrySize = 0, const std::string& linkedSection = "", const std::string& infoSection = "",
 		    uint64_t infoData = 0);
 
+		/*! Adds multiple user-defined sections in a batch operation
+
+			This method is more efficient than calling AddUserSection multiple times as it only triggers
+			one SectionMap rebuild for all sections.
+
+			Note that all data specified must already be mapped by an existing segment.
+
+			\param sections Vector of BNSectionInfo describing the sections to add
+		*/
+		void AddUserSections(const std::vector<BNSectionInfo>& sections);
+
 		/*! Remove a user defined section by name
 
 			\param name Name of the section to remove
@@ -8129,6 +8153,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 +8182,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 +11476,61 @@ 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();
+
+		// Section map access - lock-free access to cached SectionMap
+		bool IsOffsetCodeSemantics(uint64_t offset);
+		bool IsOffsetExternSemantics(uint64_t offset);
+		bool IsOffsetWritableSemantics(uint64_t offset);
+		bool IsOffsetReadOnlySemantics(uint64_t offset);
+		std::vector<Ref<Section>> GetSections();
+		Ref<Section> GetSectionByName(const std::string& name);
+		std::vector<Ref<Section>> GetSectionsAt(uint64_t addr);
 	};
 
+	// 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 151
 
 // 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
@@ -3682,6 +3682,19 @@ extern "C"
 		uint32_t flags;
 	} BNSegmentInfo;
 
+	typedef struct BNSectionInfo {
+		const char* name;
+		uint64_t start;
+		uint64_t length;
+		BNSectionSemantics semantics;
+		const char* type;
+		uint64_t align;
+		uint64_t entrySize;
+		const char* linkedSection;
+		const char* infoSection;
+		uint64_t infoData;
+	} BNSectionInfo;
+
 	typedef bool(*BNCollaborationAnalysisConflictHandler)(void*, const char** keys, BNAnalysisMergeConflict** conflicts, size_t conflictCount);
 	typedef bool(*BNCollaborationNameChangesetFunction)(void*, BNCollaborationChangeset*);
 
@@ -4179,6 +4192,7 @@ extern "C"
 	BINARYNINJACOREAPI BNProjectFile* BNProjectGetFileById(BNProject* project, const char* id);
 	BINARYNINJACOREAPI BNProjectFile* BNProjectGetFileByPathOnDisk(BNProject* project, const char* path);
 	BINARYNINJACOREAPI BNProjectFile** BNProjectGetFilesByPathInProject(BNProject* project, const char* path, size_t* count);
+	BINARYNINJACOREAPI BNProjectFile** BNProjectGetFilesInFolder(BNProject* project, BNProjectFolder* folder, size_t* count);
 
 	BINARYNINJACOREAPI bool BNProjectPushFile(BNProject* project, BNProjectFile* file);
 	BINARYNINJACOREAPI bool BNProjectDeleteFile(BNProject* project, BNProjectFile* file);
@@ -4235,6 +4249,7 @@ extern "C"
 	BINARYNINJACOREAPI BNProject* BNProjectFolderGetProject(BNProjectFolder* folder);
 	BINARYNINJACOREAPI bool BNProjectFolderExport(BNProjectFolder* folder, const char* destination, void* ctxt,
 		BNProgressFunction progress);
+	BINARYNINJACOREAPI BNProjectFile** BNProjectFolderGetFiles(BNProjectFolder* folder, size_t* count);
 
 	// ExternalLibrary object
 	BINARYNINJACOREAPI BNExternalLibrary* BNNewExternalLibraryReference(BNExternalLibrary* lib);
@@ -4445,6 +4460,7 @@ extern "C"
 	BINARYNINJACOREAPI bool BNIsOffsetCodeSemantics(BNBinaryView* view, uint64_t offset);
 	BINARYNINJACOREAPI bool BNIsOffsetExternSemantics(BNBinaryView* view, uint64_t offset);
 	BINARYNINJACOREAPI bool BNIsOffsetWritableSemantics(BNBinaryView* view, uint64_t offset);
+	BINARYNINJACOREAPI bool BNIsOffsetReadOnlySemantics(BNBinaryView* view, uint64_t offset);
 	BINARYNINJACOREAPI uint64_t BNGetNextValidOffset(BNBinaryView* view, uint64_t offset);
 
 	BINARYNINJACOREAPI uint64_t BNGetImageBase(BNBinaryView* view);
@@ -4563,10 +4579,12 @@ extern "C"
 	BINARYNINJACOREAPI void BNAddAutoSection(BNBinaryView* view, const char* name, uint64_t start, uint64_t length,
 	    BNSectionSemantics semantics, const char* type, uint64_t align, uint64_t entrySize, const char* linkedSection,
 	    const char* infoSection, uint64_t infoData);
+	BINARYNINJACOREAPI void BNAddAutoSections(BNBinaryView* view, const BNSectionInfo* sectionInfo, size_t count);
 	BINARYNINJACOREAPI void BNRemoveAutoSection(BNBinaryView* view, const char* name);
 	BINARYNINJACOREAPI void BNAddUserSection(BNBinaryView* view, const char* name, uint64_t start, uint64_t length,
 	    BNSectionSemantics semantics, const char* type, uint64_t align, uint64_t entrySize, const char* linkedSection,
 	    const char* infoSection, uint64_t infoData);
+	BINARYNINJACOREAPI void BNAddUserSections(BNBinaryView* view, const BNSectionInfo* sectionInfo, size_t count);
 	BINARYNINJACOREAPI void BNRemoveUserSection(BNBinaryView* view, const char* name);
 	BINARYNINJACOREAPI BNSection** BNGetSections(BNBinaryView* view, size_t* count);
 	BINARYNINJACOREAPI BNSection** BNGetSectionsAt(BNBinaryView* view, uint64_t addr, size_t* count);
@@ -5930,6 +5948,37 @@ 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 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);
+	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*));

binaryview.cpp

@@ -2013,6 +2013,12 @@ bool BinaryView::IsOffsetWritableSemantics(uint64_t offset) const
 }
 
 
+bool BinaryView::IsOffsetReadOnlySemantics(uint64_t offset) const
+{
+	return BNIsOffsetReadOnlySemantics(m_object, offset);
+}
+
+
 uint64_t BinaryView::GetNextValidOffset(uint64_t offset) const
 {
 	return BNGetNextValidOffset(m_object, offset);
@@ -5263,6 +5269,12 @@ void BinaryView::AddAutoSection(const string& name, uint64_t start, uint64_t len
 }
 
 
+void BinaryView::AddAutoSections(const vector<BNSectionInfo>& sections)
+{
+	BNAddAutoSections(m_object, sections.data(), sections.size());
+}
+
+
 void BinaryView::RemoveAutoSection(const string& name)
 {
 	BNRemoveAutoSection(m_object, name.c_str());
@@ -5278,6 +5290,12 @@ void BinaryView::AddUserSection(const string& name, uint64_t start, uint64_t len
 }
 
 
+void BinaryView::AddUserSections(const vector<BNSectionInfo>& sections)
+{
+	BNAddUserSections(m_object, sections.data(), sections.size());
+}
+
+
 void BinaryView::RemoveUserSection(const string& name)
 {
 	BNRemoveUserSection(m_object, name.c_str());