Add APIs for skipping analysis of functions that are too large, and overriding this behavior

2 files changed, 52 insertions, 1 deletions

diff --git a/python/binaryview.py b/python/binaryview.py
index 7a6bc875..1c986a94 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -65,6 +65,9 @@ class BinaryDataNotification(object):
 	def function_updated(self, view, func):
 		pass
 
+	def function_update_requested(self, view, func):
+		pass
+
 	def data_var_added(self, view, var):
 		pass
 
@@ -180,6 +183,7 @@ class BinaryDataNotificationCallbacks(object):
 		self._cb.functionAdded = self._cb.functionAdded.__class__(self._function_added)
 		self._cb.functionRemoved = self._cb.functionRemoved.__class__(self._function_removed)
 		self._cb.functionUpdated = self._cb.functionUpdated.__class__(self._function_updated)
+		self._cb.functionUpdateRequested = self._cb.functionUpdateRequested.__class__(self._function_update_requested)
 		self._cb.dataVariableAdded = self._cb.dataVariableAdded.__class__(self._data_var_added)
 		self._cb.dataVariableRemoved = self._cb.dataVariableRemoved.__class__(self._data_var_removed)
 		self._cb.dataVariableUpdated = self._cb.dataVariableUpdated.__class__(self._data_var_updated)
@@ -230,6 +234,12 @@ class BinaryDataNotificationCallbacks(object):
 		except:
 			log.log_error(traceback.format_exc())
 
+	def _function_update_requested(self, ctxt, view, func):
+		try:
+			self.notify.function_update_requested(self.view, function.Function(self.view, core.BNNewFunctionReference(func)))
+		except:
+			log.log_error(traceback.format_exc())
+
 	def _data_var_added(self, ctxt, view, var):
 		try:
 			address = var[0].address
@@ -1013,6 +1023,15 @@ class BinaryView(object):
 		result = core.BNGetGlobalPointerValue(self.handle)
 		return function.RegisterValue(self.arch, result.value, confidence = result.confidence)
 
+	@property
+	def max_function_size_for_analysis(self):
+		"""Maximum size of function (sum of basic block sizes in bytes) for auto analysis"""
+		return core.BNGetMaxFunctionSizeForAnalysis(self.handle)
+
+	@max_function_size_for_analysis.setter
+	def max_function_size_for_analysis(self, size):
+		core.BNSetMaxFunctionSizeForAnalysis(self.handle, size)
+
 	def __len__(self):
 		return int(core.BNGetViewLength(self.handle))
 
diff --git a/python/function.py b/python/function.py
index f68aa76f..0d796d98 100644
--- a/python/function.py
+++ b/python/function.py
@@ -26,7 +26,8 @@ import ctypes
 import _binaryninjacore as core
 from enums import (FunctionGraphType, BranchType, SymbolType, InstructionTextTokenType,
 	HighlightStandardColor, HighlightColorStyle, RegisterValueType, ImplicitRegisterExtend,
-	DisassemblyOption, IntegerDisplayType, InstructionTextTokenContext, VariableSourceType)
+	DisassemblyOption, IntegerDisplayType, InstructionTextTokenContext, VariableSourceType,
+	FunctionAnalysisSkipOverride)
 import architecture
 import platform
 import highlight
@@ -817,6 +818,32 @@ class Function(object):
 			for i in block:
 				yield i
 
+	@property
+	def too_large(self):
+		"""Whether the function is too large to automatically perform analysis (read-only)"""
+		return core.BNIsFunctionTooLarge(self.handle)
+
+	@property
+	def analysis_skipped(self):
+		"""Whether automatic analysis was skipped for this function"""
+		return core.BNIsFunctionAnalysisSkipped(self.handle)
+
+	@analysis_skipped.setter
+	def analysis_skipped(self, skip):
+		if skip:
+			core.BNSetFunctionAnalysisSkipOverride(self.handle, FunctionAnalysisSkipOverride.AlwaysSkipFunctionAnalysis)
+		else:
+			core.BNSetFunctionAnalysisSkipOverride(self.handle, FunctionAnalysisSkipOverride.NeverSkipFunctionAnalysis)
+
+	@property
+	def analysis_skip_override(self):
+		"""Override for skipping of automatic analysis"""
+		return FunctionAnalysisSkipOverride(core.BNGetFunctionAnalysisSkipOverride(self.handle))
+
+	@analysis_skip_override.setter
+	def analysis_skip_override(self, override):
+		core.BNSetFunctionAnalysisSkipOverride(self.handle, override)
+
 	def __iter__(self):
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetFunctionBasicBlockList(self.handle, count)
@@ -1836,6 +1863,11 @@ class FunctionGraph(object):
 		return result
 
 	@property
+	def has_blocks(self):
+		"""Whether the function graph has at least one block (read-only)"""
+		return core.BNFunctionGraphHasBlocks(self.handle)
+
+	@property
 	def width(self):
 		"""Function graph width (read-only)"""
 		return core.BNGetFunctionGraphWidth(self.handle)