Struct CoreCallingConvention 

pub struct CoreCallingConvention { /* private fields */ }

Implementations

impl CoreCallingConvention

pub fn name(&self) -> String

pub fn arch(&self) -> CoreArchitecture

pub fn default_incoming_variable_for_parameter_variable( &self, var: &Variable, ) -> Variable

pub fn default_parameter_variable_for_incoming_variable( &self, var: &Variable, ) -> Variable

pub fn default_is_return_type_register_compatible(&self, ty: &Type) -> bool

pub fn default_indirect_return_value_location(&self) -> Variable

pub fn default_is_argument_type_register_compatible(&self, ty: &Type) -> bool

pub fn default_call_layout( &self, view: Option<&BinaryView>, return_value: &ReturnValue, params: &[FunctionParameter], permitted_registers: Option<&[RegisterId]>, ) -> CallLayout

pub fn default_return_value_location( &self, view: Option<&BinaryView>, return_value: &ReturnValue, ) -> ValueLocation

pub fn default_parameter_locations( &self, view: Option<&BinaryView>, return_value: Option<&ValueLocation>, params: &[FunctionParameter], permitted_registers: Option<&[RegisterId]>, ) -> Vec<ValueLocation>

pub fn default_parameter_ordering_for_variables( &self, params: &[(Variable, Ref<Type>)], ) -> Vec<Variable>

pub fn default_stack_adjustment_for_locations( &self, return_value: Option<&ValueLocation>, params: &[(ValueLocation, Ref<Type>)], ) -> i64

pub fn default_register_stack_adjustments( &self, return_value: Option<&ValueLocation>, params: &[ValueLocation], ) -> BTreeMap<RegisterId, i32>

Trait Implementations

impl AsRef<CoreCallingConvention> for CoreCallingConvention

fn as_ref(&self) -> &CoreCallingConvention

Converts this type into a shared reference of the (usually inferred) input type.

impl CallingConvention for CoreCallingConvention

fn global_pointer_reg(&self) -> Option<RegisterId>

Deprecated. Use CallingConvention::global_pointer_regs instead.

fn caller_saved_registers(&self) -> Vec<RegisterId>

Gets the list of registers that are not preserved across a call (caller-saved / volatile registers).

fn callee_saved_registers(&self) -> Vec<RegisterId>

Gets the list of registers that a callee must preserve across a call (callee-saved / non-volatile registers).

fn int_arg_registers(&self) -> Vec<RegisterId>

Gets the registers used to pass integer and pointer arguments, in the order they are used.

fn float_arg_registers(&self) -> Vec<RegisterId>

Gets the registers used to pass floating point arguments, in the order they are used.

fn required_argument_registers(&self) -> Vec<RegisterId>

Gets the set of registers that must be arguments for heuristic calling convention detection to consider this calling convention as a valid option.

fn required_clobbered_registers(&self) -> Vec<RegisterId>

Gets the set of registers that must be clobbered for heuristic calling convention detection to consider this calling convention as a valid option.

fn arg_registers_shared_index(&self) -> bool

Whether the integer and floating point argument registers share a single argument index.

fn reserved_stack_space_for_arg_registers(&self) -> bool

Whether stack space is reserved by the caller for the register arguments (for example, the shadow/home space used by the Windows x64 calling convention).

fn stack_adjusted_on_return(&self) -> bool

Whether the callee adjusts the stack to remove the arguments before returning (as in stdcall), rather than leaving the caller to clean up the stack (as in cdecl).

fn is_eligible_for_heuristics(&self) -> bool

Whether this calling convention may be selected by heuristic calling convention detection.

fn return_int_reg(&self) -> Option<RegisterId>

Gets the register that holds the integer return value.

fn return_hi_int_reg(&self) -> Option<RegisterId>

Gets the register that holds the high part of an integer return value that is too large to fit in a single register.

fn return_float_reg(&self) -> Option<RegisterId>

Gets the register that holds the floating point return value.

fn global_pointer_regs(&self) -> Vec<RegisterId>

fn implicitly_defined_registers(&self) -> Vec<RegisterId>

Gets the registers that are implicitly given a known value on function entry by this calling convention.

fn are_argument_registers_used_for_var_args(&self) -> bool

Whether argument registers are used to pass variadic arguments.

fn incoming_register_value( &self, reg: RegisterId, func: Option<&Function>, ) -> RegisterValue

The known value of a register on entry to a function. The default implementation models the top of a register stack (such as the x87 floating point stack) as the constant zero and leaves all other registers undetermined.

fn incoming_flag_value( &self, flag: FlagId, func: Option<&Function>, ) -> RegisterValue

The known value of a flag on entry to a function. The default implementation leaves all flags undetermined.

fn incoming_variable_for_parameter_variable( &self, var: &Variable, func: Option<&Function>, ) -> Variable

The incoming variable used to pass the given parameter variable.

fn parameter_variable_for_incoming_variable( &self, var: &Variable, func: Option<&Function>, ) -> Variable

The parameter variable corresponding to the given incoming variable.

fn is_return_type_register_compatible( &self, view: Option<&BinaryView>, ty: &Type, ) -> bool

Whether a value of the given type can be returned in registers, as opposed to being returned indirectly through memory. The default implementation allows register returns for types that fit in a single register, have a size equal to two registers when CallingConvention::return_hi_int_reg is a valid register, or are a floating point type when CallingConvention::return_float_reg is a valid register.

fn indirect_return_value_location(&self) -> Variable

The location used to pass the hidden pointer argument for return values that are returned indirectly through memory. The default location is the first integer argument register, or the first stack slot if there are no integer argument registers.

fn returned_indirect_return_value_pointer(&self) -> Option<Variable>

The location in which the hidden indirect return value pointer is returned to the caller, for calling conventions that return it.

fn is_argument_type_register_compatible( &self, view: Option<&BinaryView>, ty: &Type, ) -> bool

Whether a value of the given type can be passed as an argument in registers. The default implementation allows register arguments for types that fit in a single register, or are a floating point type when CallingConvention::float_arg_registers has valid registers.

fn is_non_register_argument_indirect( &self, view: Option<&BinaryView>, ty: &Type, ) -> bool

Whether an argument that cannot be passed in registers is passed indirectly by pointer, as opposed to being passed directly on the stack.

fn are_stack_arguments_naturally_aligned(&self) -> bool

Whether arguments passed on the stack are aligned to their natural alignment. If false, arguments are aligned to the address size.

fn are_stack_arguments_pushed_left_to_right(&self) -> bool

Whether arguments passed on the stack are pushed left-to-right, as opposed to the more common right-to-left order.

fn call_layout( &self, view: Option<&BinaryView>, return_value: &ReturnValue, params: &[FunctionParameter], permitted_registers: Option<&[RegisterId]>, ) -> CallLayout

Computes the complete call layout (parameter locations, return value location, and stack adjustments) for a call with the given return value and parameters. The default implementation uses CallingConvention::return_value_location, CallingConvention::parameter_locations, CallingConvention::stack_adjustment_for_locations, and CallingConvention::stack_adjustment_for_locations to compute the layout.

fn return_value_location( &self, view: Option<&BinaryView>, return_value: &ReturnValue, ) -> ValueLocation

Computes the location of the return value for the given return value type. The default implementation checks CallingConvention::is_return_type_register_compatible and places the return value in registers if it can, or uses an indirect return by pointer if not. If an indirect return is required, then CallingConvention::indirect_return_value_location and CallingConvention::returned_indirect_return_value_pointer are used to provide the location of the indirect return value.

fn parameter_locations( &self, view: Option<&BinaryView>, return_value: Option<&ValueLocation>, params: &[FunctionParameter], permitted_registers: Option<&[RegisterId]>, ) -> Vec<ValueLocation>

Computes the locations of the parameters for a call with the given return value and parameters. The default implementation uses CallingConvention::int_arg_registers, CallingConvention::float_arg_registers, CallingConvention::arg_registers_shared_index, CallingConvention::reserved_stack_space_for_arg_registers, CallingConvention::is_argument_type_register_compatible, CallingConvention::is_non_register_argument_indirect, CallingConvention::are_stack_arguments_naturally_aligned, and CallingConvention::are_stack_arguments_pushed_left_to_right to compute the parameter layout.

fn parameter_ordering_for_variables( &self, view: Option<&BinaryView>, params: &[(Variable, Ref<Type>)], ) -> Vec<Variable>

Computes the order in which the given parameter variables are passed. The default implementation first checks CallingConvention::arg_registers_shared_index to see if the parameter ordering is well defined. If the arguments do not share an index, it places all integer arguments before the floating point arguments. Arguments that are not passed in a normal location are placed last.

fn stack_adjustment_for_locations( &self, view: Option<&BinaryView>, return_value: Option<&ValueLocation>, params: &[(ValueLocation, Ref<Type>)], ) -> i64

Computes the stack adjustment applied on return for a call with the given return value and parameter locations. The default implementation first checks CallingConvention::stack_adjusted_on_return, and returns zero if that returns false. Otherwise, it checks the stack parameter locations and CallingConvention::are_stack_arguments_naturally_aligned to compute the stack adjustment necessary to cover all parameters.

fn register_stack_adjustments( &self, view: Option<&BinaryView>, return_value: Option<&ValueLocation>, params: &[ValueLocation], ) -> BTreeMap<RegisterId, i32>

Computes the per-register-stack adjustments (for architectures with register stacks, such as the x87 floating point stack) for a call with the given return value and parameter locations. The default implementation compares the register stack slots used by the parameters and the return value to compute the adjustments.

impl CoreArrayProvider for CoreCallingConvention

type Raw = *mut BNCallingConvention

type Context = CoreArchitecture

type Wrapped<'a> = Guard<'a, CoreCallingConvention>

impl Debug for CoreCallingConvention

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for CoreCallingConvention

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CoreCallingConvention

fn eq(&self, rhs: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToOwned for CoreCallingConvention

type Owned = Ref<CoreCallingConvention>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl Eq for CoreCallingConvention

impl Send for CoreCallingConvention

impl Sync for CoreCallingConvention