Merge remote-tracking branch 'origin/dev' into powerpc_vle_merging

Author: galenbwill

binaryninjaapi.h

@@ -10033,6 +10033,12 @@ namespace BinaryNinja {
 		*/
 		Ref<Function> GetFunction();
 
+		/*! Get the lifted IL function for the current AnalysisContext
+
+			\return The Lifted IL LowLevelILFunction for the current context
+		*/
+		Ref<LowLevelILFunction> GetLiftedILFunction();
+
 		/*! Get the low level IL function for the current AnalysisContext
 
 			\return The LowLevelILFunction for the current context
@@ -11211,6 +11217,7 @@ namespace BinaryNinja {
 		void ApplyAutoDiscoveredType(Type* type);
 
 		Ref<FlowGraph> CreateFunctionGraph(const FunctionViewType& type, DisassemblySettings* settings = nullptr);
+		Ref<FlowGraph> CreateFunctionGraphImmediate(const FunctionViewType& type, DisassemblySettings* settings = nullptr);
 
 		std::map<int64_t, std::vector<VariableNameAndType>> GetStackLayout();
 		void CreateAutoStackVariable(int64_t offset, const Confidence<Ref<Type>>& type, const std::string& name);
@@ -11409,6 +11416,7 @@ namespace BinaryNinja {
 		std::map<Variable, std::map<ArchAndAddr, Ref<FieldResolutionInfo>>> GetAllFieldResolutions();
 
 		void RequestDebugReport(const std::string& name);
+		bool CheckForDebugReport(const std::string& name);
 
 		/*! Get the name for a given label ID
 
@@ -13387,6 +13395,7 @@ namespace BinaryNinja {
 		}
 
 		Ref<FlowGraph> CreateFunctionGraph(DisassemblySettings* settings = nullptr);
+		Ref<FlowGraph> CreateFunctionGraphImmediate(DisassemblySettings* settings = nullptr);
 	};
 
 	/*!
@@ -13779,6 +13788,7 @@ namespace BinaryNinja {
 		}
 
 		Ref<FlowGraph> CreateFunctionGraph(DisassemblySettings* settings = nullptr);
+		Ref<FlowGraph> CreateFunctionGraphImmediate(DisassemblySettings* settings = nullptr);
 
 		std::set<size_t> GetLiveInstructionsForVariable(const Variable& var, bool includeLastUse = true);
 
@@ -14074,6 +14084,7 @@ namespace BinaryNinja {
 		void VisitAllExprs(const std::function<bool(const HighLevelILInstruction& expr)>& func);
 
 		Ref<FlowGraph> CreateFunctionGraph(DisassemblySettings* settings = nullptr);
+		Ref<FlowGraph> CreateFunctionGraphImmediate(DisassemblySettings* settings = nullptr);
 
 		size_t GetExprIndexForLabel(uint64_t label);
 		std::set<size_t> GetUsesForLabel(uint64_t label);

binaryninjacore.h

@@ -5505,6 +5505,7 @@ extern "C"
 			const BNArchitectureAndAddress* defSite);
 
 	BINARYNINJACOREAPI void BNRequestFunctionDebugReport(BNFunction* func, const char* name);
+	BINARYNINJACOREAPI bool BNFunctionCheckForDebugReport(BNFunction* func, const char* name);
 
 	BINARYNINJACOREAPI BNILReferenceSource* BNGetMediumLevelILVariableReferences(
 	    BNFunction* func, BNVariable* var, size_t* count);
@@ -5541,6 +5542,7 @@ extern "C"
 	BINARYNINJACOREAPI void BNFreeAnalysisContext(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI BNBinaryView* BNAnalysisContextGetBinaryView(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI BNFunction* BNAnalysisContextGetFunction(BNAnalysisContext* analysisContext);
+	BINARYNINJACOREAPI BNLowLevelILFunction* BNAnalysisContextGetLiftedILFunction(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI BNLowLevelILFunction* BNAnalysisContextGetLowLevelILFunction(BNAnalysisContext* analysisContext);
 	BINARYNINJACOREAPI BNMediumLevelILFunction* BNAnalysisContextGetMediumLevelILFunction(
 	    BNAnalysisContext* analysisContext);
@@ -5652,6 +5654,14 @@ extern "C"
 	    BNMediumLevelILFunction* func, BNDisassemblySettings* settings);
 	BINARYNINJACOREAPI BNFlowGraph* BNCreateHighLevelILFunctionGraph(
 	    BNHighLevelILFunction* func, BNDisassemblySettings* settings);
+	BINARYNINJACOREAPI BNFlowGraph* BNCreateImmediateFunctionGraph(
+	    BNFunction* func, BNFunctionViewType type, BNDisassemblySettings* settings);
+	BINARYNINJACOREAPI BNFlowGraph* BNCreateLowLevelILImmediateFunctionGraph(
+	    BNLowLevelILFunction* func, BNDisassemblySettings* settings);
+	BINARYNINJACOREAPI BNFlowGraph* BNCreateMediumLevelILImmediateFunctionGraph(
+	    BNMediumLevelILFunction* func, BNDisassemblySettings* settings);
+	BINARYNINJACOREAPI BNFlowGraph* BNCreateHighLevelILImmediateFunctionGraph(
+	    BNHighLevelILFunction* func, BNDisassemblySettings* settings);
 	BINARYNINJACOREAPI BNFlowGraph* BNCreateCustomFlowGraph(BNCustomFlowGraph* callbacks);
 	BINARYNINJACOREAPI BNFlowGraph* BNNewFlowGraphReference(BNFlowGraph* graph);
 	BINARYNINJACOREAPI void BNFreeFlowGraph(BNFlowGraph* graph);

function.cpp

@@ -1292,6 +1292,13 @@ Ref<FlowGraph> Function::CreateFunctionGraph(const FunctionViewType& type, Disas
 }
 
 
+Ref<FlowGraph> Function::CreateFunctionGraphImmediate(const FunctionViewType& type, DisassemblySettings* settings)
+{
+	BNFlowGraph* graph = BNCreateImmediateFunctionGraph(m_object, type.ToAPIObject(), settings ? settings->GetObject() : nullptr);
+	return new CoreFlowGraph(graph);
+}
+
+
 map<int64_t, vector<VariableNameAndType>> Function::GetStackLayout()
 {
 	size_t count;
@@ -2778,6 +2785,12 @@ void Function::RequestDebugReport(const string& name)
 }
 
 
+bool Function::CheckForDebugReport(const string& name)
+{
+	return BNFunctionCheckForDebugReport(m_object, name.c_str());
+}
+
+
 string Function::GetGotoLabelName(uint64_t labelId)
 {
 	char* name = BNGetGotoLabelName(m_object, labelId);

highlevelil.cpp

@@ -564,6 +564,13 @@ Ref<FlowGraph> HighLevelILFunction::CreateFunctionGraph(DisassemblySettings* set
 }
 
 
+Ref<FlowGraph> HighLevelILFunction::CreateFunctionGraphImmediate(DisassemblySettings* settings)
+{
+	BNFlowGraph* graph = BNCreateHighLevelILImmediateFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);
+	return new CoreFlowGraph(graph);
+}
+
+
 size_t HighLevelILFunction::GetExprIndexForLabel(uint64_t label)
 {
 	return BNGetHighLevelILExprIndexForLabel(m_object, label);

lowlevelil.cpp

@@ -1038,3 +1038,10 @@ Ref<FlowGraph> LowLevelILFunction::CreateFunctionGraph(DisassemblySettings* sett
 	BNFlowGraph* graph = BNCreateLowLevelILFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);
 	return new CoreFlowGraph(graph);
 }
+
+
+Ref<FlowGraph> LowLevelILFunction::CreateFunctionGraphImmediate(DisassemblySettings* settings)
+{
+	BNFlowGraph* graph = BNCreateLowLevelILImmediateFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);
+	return new CoreFlowGraph(graph);
+}

lowlevelilinstruction.cpp

@@ -3035,7 +3035,7 @@ ExprId LowLevelILFunction::RegisterStackFreeReg(uint32_t reg, const ILSourceLoca
 
 ExprId LowLevelILFunction::RegisterStackFreeTopRelative(uint32_t regStack, ExprId entry, const ILSourceLocation& loc)
 {
-	return AddExprWithLocation(LLIL_REG_STACK_FREE_REG, loc, 0, 0, regStack, entry);
+	return AddExprWithLocation(LLIL_REG_STACK_FREE_REL, loc, 0, 0, regStack, entry);
 }
 
 

mediumlevelil.cpp

@@ -941,6 +941,13 @@ Ref<FlowGraph> MediumLevelILFunction::CreateFunctionGraph(DisassemblySettings* s
 }
 
 
+Ref<FlowGraph> MediumLevelILFunction::CreateFunctionGraphImmediate(DisassemblySettings* settings)
+{
+	BNFlowGraph* graph = BNCreateMediumLevelILImmediateFunctionGraph(m_object, settings ? settings->GetObject() : nullptr);
+	return new CoreFlowGraph(graph);
+}
+
+
 set<size_t> MediumLevelILFunction::GetLiveInstructionsForVariable(const Variable& var, bool includeLastUse)
 {
 	size_t count;

python/basicblock.py

@@ -118,10 +118,17 @@ def _from_core_block(cls, block: core.BNBasicBlockHandle) -> Optional['BasicBloc
 
 	def __repr__(self):
 		arch = self.arch
-		if arch:
-			return f"<{self.__class__.__name__}: {arch.name}@{self.start:#x}-{self.end:#x}>"
+		if self.is_il:
+			# IL indices are shown as decimal
+			if arch:
+				return f"<{self.__class__.__name__}: {arch.name}@{self.start}-{self.end}>"
+			else:
+				return f"<{self.__class__.__name__}: {self.start}-{self.end}>"
 		else:
-			return f"<{self.__class__.__name__}: {self.start:#x}-{self.end:#x}>"
+			if arch:
+				return f"<{self.__class__.__name__}: {arch.name}@{self.start:#x}-{self.end:#x}>"
+			else:
+				return f"<{self.__class__.__name__}: {self.start:#x}-{self.end:#x}>"
 
 	def __len__(self):
 		return int(core.BNGetBasicBlockLength(self.handle))
@@ -430,65 +437,134 @@ def _make_blocks(self, blocks, count: int) -> List['BasicBlock']:
 
 	@property
 	def dominators(self) -> List['BasicBlock']:
-		"""List of dominators for this basic block (read-only)"""
+		"""
+		List of dominators for this basic block (read-only).
+
+		A dominator of a basic block B is a block that must be executed before B can be executed.
+		In other words, every path from the entry block to B must go through the dominator.
+		This includes B itself - every block dominates itself. See
+		:py:func:`BasicBlock.strict_dominators` for dominators that don't include B.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominators(self.handle, count, False)
 		return self._make_blocks(blocks, count.value)
 
 	@property
 	def post_dominators(self) -> List['BasicBlock']:
-		"""List of dominators for this basic block (read-only)"""
+		"""
+		List of post-dominators for this basic block (read-only)
+
+		A post-dominator of a basic block B is a block that must be executed after B is executed.
+		In other words, every path from B to an exit block must go through the post-dominator.
+		This includes B itself - every block post-dominates itself. See
+		:py:func:`BasicBlock.strict_post_dominators` for post-dominators that don't include B.
+		If B has outgoing edges that can lead to different exit blocks, then this will only include B.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominators(self.handle, count, True)
 		return self._make_blocks(blocks, count.value)
 
 	@property
 	def strict_dominators(self) -> List['BasicBlock']:
-		"""List of strict dominators for this basic block (read-only)"""
+		"""
+		List of strict dominators for this basic block (read-only)
+
+		A strict dominator of a basic block B is a dominator of B that is not B itself.
+		See :py:func:`BasicBlock.dominators` for the definition of a dominator.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockStrictDominators(self.handle, count, False)
 		return self._make_blocks(blocks, count.value)
 
+	@property
+	def strict_post_dominators(self) -> List['BasicBlock']:
+		"""
+		List of strict post-dominators for this basic block (read-only)
+
+		A strict post-dominator of a basic block B is a post-dominator of B that is not B itself.
+		See :py:func:`BasicBlock.post_dominators` for the definition of a post-dominator.
+		"""
+		count = ctypes.c_ulonglong()
+		blocks = core.BNGetBasicBlockStrictDominators(self.handle, count, True)
+		return self._make_blocks(blocks, count.value)
+
 	@property
 	def immediate_dominator(self) -> Optional['BasicBlock']:
-		"""Immediate dominator of this basic block (read-only)"""
+		"""
+		Immediate dominator of this basic block (read-only)
+
+		The immediate dominator of a basic block B is the dominator closest to B in the control flow graph.
+		In other words, among all dominators of B, it is the dominator that doesn't dominate any other
+		dominator of B except itself. Each basic block except the entry block has a unique immediate dominator.
+		"""
 		result = core.BNGetBasicBlockImmediateDominator(self.handle, False)
 		if not result:
 			return None
 		return self._create_instance(result)
 
 	@property
 	def immediate_post_dominator(self) -> Optional['BasicBlock']:
-		"""Immediate dominator of this basic block (read-only)"""
+		"""
+		Immediate post-dominator of this basic block (read-only)
+
+		The immediate post-dominator of a basic block B is the post-dominator closest to B in the control flow graph.
+		In other words, among all post-dominators of B, it is the post-dominator that doesn't post-dominate any other
+		post-dominator of B except itself.
+		If B has outgoing edges that can lead to different exit blocks, then this will not exist.
+		"""
 		result = core.BNGetBasicBlockImmediateDominator(self.handle, True)
 		if not result:
 			return None
 		return self._create_instance(result)
 
 	@property
 	def dominator_tree_children(self) -> List['BasicBlock']:
-		"""List of child blocks in the dominator tree for this basic block (read-only)"""
+		"""
+		List of child blocks in the dominator tree for this basic block (read-only)
+
+		The dominator tree children of a basic block B are the blocks dominated by B.
+		See :py:func:`BasicBlock.dominators` for the definition of a dominator.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominatorTreeChildren(self.handle, count, False)
 		return self._make_blocks(blocks, count.value)
 
 	@property
 	def post_dominator_tree_children(self) -> List['BasicBlock']:
-		"""List of child blocks in the post dominator tree for this basic block (read-only)"""
+		"""
+		List of child blocks in the post-dominator tree for this basic block (read-only)
+
+		The post-dominator tree children of a basic block B are the blocks post-dominated by B.
+		See :py:func:`BasicBlock.post_dominators` for the definition of a post-dominator.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominatorTreeChildren(self.handle, count, True)
 		return self._make_blocks(blocks, count.value)
 
 	@property
 	def dominance_frontier(self) -> List['BasicBlock']:
-		"""Dominance frontier for this basic block (read-only)"""
+		"""
+		Dominance frontier for this basic block (read-only)
+
+		The dominance frontier of a basic block B is the set of blocks that are not strictly dominated by B,
+		but are immediately control-dependent on B. In other words, it contains the blocks where B's dominance 
+		"stops" - the blocks that have at least one predecessor not dominated by B, while having another 
+		predecessor that is dominated by B.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominanceFrontier(self.handle, count, False)
 		return self._make_blocks(blocks, count.value)
 
 	@property
 	def post_dominance_frontier(self) -> List['BasicBlock']:
-		"""Post dominance frontier for this basic block (read-only)"""
+		"""
+		Post-dominance frontier for this basic block (read-only)
+
+		The post-dominance frontier of a basic block B is the set of blocks that are not strictly post-dominated
+		by B, but have at least one successor that is post-dominated by B. In other words, it contains the blocks
+		where B's post-dominance "stops" - the blocks that have at least one successor not post-dominated by B,
+		while having another successor that is post-dominated by B.
+		"""
 		count = ctypes.c_ulonglong()
 		blocks = core.BNGetBasicBlockDominanceFrontier(self.handle, count, True)
 		return self._make_blocks(blocks, count.value)