diff options
| -rw-r--r-- | binaryninjaapi.h | 3 | ||||
| -rw-r--r-- | binaryninjacore.h | 2 | ||||
| -rw-r--r-- | callingconvention.cpp | 20 | ||||
| -rw-r--r-- | python/callingconvention.py | 10 |
4 files changed, 35 insertions, 0 deletions
diff --git a/binaryninjaapi.h b/binaryninjaapi.h index 337a226f..d0a3bbff 100644 --- a/binaryninjaapi.h +++ b/binaryninjaapi.h @@ -4639,6 +4639,7 @@ __attribute__ ((format (printf, 1, 2))) static bool AreArgumentRegistersSharedIndexCallback(void* ctxt); static bool IsStackReservedForArgumentRegistersCallback(void* ctxt); static bool IsStackAdjustedOnReturnCallback(void* ctxt); + static bool IsEligibleForHeuristicsCallback(void* ctxt); static uint32_t GetIntegerReturnValueRegisterCallback(void* ctxt); static uint32_t GetHighIntegerReturnValueRegisterCallback(void* ctxt); @@ -4666,6 +4667,7 @@ __attribute__ ((format (printf, 1, 2))) virtual bool AreArgumentRegistersSharedIndex(); virtual bool IsStackReservedForArgumentRegisters(); virtual bool IsStackAdjustedOnReturn(); + virtual bool IsEligibleForHeuristics(); virtual uint32_t GetIntegerReturnValueRegister() = 0; virtual uint32_t GetHighIntegerReturnValueRegister(); @@ -4693,6 +4695,7 @@ __attribute__ ((format (printf, 1, 2))) virtual bool AreArgumentRegistersSharedIndex() override; virtual bool IsStackReservedForArgumentRegisters() override; virtual bool IsStackAdjustedOnReturn() override; + virtual bool IsEligibleForHeuristics() override; virtual uint32_t GetIntegerReturnValueRegister() override; virtual uint32_t GetHighIntegerReturnValueRegister() override; diff --git a/binaryninjacore.h b/binaryninjacore.h index 30b4d18b..32f1c5b8 100644 --- a/binaryninjacore.h +++ b/binaryninjacore.h @@ -1948,6 +1948,7 @@ extern "C" bool (*areArgumentRegistersSharedIndex)(void* ctxt); bool (*isStackReservedForArgumentRegisters)(void* ctxt); bool (*isStackAdjustedOnReturn)(void* ctxt); + bool (*isEligibleForHeuristics)(void* ctxt); uint32_t (*getIntegerReturnValueRegister)(void* ctxt); uint32_t (*getHighIntegerReturnValueRegister)(void* ctxt); @@ -4428,6 +4429,7 @@ __attribute__ ((format (printf, 1, 2))) BINARYNINJACOREAPI bool BNAreArgumentRegistersSharedIndex(BNCallingConvention* cc); BINARYNINJACOREAPI bool BNIsStackReservedForArgumentRegisters(BNCallingConvention* cc); BINARYNINJACOREAPI bool BNIsStackAdjustedOnReturn(BNCallingConvention* cc); + BINARYNINJACOREAPI bool BNIsEligibleForHeuristics(BNCallingConvention* cc); BINARYNINJACOREAPI uint32_t BNGetIntegerReturnValueRegister(BNCallingConvention* cc); BINARYNINJACOREAPI uint32_t BNGetHighIntegerReturnValueRegister(BNCallingConvention* cc); diff --git a/callingconvention.cpp b/callingconvention.cpp index 4693b988..b6354381 100644 --- a/callingconvention.cpp +++ b/callingconvention.cpp @@ -43,6 +43,7 @@ CallingConvention::CallingConvention(Architecture* arch, const string& name) cc.areArgumentRegistersSharedIndex = AreArgumentRegistersSharedIndexCallback; cc.isStackReservedForArgumentRegisters = IsStackReservedForArgumentRegistersCallback; cc.isStackAdjustedOnReturn = IsStackAdjustedOnReturnCallback; + cc.isEligibleForHeuristics = IsEligibleForHeuristicsCallback; cc.getIntegerReturnValueRegister = GetIntegerReturnValueRegisterCallback; cc.getHighIntegerReturnValueRegister = GetHighIntegerReturnValueRegisterCallback; cc.getFloatReturnValueRegister = GetFloatReturnValueRegisterCallback; @@ -144,6 +145,13 @@ bool CallingConvention::IsStackAdjustedOnReturnCallback(void* ctxt) } +bool CallingConvention::IsEligibleForHeuristicsCallback(void* ctxt) +{ + CallingConvention* cc = (CallingConvention*)ctxt; + return cc->IsEligibleForHeuristics(); +} + + uint32_t CallingConvention::GetIntegerReturnValueRegisterCallback(void* ctxt) { CallingConvention* cc = (CallingConvention*)ctxt; @@ -284,6 +292,12 @@ bool CallingConvention::IsStackAdjustedOnReturn() } +bool CallingConvention::IsEligibleForHeuristics() +{ + return true; +} + + uint32_t CallingConvention::GetHighIntegerReturnValueRegister() { return BN_INVALID_REGISTER; @@ -407,6 +421,12 @@ bool CoreCallingConvention::IsStackAdjustedOnReturn() } +bool CoreCallingConvention::IsEligibleForHeuristics() +{ + return BNIsEligibleForHeuristics(m_object); +} + + uint32_t CoreCallingConvention::GetIntegerReturnValueRegister() { return BNGetIntegerReturnValueRegister(m_object); diff --git a/python/callingconvention.py b/python/callingconvention.py index 5e4c0dac..aaf86239 100644 --- a/python/callingconvention.py +++ b/python/callingconvention.py @@ -40,6 +40,7 @@ class CallingConvention(object): arg_regs_share_index = False stack_reserved_for_arg_regs = False stack_adjusted_on_return = False + eligible_for_heuristics = True int_return_reg = None high_int_return_reg = None float_return_reg = None @@ -65,6 +66,7 @@ class CallingConvention(object): self._cb.areArgumentRegistersSharedIndex = self._cb.areArgumentRegistersSharedIndex.__class__(self._arg_regs_share_index) self._cb.isStackReservedForArgumentRegisters = self._cb.isStackReservedForArgumentRegisters.__class__(self._stack_reserved_for_arg_regs) self._cb.isStackAdjustedOnReturn = self._cb.isStackAdjustedOnReturn.__class__(self._stack_adjusted_on_return) + self._cb.isEligibleForHeuristics = self._cb.isEligibleForHeuristics.__class__(self._eligible_for_heuristics) self._cb.getIntegerReturnValueRegister = self._cb.getIntegerReturnValueRegister.__class__(self._get_int_return_reg) self._cb.getHighIntegerReturnValueRegister = self._cb.getHighIntegerReturnValueRegister.__class__(self._get_high_int_return_reg) self._cb.getFloatReturnValueRegister = self._cb.getFloatReturnValueRegister.__class__(self._get_float_return_reg) @@ -83,6 +85,7 @@ class CallingConvention(object): self.__dict__["arg_regs_share_index"] = core.BNAreArgumentRegistersSharedIndex(self.handle) self.__dict__["stack_reserved_for_arg_regs"] = core.BNIsStackReservedForArgumentRegisters(self.handle) self.__dict__["stack_adjusted_on_return"] = core.BNIsStackAdjustedOnReturn(self.handle) + self.__dict__["eligible_for_heuristics"] = core.BNIsEligibleForHeuristics(self.handle) count = ctypes.c_ulonglong() regs = core.BNGetCallerSavedRegisters(self.handle, count) @@ -268,6 +271,13 @@ class CallingConvention(object): log.log_error(traceback.format_exc()) return False + def _eligible_for_heuristics(self, ctxt): + try: + return self.__class__.eligible_for_heuristics + except: + log.log_error(traceback.format_exc()) + return False + def _get_int_return_reg(self, ctxt): try: return self.arch.regs[self.__class__.int_return_reg].index |