Merge branch 'thumb' into dev

4 files changed, 63 insertions, 0 deletions

diff --git a/architecture.cpp b/architecture.cpp
index af7b0cba..3c7d9af8 100644
--- a/architecture.cpp
+++ b/architecture.cpp
@@ -111,6 +111,13 @@ size_t Architecture::GetOpcodeDisplayLengthCallback(void* ctxt)
 }
 
 
+BNArchitecture* Architecture::GetAssociatedArchitectureByAddressCallback(void* ctxt, uint64_t* addr)
+{
+	Architecture* arch = (Architecture*)ctxt;
+	return arch->GetAssociatedArchitectureByAddress(*addr)->GetObject();
+}
+
+
 bool Architecture::GetInstructionInfoCallback(void* ctxt, const uint8_t* data, uint64_t addr,
                                               size_t maxLen, BNInstructionInfo* result)
 {
@@ -408,6 +415,7 @@ void Architecture::Register(Architecture* arch)
 	callbacks.getDefaultIntegerSize = GetDefaultIntegerSizeCallback;
 	callbacks.getMaxInstructionLength = GetMaxInstructionLengthCallback;
 	callbacks.getOpcodeDisplayLength = GetOpcodeDisplayLengthCallback;
+	callbacks.getAssociatedArchitectureByAddress = GetAssociatedArchitectureByAddressCallback;
 	callbacks.getInstructionInfo = GetInstructionInfoCallback;
 	callbacks.getInstructionText = GetInstructionTextCallback;
 	callbacks.freeInstructionText = FreeInstructionTextCallback;
@@ -499,6 +507,12 @@ size_t Architecture::GetOpcodeDisplayLength() const
 }
 
 
+Ref<Architecture> Architecture::GetAssociatedArchitectureByAddress(uint64_t&)
+{
+	return this;
+}
+
+
 bool Architecture::GetInstructionLowLevelIL(const uint8_t*, uint64_t, size_t&, LowLevelILFunction& il)
 {
 	il.AddInstruction(il.Undefined());
@@ -919,6 +933,12 @@ size_t CoreArchitecture::GetOpcodeDisplayLength() const
 }
 
 
+Ref<Architecture> CoreArchitecture::GetAssociatedArchitectureByAddress(uint64_t& addr)
+{
+	return new CoreArchitecture(BNGetAssociatedArchitectureByAddress(m_object, &addr));
+}
+
+
 bool CoreArchitecture::GetInstructionInfo(const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result)
 {
 	return BNGetInstructionInfo(m_object, data, addr, maxLen, &result);
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index 7c297f73..6311271c 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -1257,6 +1257,7 @@ namespace BinaryNinja
 		static size_t GetDefaultIntegerSizeCallback(void* ctxt);
 		static size_t GetMaxInstructionLengthCallback(void* ctxt);
 		static size_t GetOpcodeDisplayLengthCallback(void* ctxt);
+		static BNArchitecture* GetAssociatedArchitectureByAddressCallback(void* ctxt, uint64_t* addr);
 		static bool GetInstructionInfoCallback(void* ctxt, const uint8_t* data, uint64_t addr,
 		                                       size_t maxLen, BNInstructionInfo* result);
 		static bool GetInstructionTextCallback(void* ctxt, const uint8_t* data, uint64_t addr,
@@ -1311,6 +1312,8 @@ namespace BinaryNinja
 		virtual size_t GetMaxInstructionLength() const;
 		virtual size_t GetOpcodeDisplayLength() const;
 
+		virtual Ref<Architecture> GetAssociatedArchitectureByAddress(uint64_t& addr);
+
 		virtual bool GetInstructionInfo(const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result) = 0;
 		virtual bool GetInstructionText(const uint8_t* data, uint64_t addr, size_t& len,
 		                                std::vector<InstructionTextToken>& result) = 0;
@@ -1454,6 +1457,7 @@ namespace BinaryNinja
 		virtual size_t GetDefaultIntegerSize() const override;
 		virtual size_t GetMaxInstructionLength() const override;
 		virtual size_t GetOpcodeDisplayLength() const override;
+		virtual Ref<Architecture> GetAssociatedArchitectureByAddress(uint64_t& addr) override;
 		virtual bool GetInstructionInfo(const uint8_t* data, uint64_t addr, size_t maxLen, InstructionInfo& result) override;
 		virtual bool GetInstructionText(const uint8_t* data, uint64_t addr, size_t& len,
 		                                std::vector<InstructionTextToken>& result) override;
diff --git a/binaryninjacore.h b/binaryninjacore.h
index ac615922..ea81c388 100644
--- a/binaryninjacore.h
+++ b/binaryninjacore.h
@@ -725,6 +725,7 @@ extern "C"
 		size_t (*getDefaultIntegerSize)(void* ctxt);
 		size_t (*getMaxInstructionLength)(void* ctxt);
 		size_t (*getOpcodeDisplayLength)(void* ctxt);
+		BNArchitecture* (*getAssociatedArchitectureByAddress)(void* ctxt, uint64_t* addr);
 		bool (*getInstructionInfo)(void* ctxt, const uint8_t* data, uint64_t addr, size_t maxLen, BNInstructionInfo* result);
 		bool (*getInstructionText)(void* ctxt, const uint8_t* data, uint64_t addr, size_t* len,
 		                           BNInstructionTextToken** result, size_t* count);
@@ -1516,6 +1517,7 @@ extern "C"
 	BINARYNINJACOREAPI size_t BNGetArchitectureDefaultIntegerSize(BNArchitecture* arch);
 	BINARYNINJACOREAPI size_t BNGetArchitectureMaxInstructionLength(BNArchitecture* arch);
 	BINARYNINJACOREAPI size_t BNGetArchitectureOpcodeDisplayLength(BNArchitecture* arch);
+	BINARYNINJACOREAPI BNArchitecture* BNGetAssociatedArchitectureByAddress(BNArchitecture* arch, uint64_t* addr);
 	BINARYNINJACOREAPI bool BNGetInstructionInfo(BNArchitecture* arch, const uint8_t* data, uint64_t addr,
 	                                             size_t maxLen, BNInstructionInfo* result);
 	BINARYNINJACOREAPI bool BNGetInstructionText(BNArchitecture* arch, const uint8_t* data, uint64_t addr,
diff --git a/python/__init__.py b/python/__init__.py
index 0ba0f1a5..6c7e298c 100644
--- a/python/__init__.py
+++ b/python/__init__.py
@@ -4789,6 +4789,14 @@ class Function(object):
 		return Architecture(arch)
 
 	@property
+	def platform(self):
+		"""Function platform (read-only)"""
+		platform = core.BNGetFunctionPlatform(self.handle)
+		if platform is None:
+			return None
+		return Platform(None, handle = platform)
+
+	@property
 	def start(self):
 		"""Function start (read-only)"""
 		return core.BNGetFunctionStart(self.handle)
@@ -6011,6 +6019,8 @@ class Architecture(object):
 			self._cb.getDefaultIntegerSize = self._cb.getDefaultIntegerSize.__class__(self._get_default_integer_size)
 			self._cb.getMaxInstructionLength = self._cb.getMaxInstructionLength.__class__(self._get_max_instruction_length)
 			self._cb.getOpcodeDisplayLength = self._cb.getOpcodeDisplayLength.__class__(self._get_opcode_display_length)
+			self._cb.getAssociatedArchitectureByAddress = self._cb.getAssociatedArchitectureByAddress.__class__(
+				self._get_associated_arch_by_address)
 			self._cb.getInstructionInfo = self._cb.getInstructionInfo.__class__(self._get_instruction_info)
 			self._cb.getInstructionText = self._cb.getInstructionText.__class__(self._get_instruction_text)
 			self._cb.freeInstructionText = self._cb.freeInstructionText.__class__(self._free_instruction_text)
@@ -6200,6 +6210,15 @@ class Architecture(object):
 			log_error(traceback.format_exc())
 			return 8
 
+	def _get_associated_arch_by_address(self, ctxt, addr):
+		try:
+			result, new_addr = self.perform_get_associated_arch_by_address(addr[0])
+			addr[0] = new_addr
+			return ctypes.cast(result.handle, ctypes.c_void_p).value
+		except:
+			log_error(traceback.format_exc())
+			return ctypes.cast(self.handle, ctypes.c_void_p).value
+
 	def _get_instruction_info(self, ctxt, data, addr, max_len, result):
 		try:
 			buf = ctypes.create_string_buffer(max_len)
@@ -6609,6 +6628,9 @@ class Architecture(object):
 			log_error(traceback.format_exc())
 			return False
 
+	def perform_get_associated_arch_by_address(self, addr):
+		return self, addr
+
 	@abc.abstractmethod
 	def perform_get_instruction_info(self, data, addr):
 		"""
@@ -6859,6 +6881,12 @@ class Architecture(object):
 		"""
 		return None
 
+	def get_associated_arch_by_address(self, addr):
+		new_addr = ctypes.c_ulonglong()
+		new_addr.value = addr
+		result = core.BNGetAssociatedArchitectureByAddress(self.handle, new_addr)
+		return Architecture(handle = result), new_addr.value
+
 	def get_instruction_info(self, data, addr):
 		"""
 		``get_instruction_info`` returns an InstructionInfo object for the instruction at the given virtual address
@@ -9693,6 +9721,15 @@ class Platform(object):
 		"""
 		core.BNRegisterPlatformCallingConvention(self.handle, cc.handle)
 
+	def get_related_platform(self, arch):
+		result = core.BNGetRelatedPlatform(self.handle, arch.handle)
+		if not result:
+			return None
+		return Platform(None, handle = result)
+
+	def add_related_platform(self, arch, platform):
+		core.BNAddRelatedPlatform(self.handle, arch.handle, platform.handle)
+
 class ScriptingOutputListener(object):
 	def _register(self, handle):
 		self._cb = core.BNScriptingOutputListener()