Registering default function lifter with core

Start of migrating FunctionLifter::Lift to API. The default
implementation can be overriden by architecture plugins to lift entire
functions in a single call to Architecture::LiftFunction.

Author: zznop

architecture.cpp

@@ -466,6 +466,29 @@ void BasicBlockAnalysisContext::Finalize()
 }
 
 
+FunctionLifterContext::FunctionLifterContext(BNFunctionLifterContext* context)
+{
+	m_context = context;
+	m_blocks.reserve(m_context->basicBlockCount);
+	for (size_t i = 0; i < m_context->basicBlockCount; i++)
+	{
+		m_blocks.emplace_back(new BasicBlock(m_context->basicBlocks[i]));
+	}
+}
+
+
+void FunctionLifterContext::Finalize()
+{
+	// TODO
+}
+
+
+vector<Ref<BasicBlock>> FunctionLifterContext::GetBasicBlocks()
+{
+	return m_blocks;
+}
+
+
 Architecture::Architecture(BNArchitecture* arch)
 {
 	m_object = arch;
@@ -600,6 +623,15 @@ void Architecture::AnalyzeBasicBlocksCallback(void *ctxt, BNFunction* function,
 }
 
 
+bool Architecture::LiftFunctionCallback(void *ctxt, BNLowLevelILFunction* function, BNFunctionLifterContext* context)
+{
+	CallbackRef<Architecture> arch(ctxt);
+	FunctionLifterContext flc(context);
+	Ref func(new LowLevelILFunction(BNNewLowLevelILFunctionReference(function)));
+	return arch->LiftFunction(func, flc);
+}
+
+
 char* Architecture::GetRegisterNameCallback(void* ctxt, uint32_t reg)
 {
 	CallbackRef<Architecture> arch(ctxt);
@@ -1091,6 +1123,7 @@ void Architecture::Register(Architecture* arch)
 	callbacks.freeInstructionText = FreeInstructionTextCallback;
 	callbacks.getInstructionLowLevelIL = GetInstructionLowLevelILCallback;
 	callbacks.analyzeBasicBlocks = AnalyzeBasicBlocksCallback;
+	callbacks.liftFunction = LiftFunctionCallback;
 	callbacks.getRegisterName = GetRegisterNameCallback;
 	callbacks.getFlagName = GetFlagNameCallback;
 	callbacks.getFlagWriteTypeName = GetFlagWriteTypeNameCallback;
@@ -1225,6 +1258,12 @@ void Architecture::AnalyzeBasicBlocks(Function* function, BasicBlockAnalysisCont
 }
 
 
+bool Architecture::LiftFunction(LowLevelILFunction* function, FunctionLifterContext& context)
+{
+	return DefaultLiftFunction(function, context);
+}
+
+
 string Architecture::GetRegisterName(uint32_t reg)
 {
 	return fmt::format("r{}", reg);
@@ -1792,6 +1831,12 @@ void CoreArchitecture::AnalyzeBasicBlocks(Function* function, BasicBlockAnalysis
 }
 
 
+bool CoreArchitecture::LiftFunction(LowLevelILFunction* function, FunctionLifterContext& context)
+{
+	return BNArchitectureLiftFunction(m_object, function->GetObject(), context.m_context);
+}
+
+
 string CoreArchitecture::GetRegisterName(uint32_t reg)
 {
 	char* name = BNGetArchitectureRegisterName(m_object, reg);

binaryninjaapi.h

@@ -9387,6 +9387,17 @@ namespace BinaryNinja {
 		void Finalize();
 	};
 
+	class FunctionLifterContext {
+	private:
+		std::vector<Ref<BasicBlock>> m_blocks;
+
+	public:
+		BNFunctionLifterContext* m_context;
+		FunctionLifterContext(BNFunctionLifterContext* context);
+		std::vector<Ref<BasicBlock>> GetBasicBlocks();
+		void Finalize();
+	};
+
 	/*! The Architecture class is the base class for all CPU architectures. This provides disassembly, assembly,
 	    patching, and IL translation lifting for a given architecture.
 
@@ -9415,6 +9426,7 @@ namespace BinaryNinja {
 		static bool GetInstructionLowLevelILCallback(
 		    void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il);
 		static void AnalyzeBasicBlocksCallback(void *ctxt, BNFunction* function, BNBasicBlockAnalysisContext* context);
+		static bool LiftFunctionCallback(void* ctxt, BNLowLevelILFunction* function, BNFunctionLifterContext* context);
 		static char* GetRegisterNameCallback(void* ctxt, uint32_t reg);
 		static char* GetFlagNameCallback(void* ctxt, uint32_t flag);
 		static char* GetFlagWriteTypeNameCallback(void* ctxt, uint32_t flags);
@@ -9496,6 +9508,16 @@ namespace BinaryNinja {
 		*/
 		static void DefaultAnalyzeBasicBlocks(Function* function, BasicBlockAnalysisContext& context);
 
+		static bool DefaultLiftFunctionCallback(BNLowLevelILFunction* function, BNFunctionLifterContext* context);
+
+		/*! Default implementation of LiftFunction
+
+			\param function Function to analyze
+			\param context Context for the analysis
+			\return Whether lifting was successful
+		*/
+		static bool DefaultLiftFunction(LowLevelILFunction* function, FunctionLifterContext& context);
+
 		/*! Get an Architecture by name
 
 			\param name Name of the architecture
@@ -9600,6 +9622,14 @@ namespace BinaryNinja {
 		*/
 		virtual void AnalyzeBasicBlocks(Function* function, BasicBlockAnalysisContext& context);
 
+		/*! Lift function instructions to IL
+
+			\param function Function to analyze
+			\param context Context for the analysis
+			\return Whether lifting was successful
+		*/
+		virtual bool LiftFunction(LowLevelILFunction* function, FunctionLifterContext& context);
+
 		/*! Gets a register name from a register index.
 
 			\param reg Register index
@@ -9994,6 +10024,7 @@ namespace BinaryNinja {
 		virtual bool GetInstructionLowLevelIL(
 		    const uint8_t* data, uint64_t addr, size_t& len, LowLevelILFunction& il) override;
 		virtual void AnalyzeBasicBlocks(Function* function, BasicBlockAnalysisContext& context) override;
+		virtual bool LiftFunction(LowLevelILFunction* function, FunctionLifterContext& context) override;
 		virtual std::string GetRegisterName(uint32_t reg) override;
 		virtual std::string GetFlagName(uint32_t flag) override;
 		virtual std::string GetFlagWriteTypeName(uint32_t flags) override;

binaryninjacore.h

@@ -2024,6 +2024,29 @@ extern "C"
 		BNArchitectureAndAddress* inlinedUnresolvedIndirectBranches;
 	} BNBasicBlockAnalysisContext;
 
+	typedef struct BNFunctionLifterContext {
+		// IN
+		size_t basicBlockCount;
+		BNBasicBlock** basicBlocks;
+
+		// TODO: inlinedRemapping
+
+		size_t indirectBranchesCount;
+		BNIndirectBranchInfo* indirectBranches;
+
+		size_t noReturnCallsCount;
+		BNArchitectureAndAddress* noReturnCalls;
+
+		size_t contextualFunctionReturnCount;
+		BNArchitectureAndAddress* contextualFunctionReturnLocations;
+		bool* contextualFunctionReturnValues;
+
+		// OUT
+		size_t indirectSourceCount;
+		BNArchitectureAndAddress* indirectSourcesFrom;
+		BNArchitectureAndAddress* indirectSourcesTo;
+	} BNFunctionLifterContext;
+
 	typedef struct BNCustomArchitecture
 	{
 		void* context;
@@ -2043,6 +2066,7 @@ extern "C"
 		bool (*getInstructionLowLevelIL)(
 		    void* ctxt, const uint8_t* data, uint64_t addr, size_t* len, BNLowLevelILFunction* il);
 		void (*analyzeBasicBlocks)(void* ctxt, BNFunction* function, BNBasicBlockAnalysisContext* context);
+		bool (*liftFunction)(void *ctext, BNLowLevelILFunction* function, BNFunctionLifterContext* context);
 		char* (*getRegisterName)(void* ctxt, uint32_t reg);
 		char* (*getFlagName)(void* ctxt, uint32_t flag);
 		char* (*getFlagWriteTypeName)(void* ctxt, uint32_t flags);
@@ -4878,6 +4902,10 @@ extern "C"
 	BINARYNINJACOREAPI void BNArchitectureDefaultAnalyzeBasicBlocks(BNFunction* function, BNBasicBlockAnalysisContext* context);
 	BINARYNINJACOREAPI void BNArchitectureAnalyzeBasicBlocks(BNArchitecture* arch, BNFunction* function,
 		BNBasicBlockAnalysisContext* context);
+	BINARYNINJACOREAPI bool BNArchitectureSetDefaultLiftFunctionCallback(void *callback);
+	BINARYNINJACOREAPI bool BNArchitectureDefaultLiftFunction(BNLowLevelILFunction* function, BNFunctionLifterContext* context);
+	BINARYNINJACOREAPI bool BNArchitectureLiftFunction(BNArchitecture* arch, BNLowLevelILFunction* function,
+		BNFunctionLifterContext* context);
 	BINARYNINJACOREAPI void BNFreeInstructionTextLines(BNInstructionTextLine* lines, size_t count);
 	BINARYNINJACOREAPI char* BNGetArchitectureRegisterName(BNArchitecture* arch, uint32_t reg);
 	BINARYNINJACOREAPI char* BNGetArchitectureFlagName(BNArchitecture* arch, uint32_t flag);