Refactor calling conventions to support correct representation of structures

1 files changed, 858 insertions, 110 deletions

diff --git a/python/callingconvention.py b/python/callingconvention.py
index 94aeb699..4f17d1cf 100644
--- a/python/callingconvention.py
+++ b/python/callingconvention.py
@@ -20,7 +20,8 @@
 
 import traceback
 import ctypes
-from typing import Optional, Union
+from typing import Optional, Union, List, Dict, Tuple
+from dataclasses import dataclass
 
 # Binary Ninja components
 from . import _binaryninjacore as core
@@ -28,12 +29,62 @@ from .log import log_error_for_exception
 from . import variable
 from . import function
 from . import architecture
+from . import types
+from . import binaryview
 
 FunctionOrILFunction = Union["binaryninja.function.Function", "binaryninja.lowlevelil.LowLevelILFunction",
                              "binaryninja.mediumlevelil.MediumLevelILFunction",
                              "binaryninja.highlevelil.HighLevelILFunction"]
 
 
+@dataclass
+class CallLayout:
+	parameters: List['types.ValueLocation']
+	return_value: Optional['types.ValueLocation']
+	stack_adjustment: int
+	reg_stack_adjustments: Dict['architecture.RegisterIndex', int]
+
+	@staticmethod
+	def _from_core_struct(struct: core.BNCallLayout, func: Optional['function.Function'] = None) -> 'CallLayout':
+		params = []
+		if func is None:
+			arch = None
+		else:
+			arch = func.arch
+		for i in range(struct.parameterCount):
+			params.append(types.ValueLocation._from_core_struct(struct.parameters[i], arch))
+		if struct.returnValueValid:
+			return_value = types.ValueLocation._from_core_struct(struct.returnValue, arch)
+		else:
+			return_value = None
+		stack_adjust = struct.stackAdjustment
+		reg_stack_adjust = dict()
+		for i in range(struct.registerStackAdjustmentCount):
+			reg = architecture.RegisterIndex(struct.registerStackAdjustmentRegisters[i])
+			reg_stack_adjust[reg] = struct.registerStackAdjustmentAmounts[i]
+		return CallLayout(params, return_value, stack_adjust, reg_stack_adjust)
+
+	def _to_core_struct(self):
+		struct = core.BNCallLayout()
+		struct.parameters = (core.BNValueLocation * len(self.parameters))()
+		struct.parameterCount = len(self.parameters)
+		for i in range(len(self.parameters)):
+			struct.parameters[i] = self.parameters[i]._to_core_struct()
+		if self.return_value is None:
+			struct.returnValueValid = False
+		else:
+			struct.returnValue = self.return_value._to_core_struct()
+			struct.returnValueValid = True
+		struct.stackAdjustment = self.stack_adjustment
+		struct.registerStackAdjustmentRegisters = (ctypes.c_uint * len(self.reg_stack_adjustments))()
+		struct.registerStackAdjustmentAmounts = (ctypes.c_int * len(self.reg_stack_adjustments))()
+		struct.registerStackAdjustmentCount = len(self.reg_stack_adjustments)
+		for i, (reg, amount) in enumerate(self.reg_stack_adjustments.items()):
+			struct.registerStackAdjustmentRegisters[i] = reg
+			struct.registerStackAdjustmentAmounts[i] = amount
+		return struct
+
+
 class CallingConvention:
 	name = None
 	caller_saved_regs = []
@@ -52,8 +103,13 @@ class CallingConvention:
 	float_return_reg = None
 	global_pointer_reg = None
 	implicitly_defined_regs = []
+	stack_args_naturally_aligned = False
 
 	_registered_calling_conventions = []
+	_pending_value_locations = {}
+	_pending_value_location_lists = {}
+	_pending_reg_stack_adjustment_reg_lists = {}
+	_pending_reg_stack_adjustment_amount_lists = {}
 
 	def __init__(
 	    self, arch: Optional['architecture.Architecture'] = None, name: Optional[str] = None, handle=None,
@@ -117,111 +173,43 @@ class CallingConvention:
 			self._cb.getParameterVariableForIncomingVariable = self._cb.getParameterVariableForIncomingVariable.__class__(
 			    self._get_parameter_var_for_incoming_var
 			)
+			self._cb.isReturnTypeRegisterCompatible = self._cb.isReturnTypeRegisterCompatible.__class__(
+				self._is_return_type_reg_compatible
+			)
+			self._cb.getIndirectReturnValueLocation = self._cb.getIndirectReturnValueLocation.__class__(
+				self._get_indirect_return_value_location
+			)
+			self._cb.getReturnedIndirectReturnValuePointer = self._cb.getReturnedIndirectReturnValuePointer.__class__(
+				self._get_returned_indirect_return_value_pointer
+			)
+			self._cb.isArgumentTypeRegisterCompatible = self._cb.isArgumentTypeRegisterCompatible.__class__(
+				self._is_arg_type_reg_compatible
+			)
+			self._cb.isNonRegisterArgumentIndirect = self._cb.isNonRegisterArgumentIndirect.__class__(
+				self._is_non_reg_arg_indirect
+			)
+			self._cb.areStackArgumentsNaturallyAligned = self._cb.areStackArgumentsNaturallyAligned.__class__(
+				self._are_stack_args_naturally_aligned
+			)
+			self._cb.getCallLayout = self._cb.getCallLayout.__class__(self._get_call_layout)
+			self._cb.freeCallLayout = self._cb.freeCallLayout.__class__(self._free_call_layout)
+			self._cb.getReturnValueLocation = self._cb.getReturnValueLocation.__class__(self._get_return_value_location)
+			self._cb.freeValueLocation = self._cb.freeValueLocation.__class__(self._free_value_location)
+			self._cb.getParameterLocations = self._cb.getParameterLocations.__class__(self._get_parameter_locations)
+			self._cb.freeParameterLocations = self._cb.freeParameterLocations.__class__(self._free_parameter_locations)
+			self._cb.getStackAdjustmentForLocations = self._cb.getStackAdjustmentForLocations.__class__(
+				self._get_stack_adjustment_for_locations
+			)
+			self._cb.getRegisterStackAdjustments = self._cb.getRegisterStackAdjustments.__class__(
+				self._get_register_stack_adjustments
+			)
+			self._cb.freeRegisterStackAdjustments = self._cb.freeRegisterStackAdjustments.__class__(
+				self._free_register_stack_adjustments
+			)
 			_handle = core.BNCreateCallingConvention(arch.handle, name, self._cb)
 			self.__class__._registered_calling_conventions.append(self)
 		else:
 			_handle = handle
-			self.arch = architecture.CoreArchitecture._from_cache(core.BNGetCallingConventionArchitecture(_handle))
-			self.__dict__["name"] = core.BNGetCallingConventionName(_handle)
-			self.__dict__["arg_regs_share_index"] = core.BNAreArgumentRegistersSharedIndex(_handle)
-			self.__dict__["arg_regs_for_varargs"] = core.BNAreArgumentRegistersUsedForVarArgs(_handle)
-			self.__dict__["stack_reserved_for_arg_regs"] = core.BNIsStackReservedForArgumentRegisters(_handle)
-			self.__dict__["stack_adjusted_on_return"] = core.BNIsStackAdjustedOnReturn(_handle)
-			self.__dict__["eligible_for_heuristics"] = core.BNIsEligibleForHeuristics(_handle)
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetCallerSavedRegisters(_handle, count)
-			assert regs is not None, "core.BNGetCallerSavedRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["caller_saved_regs"] = result
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetCalleeSavedRegisters(_handle, count)
-			assert regs is not None, "core.BNGetCalleeSavedRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["callee_saved_regs"] = result
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetIntegerArgumentRegisters(_handle, count)
-			assert regs is not None, "core.BNGetIntegerArgumentRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["int_arg_regs"] = result
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetFloatArgumentRegisters(_handle, count)
-			assert regs is not None, "core.BNGetFloatArgumentRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["float_arg_regs"] = result
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetRequiredArgumentRegisters(handle, count)
-			assert regs is not None, "core.BNGetRequiredArgumentRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["required_arg_regs"] = result
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetRequiredClobberedRegisters(handle, count)
-			assert regs is not None, "core.BNGetRequiredClobberedRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["required_clobbered_regs"] = result
-
-			reg = core.BNGetIntegerReturnValueRegister(_handle)
-			if reg == 0xffffffff:
-				self.__dict__["int_return_reg"] = None
-			else:
-				self.__dict__["int_return_reg"] = self.arch.get_reg_name(reg)
-
-			reg = core.BNGetHighIntegerReturnValueRegister(_handle)
-			if reg == 0xffffffff:
-				self.__dict__["high_int_return_reg"] = None
-			else:
-				self.__dict__["high_int_return_reg"] = self.arch.get_reg_name(reg)
-
-			reg = core.BNGetFloatReturnValueRegister(_handle)
-			if reg == 0xffffffff:
-				self.__dict__["float_return_reg"] = None
-			else:
-				self.__dict__["float_return_reg"] = self.arch.get_reg_name(reg)
-
-			reg = core.BNGetGlobalPointerRegister(_handle)
-			if reg == 0xffffffff:
-				self.__dict__["global_pointer_reg"] = None
-			else:
-				self.__dict__["global_pointer_reg"] = self.arch.get_reg_name(reg)
-
-			count = ctypes.c_ulonglong()
-			regs = core.BNGetImplicitlyDefinedRegisters(_handle, count)
-			assert regs is not None, "core.BNGetImplicitlyDefinedRegisters returned None"
-			result = []
-			arch = self.arch
-			for i in range(0, count.value):
-				result.append(arch.get_reg_name(regs[i]))
-			core.BNFreeRegisterList(regs)
-			self.__dict__["implicitly_defined_regs"] = result
 		assert _handle is not None
 		self.handle = _handle
 		self.confidence = confidence
@@ -492,9 +480,309 @@ class CallingConvention:
 			result[0].index = in_var[0].index
 			result[0].storage = in_var[0].storage
 
+	def _is_return_type_reg_compatible(self, ctxt, view, type):
+		try:
+			if type:
+				if view:
+					view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+				else:
+					view_obj = None
+				type_obj = types.Type.create(handle=core.BNNewTypeReference(type))
+				return self.is_return_type_reg_compatible(view_obj, type_obj)
+			else:
+				return False
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._is_return_type_reg_compatible")
+			return False
+
+	def _get_indirect_return_value_location(self, ctxt, out_var):
+		try:
+			out_var[0] = self.get_indirect_return_value_location().to_BNVariable()
+		except:
+			log_error_for_exception(
+				"Unhandled Python exception in CallingConvention._get_indirect_return_value_location")
+
+	def _get_returned_indirect_return_value_pointer(self, ctxt, out_var):
+		try:
+			result = self.get_returned_indirect_return_value_pointer()
+			if result is None:
+				return False
+			out_var[0] = result.to_BNVariable()
+			return True
+		except:
+			log_error_for_exception(
+				"Unhandled Python exception in CallingConvention._get_returned_indirect_return_value_pointer")
+			return False
+
+	def _is_arg_type_reg_compatible(self, ctxt, view, type):
+		try:
+			if type:
+				if view:
+					view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+				else:
+					view_obj = None
+				type_obj = types.Type.create(handle=core.BNNewTypeReference(type))
+				return self.is_arg_type_reg_compatible(view_obj, type_obj)
+			else:
+				return False
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._is_arg_type_reg_compatible")
+			return False
+
+	def _is_non_reg_arg_indirect(self, ctxt, view, type):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			if type:
+				type_obj = types.Type.create(handle=core.BNNewTypeReference(type))
+				return self.is_non_reg_arg_indirect(view_obj, type_obj)
+			else:
+				return self.is_non_reg_arg_indirect(view_obj, None)
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._is_non_reg_arg_indirect")
+			return False
+
+	def _are_stack_args_naturally_aligned(self, ctxt):
+		try:
+			return self.__class__.stack_args_naturally_aligned
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._are_stack_args_naturally_aligned")
+			return False
+
+	def _get_call_layout(
+		self, ctxt, view, ret_value, params, param_count, has_permitted_regs, permitted_regs,
+		permitted_reg_count, out_layout
+	):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			if ret_value:
+				ret_value_obj = types.ReturnValue._from_core_struct(ret_value[0])
+			else:
+				ret_value_obj = None
+			param_objs = []
+			for i in range(param_count):
+				param_objs.append(types.FunctionParameter._from_core_struct(params[i]))
+			if has_permitted_regs:
+				reg_objs = []
+				for i in range(permitted_reg_count):
+					reg_objs.append(architecture.RegisterIndex(permitted_regs[i]))
+			else:
+				reg_objs = None
+			layout = self.get_call_layout(view_obj, ret_value_obj, param_objs, permitted_regs = reg_objs)
+
+			result = layout._to_core_struct()
+
+			param_ptr = ctypes.cast(result.parameters, ctypes.c_void_p)
+			self._pending_value_location_lists[param_ptr.value] = (param_ptr.value, result.parameters)
+
+			if result.returnValueValid:
+				ret_ptr = ctypes.cast(result.returnValue.components, ctypes.c_void_p)
+				self._pending_value_locations[ret_ptr.value] = (ret_ptr.value, result.returnValue)
+
+			reg_ptr = ctypes.cast(result.registerStackAdjustmentRegisters, ctypes.c_void_p)
+			self._pending_reg_stack_adjustment_reg_lists[reg_ptr.value] = (reg_ptr.value, result.registerStackAdjustmentRegisters)
+			amount_ptr = ctypes.cast(result.registerStackAdjustmentAmounts, ctypes.c_void_p)
+			self._pending_reg_stack_adjustment_amount_lists[amount_ptr.value] = (amount_ptr.value, result.registerStackAdjustmentAmounts)
+
+			out_layout[0] = result
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._get_call_layout")
+			result = core.BNCallLayout()
+			result.parameterCount = 0
+			result.returnValueValid = False
+			result.stackAdjustment = 0
+			result.registerStackAdjustmentCount = 0
+			out_layout[0] = result
+
+	def _free_call_layout(self, ctxt, layout_ptr):
+		try:
+			layout = layout_ptr[0]
+			param_ptr = ctypes.cast(layout.parameters, ctypes.c_void_p)
+			if param_ptr.value is not None:
+				if param_ptr.value not in self._pending_value_location_lists:
+					raise ValueError("freeing parameter location list that wasn't allocated")
+				del self._pending_value_location_lists[param_ptr.value]
+
+			if layout.returnValueValid:
+				ret_ptr = ctypes.cast(layout.returnValue.components, ctypes.c_void_p)
+				if ret_ptr.value is not None:
+					if ret_ptr.value not in self._pending_value_locations:
+						raise ValueError("freeing return value location that wasn't allocated")
+					del self._pending_value_locations[ret_ptr.value]
+
+			reg_ptr = ctypes.cast(layout.registerStackAdjustmentRegisters, ctypes.c_void_p)
+			if reg_ptr.value is not None:
+				if reg_ptr.value not in self._pending_reg_stack_adjustment_reg_lists:
+					raise ValueError("freeing register list that wasn't allocated")
+				del self._pending_reg_stack_adjustment_reg_lists[reg_ptr.value]
+
+			amount_ptr = ctypes.cast(layout.registerStackAdjustmentAmounts, ctypes.c_void_p)
+			if amount_ptr.value is not None:
+				if amount_ptr.value not in self._pending_reg_stack_adjustment_amount_lists:
+					raise ValueError("freeing adjustment list that wasn't allocated")
+				del self._pending_reg_stack_adjustment_amount_lists[amount_ptr.value]
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._free_call_layout")
+
+	def _get_return_value_location(self, ctxt, view, ret_value, out_location):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			ret = types.ReturnValue._from_core_struct(ret_value[0])
+			location = self.get_return_value_location(view_obj, ret)
+			if location is None:
+				location = types.ValueLocation([])
+			result = location._to_core_struct()
+			result_ptr = ctypes.cast(result.components, ctypes.c_void_p)
+			self._pending_value_locations[result_ptr.value] = (result_ptr.value, result)
+			out_location[0] = result
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._get_return_value_location")
+			result = core.BNValueLocation()
+			result.count = 0
+			result.components = None
+			out_location[0] = result
+
+	def _free_value_location(self, ctxt, location_ptr):
+		try:
+			location = location_ptr[0]
+			loc_ptr = ctypes.cast(location.components, ctypes.c_void_p)
+			if loc_ptr.value is not None:
+				if loc_ptr.value not in self._pending_value_locations:
+					raise ValueError("freeing value location that wasn't allocated")
+				del self._pending_value_locations[loc_ptr.value]
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._free_value_location")
+
+	def _get_parameter_locations(
+		self, ctxt, view, ret_value, params, param_count, has_permitted_regs, permitted_regs, permitted_reg_count,
+		out_location_count
+	):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			if ret_value:
+				ret_value_obj = types.ValueLocation._from_core_struct(ret_value[0])
+			else:
+				ret_value_obj = None
+			param_objs = []
+			for i in range(param_count):
+				param_objs.append(types.FunctionParameter._from_core_struct(params[i]))
+			if has_permitted_regs:
+				reg_objs = []
+				for i in range(permitted_reg_count):
+					reg_objs.append(architecture.RegisterIndex(permitted_regs[i]))
+			else:
+				reg_objs = None
+			locations = self.get_parameter_locations(view_obj, ret_value_obj, param_objs, permitted_regs = reg_objs)
+
+			out_location_count[0] = len(locations)
+			result = (core.BNValueLocation * len(locations))()
+			for i, location in enumerate(locations):
+				result[i] = location._to_core_struct()
+
+			result_ptr = ctypes.cast(result, ctypes.c_void_p)
+			self._pending_value_location_lists[result_ptr.value] = (result_ptr.value, result)
+
+			return result_ptr.value
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._get_parameter_locations")
+			out_location_count[0] = 0
+			return None
+
+	def _free_parameter_locations(self, ctxt, locations, count):
+		try:
+			location_ptr = ctypes.cast(locations, ctypes.c_void_p)
+			if location_ptr.value is not None:
+				if location_ptr.value not in self._pending_value_location_lists:
+					raise ValueError("freeing parameter location list that wasn't allocated")
+				del self._pending_value_location_lists[location_ptr.value]
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._free_parameter_locations")
+
+	def _get_stack_adjustment_for_locations(self, ctxt, view, ret_value, locations, type_list, param_count):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			if ret_value:
+				ret_value_obj = types.ValueLocation._from_core_struct(ret_value[0])
+			else:
+				ret_value_obj = None
+			params = []
+			for i in range(param_count):
+				loc = types.ValueLocation._from_core_struct(locations[i])
+				ty = types.Type.from_core_struct(type_list[i])
+				params.append((loc, ty))
+			return self.get_stack_adjustment_for_locations(view_obj, ret_value_obj, params)
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._get_stack_adjustment_for_locations")
+			return 0
+
+	def _get_register_stack_adjustments(self, ctxt, view, ret_value, params, param_count, out_regs, out_adjust):
+		try:
+			if view:
+				view_obj = binaryview.BinaryView(handle=core.BNNewViewReference(view))
+			else:
+				view_obj = None
+			if ret_value:
+				ret_value_obj = types.ValueLocation._from_core_struct(ret_value[0])
+			else:
+				ret_value_obj = None
+			param_objs = []
+			for i in range(param_count):
+				param_objs.append(types.ValueLocation._from_core_struct(params[i]))
+			adjustment = self.get_register_stack_adjustments(view_obj, ret_value_obj, param_objs)
+
+			regs = (ctypes.c_uint * len(adjustment))()
+			adjust = (ctypes.c_int * len(adjustment))()
+			for i, (reg, adj) in enumerate(adjustment.items()):
+				regs[i] = int(reg)
+				adjust[i] = adj
+
+			reg_ptr = ctypes.cast(regs, ctypes.c_void_p)
+			self._pending_reg_stack_adjustment_reg_lists[reg_ptr.value] = (reg_ptr.value, regs)
+			adjust_ptr = ctypes.cast(adjust, ctypes.c_void_p)
+			self._pending_reg_stack_adjustment_amount_lists[adjust_ptr.value] = (adjust_ptr.value, adjust)
+
+			out_regs[0] = regs
+			out_adjust[0] = adjust
+			return len(adjustment)
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._get_register_stack_adjustments")
+			out_regs[0] = None
+			out_adjust[0] = None
+			return 0
+
+	def _free_register_stack_adjustments(self, ctxt, regs, adjust, count):
+		try:
+			reg_ptr = ctypes.cast(regs, ctypes.c_void_p)
+			if reg_ptr.value is not None:
+				if reg_ptr.value not in self._pending_reg_stack_adjustment_reg_lists:
+					raise ValueError("freeing register list that wasn't allocated")
+				del self._pending_reg_stack_adjustment_reg_lists[reg_ptr.value]
+			adjust_ptr = ctypes.cast(adjust, ctypes.c_void_p)
+			if adjust_ptr.value is not None:
+				if adjust_ptr.value not in self._pending_reg_stack_adjustment_amount_lists:
+					raise ValueError("freeing adjustment list that wasn't allocated")
+				del self._pending_reg_stack_adjustment_amount_lists[adjust_ptr.value]
+		except:
+			log_error_for_exception("Unhandled Python exception in CallingConvention._free_register_stack_adjustments")
+
 	def perform_get_incoming_reg_value(
 	    self, reg: 'architecture.RegisterName', func: 'function.Function'
 	) -> 'variable.RegisterValue':
+		"""Deprecated, override `get_incoming_reg_value` instead."""
 		reg_stack = self.arch.get_reg_stack_for_reg(reg)
 		if reg_stack is not None:
 			if reg == self.arch.reg_stacks[reg_stack].stack_top_reg:
@@ -504,25 +792,335 @@ class CallingConvention:
 	def perform_get_incoming_flag_value(
 	    self, flag: 'architecture.FlagName', func: 'function.Function'
 	) -> 'variable.RegisterValue':
+		"""Deprecated, override `get_incoming_flag_value` instead."""
 		return variable.Undetermined()
 
 	def perform_get_incoming_var_for_parameter_var(
 	    self, in_var: 'variable.CoreVariable', func: Optional['function.Function'] = None
 	) -> 'variable.CoreVariable':
+		"""Deprecated, override `get_incoming_var_for_parameter_var` instead."""
 		out_var = core.BNGetDefaultIncomingVariableForParameterVariable(self.handle, in_var.to_BNVariable())
 		return variable.CoreVariable.from_BNVariable(out_var)
 
 	def perform_get_parameter_var_for_incoming_var(
 	    self, in_var: 'variable.CoreVariable', func: Optional['function.Function'] = None
 	) -> 'variable.CoreVariable':
+		"""Deprecated, override `get_parameter_var_for_incoming_var` instead."""
 		out_var = core.BNGetDefaultParameterVariableForIncomingVariable(self.handle, in_var.to_BNVariable())
 		return variable.CoreVariable.from_BNVariable(out_var)
 
+	def get_incoming_reg_value(
+		self, reg: 'architecture.RegisterName', func: 'function.Function'
+	) -> 'variable.RegisterValue':
+		return self.perform_get_incoming_reg_value(reg, func)
+
+	def get_incoming_flag_value(
+		self, reg: 'architecture.RegisterName', func: 'function.Function'
+	) -> 'variable.RegisterValue':
+		return self.perform_get_incoming_flag_value(reg, func)
+
+	def get_incoming_var_for_parameter_var(
+		self, in_var: 'variable.CoreVariable', func: Optional['function.Function'] = None
+	) -> 'variable.CoreVariable':
+		return self.perform_get_incoming_var_for_parameter_var(in_var, func)
+
+	def get_parameter_var_for_incoming_var(
+		self, in_var: 'variable.CoreVariable', func: Optional['function.Function'] = None
+	) -> 'variable.CoreVariable':
+		return self.perform_get_incoming_var_for_parameter_var(in_var, func)
+
+	def is_return_type_reg_compatible(self, view: Optional['binaryview.BinaryView'], type: 'types.Type') -> bool:
+		return self.default_is_return_type_reg_compatible(type)
+
+	def is_non_reg_arg_indirect(self, view: Optional['binaryview.BinaryView'], type: Optional['types.Type']) -> bool:
+		return False
+
+	def default_is_return_type_reg_compatible(self, type: 'types.Type') -> bool:
+		return core.BNDefaultIsReturnTypeRegisterCompatible(self.handle, type.handle)
+
+	def get_indirect_return_value_location(self) -> 'variable.CoreVariable':
+		return self.get_default_indirect_return_value_location()
+
+	def get_default_indirect_return_value_location(self) -> 'variable.CoreVariable':
+		result = core.BNGetDefaultIndirectReturnValueLocation(self.handle)
+		return variable.CoreVariable.from_BNVariable(result)
+
+	def get_returned_indirect_return_value_pointer(self) -> Optional['variable.CoreVariable']:
+		return None
+
+	def is_arg_type_reg_compatible(self, view: Optional['binaryview.BinaryView'], type: 'types.Type') -> bool:
+		return self.default_is_arg_type_reg_compatible(type)
+
+	def default_is_arg_type_reg_compatible(self, type: 'types.Type') -> bool:
+		return core.BNDefaultIsArgumentTypeRegisterCompatible(self.handle, type.handle)
+
+	def get_call_layout(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ReturnValueOrType'],
+		params: 'types.ParamsType', func: Optional['function.Function'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> 'CallLayout':
+		return self.get_default_call_layout(view, return_value, params, func, permitted_regs)
+
+	def get_default_call_layout(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ReturnValueOrType'],
+		params: 'types.ParamsType', func: Optional['function.Function'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> 'CallLayout':
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = types.ReturnValue(types.Type.void())._to_core_struct()
+		elif isinstance(return_value, types.ReturnValue):
+			ret = return_value._to_core_struct()
+		else:
+			ret = types.ReturnValue(return_value)._to_core_struct()
+		param_structs, type_list = types.FunctionBuilder._to_core_struct(params)
+		if permitted_regs is None:
+			layout = core.BNGetDefaultCallLayoutDefaultPermittedArgs(self.handle, view_obj, ret, param_structs, len(params))
+		else:
+			regs = (ctypes.c_uint * len(permitted_regs))()
+			for i in range(len(permitted_regs)):
+				regs[i] = int(permitted_regs[i])
+			layout = core.BNGetDefaultCallLayout(self.handle, view_obj, ret, param_structs, len(params), regs,
+				len(permitted_regs))
+		result = CallLayout._from_core_struct(layout, func)
+		core.BNFreeCallLayout(layout)
+		return result
+
+	def get_return_value_location(
+		self, view: Optional['binaryview.BinaryView'], return_value: 'types.ReturnValueOrType'
+	) -> Optional['types.ValueLocation']:
+		return self.get_default_return_value_location(view, return_value)
+
+	def get_default_return_value_location(
+		self, view: Optional['binaryview.BinaryView'], return_value: 'types.ReturnValueOrType'
+	) -> Optional['types.ValueLocation']:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = types.ReturnValue(types.Type.void())._to_core_struct()
+		elif isinstance(return_value, types.ReturnValue):
+			ret = return_value._to_core_struct()
+		else:
+			ret = types.ReturnValue(return_value)._to_core_struct()
+		location = core.BNGetDefaultReturnValueLocation(self.handle, view_obj, ret)
+		if location.count == 0:
+			result = None
+		else:
+			result = types.ValueLocation._from_core_struct(location)
+		core.BNFreeValueLocation(location)
+		return result
+
+	def get_parameter_locations(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: 'types.ParamsType', arch: Optional['architecture.Architecture'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> List['types.ValueLocation']:
+		return self.get_default_parameter_locations(view, return_value, params, arch, permitted_regs)
+
+	def get_default_parameter_locations(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: 'types.ParamsType', arch: Optional['architecture.Architecture'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> List['types.ValueLocation']:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		param_structs, type_list = types.FunctionBuilder._to_core_struct(params)
+		count = ctypes.c_ulonglong()
+		if permitted_regs is None:
+			locations = core.BNGetDefaultParameterLocationsDefaultPermittedArgs(self.handle, view_obj, ret, param_structs,
+				len(params), count)
+		else:
+			regs = (ctypes.c_uint * len(permitted_regs))()
+			for i in range(len(permitted_regs)):
+				regs[i] = int(permitted_regs[i])
+			locations = core.BNGetDefaultParameterLocations(self.handle, view_obj, ret, param_structs, len(params), regs,
+				len(permitted_regs), count)
+		result = []
+		for i in range(count.value):
+			result.append(types.ValueLocation._from_core_struct(locations[i], arch))
+		core.BNFreeValueLocationList(locations, count.value)
+		return result
+
+	def get_stack_adjustment_for_locations(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: List[Tuple['types.ValueLocation', 'types.Type']]
+	):
+		return self.get_default_stack_adjustment_for_locations(return_value, params)
+
+	def get_default_stack_adjustment_for_locations(
+		self, return_value: Optional['types.ValueLocation'],
+		params: List[Tuple['types.ValueLocation', 'types.Type']]
+	):
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		locations = (core.BNValueLocation * len(params))()
+		type_list = (ctypes.POINTER(core.BNType) * len(params))()
+		for i, (loc, ty) in enumerate(params):
+			locations[i] = loc._to_core_struct()
+			type_list[i] = ty.handle
+		return core.BNGetDefaultStackAdjustmentForLocations(self.handle, ret, locations, type_list, len(params))
+
+	def get_register_stack_adjustments(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: List['types.ValueLocation']
+	) -> Dict['architecture.RegisterIndex', int]:
+		return self.get_default_register_stack_adjustments(return_value, params)
+
+	def get_default_register_stack_adjustments(
+			self, return_value: Optional['types.ValueLocation'], params: List['types.ValueLocation']
+	) -> Dict['architecture.RegisterIndex', int]:
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		locations = (core.BNValueLocation * len(params))()
+		for i, loc in enumerate(params):
+			locations[i] = loc._to_core_struct()
+		out_regs = ctypes.POINTER(ctypes.c_uint)()
+		out_adjust = ctypes.POINTER(ctypes.c_int)()
+		count = core.BNGetCallingConventionDefaultRegisterStackAdjustments(self.handle, ret, locations, len(params),
+			out_regs, out_adjust)
+
+		result = {}
+		for i in range(count):
+			result[architecture.RegisterIndex(out_regs[i])] = out_adjust[i]
+
+		core.BNFreeCallingConventionRegisterStackAdjustments(out_regs, out_adjust)
+		return result
+
 	def with_confidence(self, confidence: int) -> 'CallingConvention':
 		return CallingConvention(
 		    self.arch, handle=core.BNNewCallingConventionReference(self.handle), confidence=confidence
 		)
 
+	@property
+	def arch(self) -> 'architecture.Architecture':
+		return self._arch
+
+	@arch.setter
+	def arch(self, value: 'architecture.Architecture') -> None:
+		self._arch = value
+
+
+class CoreCallingConvention(CallingConvention):
+	def __init__(self, handle, confidence: int = core.max_confidence):
+		super().__init__(handle=handle, confidence=confidence)
+
+		self.arch = architecture.CoreArchitecture._from_cache(core.BNGetCallingConventionArchitecture(handle))
+		self.__dict__["name"] = core.BNGetCallingConventionName(handle)
+		self.__dict__["arg_regs_share_index"] = core.BNAreArgumentRegistersSharedIndex(handle)
+		self.__dict__["arg_regs_for_varargs"] = core.BNAreArgumentRegistersUsedForVarArgs(handle)
+		self.__dict__["stack_reserved_for_arg_regs"] = core.BNIsStackReservedForArgumentRegisters(handle)
+		self.__dict__["stack_adjusted_on_return"] = core.BNIsStackAdjustedOnReturn(handle)
+		self.__dict__["eligible_for_heuristics"] = core.BNIsEligibleForHeuristics(handle)
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetCallerSavedRegisters(handle, count)
+		assert regs is not None, "core.BNGetCallerSavedRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["caller_saved_regs"] = result
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetCalleeSavedRegisters(handle, count)
+		assert regs is not None, "core.BNGetCalleeSavedRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["callee_saved_regs"] = result
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetIntegerArgumentRegisters(handle, count)
+		assert regs is not None, "core.BNGetIntegerArgumentRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["int_arg_regs"] = result
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetFloatArgumentRegisters(handle, count)
+		assert regs is not None, "core.BNGetFloatArgumentRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["float_arg_regs"] = result
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetRequiredArgumentRegisters(handle, count)
+		assert regs is not None, "core.BNGetRequiredArgumentRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["required_arg_regs"] = result
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetRequiredClobberedRegisters(handle, count)
+		assert regs is not None, "core.BNGetRequiredClobberedRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["required_clobbered_regs"] = result
+
+		reg = core.BNGetIntegerReturnValueRegister(handle)
+		if reg == 0xffffffff:
+			self.__dict__["int_return_reg"] = None
+		else:
+			self.__dict__["int_return_reg"] = self.arch.get_reg_name(reg)
+
+		reg = core.BNGetHighIntegerReturnValueRegister(handle)
+		if reg == 0xffffffff:
+			self.__dict__["high_int_return_reg"] = None
+		else:
+			self.__dict__["high_int_return_reg"] = self.arch.get_reg_name(reg)
+
+		reg = core.BNGetFloatReturnValueRegister(handle)
+		if reg == 0xffffffff:
+			self.__dict__["float_return_reg"] = None
+		else:
+			self.__dict__["float_return_reg"] = self.arch.get_reg_name(reg)
+
+		reg = core.BNGetGlobalPointerRegister(handle)
+		if reg == 0xffffffff:
+			self.__dict__["global_pointer_reg"] = None
+		else:
+			self.__dict__["global_pointer_reg"] = self.arch.get_reg_name(reg)
+
+		count = ctypes.c_ulonglong()
+		regs = core.BNGetImplicitlyDefinedRegisters(handle, count)
+		assert regs is not None, "core.BNGetImplicitlyDefinedRegisters returned None"
+		result = []
+		arch = self.arch
+		for i in range(0, count.value):
+			result.append(arch.get_reg_name(regs[i]))
+		core.BNFreeRegisterList(regs)
+		self.__dict__["implicitly_defined_regs"] = result
+
 	def get_incoming_reg_value(
 	    self, reg: 'architecture.RegisterType', func: 'function.Function'
 	) -> 'variable.RegisterValue':
@@ -546,7 +1144,7 @@ class CallingConvention:
 		)
 
 	def get_incoming_var_for_parameter_var(
-	    self, in_var: 'variable.CoreVariable', func: FunctionOrILFunction
+	    self, in_var: 'variable.CoreVariable', func: FunctionOrILFunction = None
 	) -> 'variable.Variable':
 		in_buf = in_var.to_BNVariable()
 		if func is None:
@@ -557,7 +1155,7 @@ class CallingConvention:
 		return variable.Variable.from_BNVariable(func, out_var)
 
 	def get_parameter_var_for_incoming_var(
-	    self, in_var: 'variable.CoreVariable', func: FunctionOrILFunction
+	    self, in_var: 'variable.CoreVariable', func: FunctionOrILFunction = None
 	) -> 'variable.Variable':
 		in_buf = in_var.to_BNVariable()
 		if func is None:
@@ -567,10 +1165,160 @@ class CallingConvention:
 		out_var = core.BNGetParameterVariableForIncomingVariable(self.handle, in_buf, func_obj)
 		return variable.Variable.from_BNVariable(func, out_var)
 
-	@property
-	def arch(self) -> 'architecture.Architecture':
-		return self._arch
+	def is_return_type_reg_compatible(self, view: Optional['binaryview.BinaryView'], type: 'types.Type') -> bool:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		return core.BNIsReturnTypeRegisterCompatible(self.handle, view_obj, type.handle)
 
-	@arch.setter
-	def arch(self, value: 'architecture.Architecture') -> None:
-		self._arch = value
+	def get_indirect_return_value_location(self) -> 'variable.CoreVariable':
+		result = core.BNGetIndirectReturnValueLocation(self.handle)
+		return variable.CoreVariable.from_BNVariable(result)
+
+	def get_returned_indirect_return_value_pointer(self) -> Optional['variable.CoreVariable']:
+		var = core.BNVariable()
+		if core.BNGetReturnedIndirectReturnValuePointer(self.handle, var):
+			return variable.CoreVariable.from_BNVariable(var)
+		return None
+
+	def is_arg_type_reg_compatible(self, view: Optional['binaryview.BinaryView'], type: 'types.Type') -> bool:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		return core.BNIsArgumentTypeRegisterCompatible(self.handle, view_obj, type.handle)
+
+	def is_non_reg_arg_indirect(self, view: Optional['binaryview.BinaryView'], type: Optional['types.Type']) -> bool:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if type is None:
+			return core.BNIsNonRegisterArgumentIndirect(self.handle, view_obj, None)
+		else:
+			return core.BNIsNonRegisterArgumentIndirect(self.handle, view_obj, type.handle)
+
+	def get_call_layout(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ReturnValueOrType'],
+		params: 'types.ParamsType', func: Optional['function.Function'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> 'CallLayout':
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = types.ReturnValue(types.Type.void())._to_core_struct()
+		elif isinstance(return_value, types.ReturnValue):
+			ret = return_value._to_core_struct()
+		else:
+			ret = types.ReturnValue(return_value)._to_core_struct()
+		param_structs, type_list = types.FunctionBuilder._to_core_struct(params)
+		if permitted_regs is None:
+			layout = core.BNGetCallLayoutDefaultPermittedArgs(self.handle, view_obj, ret, param_structs, len(params))
+		else:
+			regs = (ctypes.c_uint * len(permitted_regs))()
+			for i in range(len(permitted_regs)):
+				regs[i] = int(permitted_regs[i])
+			layout = core.BNGetCallLayout(self.handle, view_obj, ret, param_structs, len(params), regs, len(permitted_regs))
+		result = CallLayout._from_core_struct(layout, func)
+		core.BNFreeCallLayout(layout)
+		return result
+
+	def get_return_value_location(
+		self, view: Optional['binaryview.BinaryView'], return_value: 'types.ReturnValueOrType'
+	) -> Optional['types.ValueLocation']:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = types.ReturnValue(types.Type.void())._to_core_struct()
+		elif isinstance(return_value, types.ReturnValue):
+			ret = return_value._to_core_struct()
+		else:
+			ret = types.ReturnValue(return_value)._to_core_struct()
+		location = core.BNGetReturnValueLocation(self.handle, view_obj, ret)
+		if location.count == 0:
+			result = None
+		else:
+			result = types.ValueLocation._from_core_struct(location)
+		core.BNFreeValueLocation(location)
+		return result
+
+	def get_parameter_locations(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: 'types.ParamsType', arch: Optional['architecture.Architecture'] = None,
+		permitted_regs: Optional[List['architecture.RegisterIndex']] = None
+	) -> List['types.ValueLocation']:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		param_structs, type_list = types.FunctionBuilder._to_core_struct(params)
+		count = ctypes.c_ulonglong()
+		if permitted_regs is None:
+			locations = core.BNGetParameterLocationsDefaultPermittedArgs(self.handle, view_obj, ret, param_structs,
+				len(params), count)
+		else:
+			regs = (ctypes.c_uint * len(permitted_regs))()
+			for i in range(len(permitted_regs)):
+				regs[i] = int(permitted_regs[i])
+			locations = core.BNGetParameterLocations(self.handle, view_obj, ret, param_structs, len(params), regs,
+				len(permitted_regs), count)
+		result = []
+		for i in range(count.value):
+			result.append(types.ValueLocation._from_core_struct(locations[i], arch))
+		core.BNFreeValueLocationList(locations, count.value)
+		return result
+
+	def get_stack_adjustment_for_locations(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: List[Tuple['types.ValueLocation', 'types.Type']]
+	):
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		locations = (core.BNValueLocation * len(params))()
+		type_list = (ctypes.POINTER(core.BNType) * len(params))()
+		for i, (loc, ty) in enumerate(params):
+			locations[i] = loc._to_core_struct()
+			type_list[i] = ty.handle
+		return core.BNGetStackAdjustmentForLocations(self.handle, view_obj, ret, locations, type_list, len(params))
+
+	def get_register_stack_adjustments(
+		self, view: Optional['binaryview.BinaryView'], return_value: Optional['types.ValueLocation'],
+		params: List['types.ValueLocation']
+	) -> Dict['architecture.RegisterIndex', int]:
+		if view is None:
+			view_obj = None
+		else:
+			view_obj = view.handle
+		if return_value is None:
+			ret = None
+		else:
+			ret = return_value._to_core_struct()
+		locations = (core.BNValueLocation * len(params))()
+		for i, loc in enumerate(params):
+			locations[i] = loc._to_core_struct()
+		out_regs = ctypes.POINTER(ctypes.c_uint)()
+		out_adjust = ctypes.POINTER(ctypes.c_int)()
+		count = core.BNGetCallingConventionRegisterStackAdjustments(self.handle, view_obj, ret, locations, len(params),
+			out_regs, out_adjust)
+
+		result = {}
+		for i in range(count):
+			result[architecture.RegisterIndex(out_regs[i])] = out_adjust[i]
+
+		core.BNFreeCallingConventionRegisterStackAdjustments(out_regs, out_adjust)
+		return result