Trait ArchitectureHook 

pub trait ArchitectureHook:
    Send
    + Sync
    + 'static {
    // Provided methods
    fn endianness(&self, base: &CoreArchitecture) -> Endianness { ... }
    fn address_size(&self, base: &CoreArchitecture) -> usize { ... }
    fn default_integer_size(&self, base: &CoreArchitecture) -> usize { ... }
    fn instruction_alignment(&self, base: &CoreArchitecture) -> usize { ... }
    fn linear_sweep_initial_alignment(&self, base: &CoreArchitecture) -> usize { ... }
    fn linear_sweep_analysis_capabilities(&self, base: &CoreArchitecture) -> u32 { ... }
    fn max_instr_len(&self, base: &CoreArchitecture) -> usize { ... }
    fn opcode_display_len(&self, base: &CoreArchitecture) -> usize { ... }
    fn associated_arch_by_addr(
        &self,
        base: &CoreArchitecture,
        addr: &mut u64,
    ) -> CoreArchitecture { ... }
    fn instruction_info(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> Option<InstructionInfo> { ... }
    fn instruction_text(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> Option<(usize, Vec<InstructionTextToken>)> { ... }
    fn instruction_text_with_context(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
        context: Option<NonNull<c_void>>,
    ) -> Option<(usize, Vec<InstructionTextToken>)> { ... }
    fn instruction_llil(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
        il: &LowLevelILMutableFunction,
    ) -> Option<(usize, bool)> { ... }
    fn analyze_basic_blocks(
        &self,
        base: &CoreArchitecture,
        function: &mut Function,
        context: &mut BasicBlockAnalysisContext,
    ) { ... }
    fn lift_function(
        &self,
        base: &CoreArchitecture,
        function: LowLevelILMutableFunction,
        context: &mut FunctionLifterContext,
    ) -> bool { ... }
    fn flag_write_llil<'a>(
        &self,
        base: &CoreArchitecture,
        flag: CoreFlag,
        flag_write_type: CoreFlagWrite,
        op: LowLevelILFlagWriteOp<CoreRegister>,
        il: &'a LowLevelILMutableFunction,
    ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>> { ... }
    fn flags_required_for_flag_condition(
        &self,
        base: &CoreArchitecture,
        condition: FlagCondition,
        class: Option<CoreFlagClass>,
    ) -> Vec<CoreFlag> { ... }
    fn flag_cond_llil<'a>(
        &self,
        base: &CoreArchitecture,
        cond: FlagCondition,
        class: Option<CoreFlagClass>,
        il: &'a LowLevelILMutableFunction,
    ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>> { ... }
    fn flag_group_llil<'a>(
        &self,
        base: &CoreArchitecture,
        group: CoreFlagGroup,
        il: &'a LowLevelILMutableFunction,
    ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>> { ... }
    fn registers_all(&self, base: &CoreArchitecture) -> Vec<CoreRegister> { ... }
    fn register_from_id(
        &self,
        base: &CoreArchitecture,
        id: RegisterId,
    ) -> Option<CoreRegister> { ... }
    fn registers_full_width(&self, base: &CoreArchitecture) -> Vec<CoreRegister> { ... }
    fn registers_global(&self, base: &CoreArchitecture) -> Vec<CoreRegister> { ... }
    fn registers_system(&self, base: &CoreArchitecture) -> Vec<CoreRegister> { ... }
    fn stack_pointer_reg(&self, base: &CoreArchitecture) -> Option<CoreRegister> { ... }
    fn link_reg(&self, base: &CoreArchitecture) -> Option<CoreRegister> { ... }
    fn register_stacks(&self, base: &CoreArchitecture) -> Vec<CoreRegisterStack> { ... }
    fn register_stack_from_id(
        &self,
        base: &CoreArchitecture,
        id: RegisterStackId,
    ) -> Option<CoreRegisterStack> { ... }
    fn flags(&self, base: &CoreArchitecture) -> Vec<CoreFlag> { ... }
    fn flag_from_id(
        &self,
        base: &CoreArchitecture,
        id: FlagId,
    ) -> Option<CoreFlag> { ... }
    fn flag_write_types(&self, base: &CoreArchitecture) -> Vec<CoreFlagWrite> { ... }
    fn flag_write_from_id(
        &self,
        base: &CoreArchitecture,
        id: FlagWriteId,
    ) -> Option<CoreFlagWrite> { ... }
    fn flag_classes(&self, base: &CoreArchitecture) -> Vec<CoreFlagClass> { ... }
    fn flag_class_from_id(
        &self,
        base: &CoreArchitecture,
        id: FlagClassId,
    ) -> Option<CoreFlagClass> { ... }
    fn flag_groups(&self, base: &CoreArchitecture) -> Vec<CoreFlagGroup> { ... }
    fn flag_group_from_id(
        &self,
        base: &CoreArchitecture,
        id: FlagGroupId,
    ) -> Option<CoreFlagGroup> { ... }
    fn intrinsics(&self, base: &CoreArchitecture) -> Vec<CoreIntrinsic> { ... }
    fn intrinsic_class(
        &self,
        base: &CoreArchitecture,
        id: IntrinsicId,
    ) -> BNIntrinsicClass { ... }
    fn intrinsic_from_id(
        &self,
        base: &CoreArchitecture,
        id: IntrinsicId,
    ) -> Option<CoreIntrinsic> { ... }
    fn can_assemble(&self, base: &CoreArchitecture) -> bool { ... }
    fn assemble(
        &self,
        base: &CoreArchitecture,
        code: &str,
        addr: u64,
    ) -> Result<Vec<u8>, String> { ... }
    fn is_never_branch_patch_available(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> bool { ... }
    fn is_always_branch_patch_available(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> bool { ... }
    fn is_invert_branch_patch_available(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> bool { ... }
    fn is_skip_and_return_zero_patch_available(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> bool { ... }
    fn is_skip_and_return_value_patch_available(
        &self,
        base: &CoreArchitecture,
        data: &[u8],
        addr: u64,
    ) -> bool { ... }
    fn convert_to_nop(
        &self,
        base: &CoreArchitecture,
        data: &mut [u8],
        addr: u64,
    ) -> bool { ... }
    fn always_branch(
        &self,
        base: &CoreArchitecture,
        data: &mut [u8],
        addr: u64,
    ) -> bool { ... }
    fn invert_branch(
        &self,
        base: &CoreArchitecture,
        data: &mut [u8],
        addr: u64,
    ) -> bool { ... }
    fn skip_and_return_value(
        &self,
        base: &CoreArchitecture,
        data: &mut [u8],
        addr: u64,
        value: u64,
    ) -> bool { ... }
}

Overrides selected operations of an already registered architecture.

Every method defaults to forwarding to base, the previous implementation in the hook chain. Override only the methods you need. Use the supplied base to delegate: looking up the hooked architecture by name inside a callback would call the hook again.

Flag-write operations without a typed representation are delivered as LowLevelILFlagWriteOp::Raw, including their complete operand list.

The methods have the same semantics as their counterparts in Architecture. Contextual disassembly forwards to the previous contextual implementation; override ArchitectureHook::instruction_text_with_context to change contextual text.

Register implementations with register_architecture_hook.

Provided Methods

fn endianness(&self, base: &CoreArchitecture) -> Endianness

See Architecture::endianness.

fn address_size(&self, base: &CoreArchitecture) -> usize

See Architecture::address_size.

fn default_integer_size(&self, base: &CoreArchitecture) -> usize

See Architecture::default_integer_size.

fn instruction_alignment(&self, base: &CoreArchitecture) -> usize

See Architecture::instruction_alignment.

fn linear_sweep_initial_alignment(&self, base: &CoreArchitecture) -> usize

See Architecture::linear_sweep_initial_alignment.

fn linear_sweep_analysis_capabilities(&self, base: &CoreArchitecture) -> u32

See Architecture::linear_sweep_analysis_capabilities.

fn max_instr_len(&self, base: &CoreArchitecture) -> usize

See Architecture::max_instr_len.

fn opcode_display_len(&self, base: &CoreArchitecture) -> usize

See Architecture::opcode_display_len.

fn associated_arch_by_addr( &self, base: &CoreArchitecture, addr: &mut u64, ) -> CoreArchitecture

See Architecture::associated_arch_by_addr.

fn instruction_info( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> Option<InstructionInfo>

See Architecture::instruction_info.

fn instruction_text( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> Option<(usize, Vec<InstructionTextToken>)>

See Architecture::instruction_text.

fn instruction_text_with_context( &self, base: &CoreArchitecture, data: &[u8], addr: u64, context: Option<NonNull<c_void>>, ) -> Option<(usize, Vec<InstructionTextToken>)>

See Architecture::instruction_text_with_context.

fn instruction_llil( &self, base: &CoreArchitecture, data: &[u8], addr: u64, il: &LowLevelILMutableFunction, ) -> Option<(usize, bool)>

See Architecture::instruction_llil.

fn analyze_basic_blocks( &self, base: &CoreArchitecture, function: &mut Function, context: &mut BasicBlockAnalysisContext, )

See Architecture::analyze_basic_blocks.

fn lift_function( &self, base: &CoreArchitecture, function: LowLevelILMutableFunction, context: &mut FunctionLifterContext, ) -> bool

See Architecture::lift_function.

fn flag_write_llil<'a>( &self, base: &CoreArchitecture, flag: CoreFlag, flag_write_type: CoreFlagWrite, op: LowLevelILFlagWriteOp<CoreRegister>, il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

See Architecture::flag_write_llil.

fn flags_required_for_flag_condition( &self, base: &CoreArchitecture, condition: FlagCondition, class: Option<CoreFlagClass>, ) -> Vec<CoreFlag>

See Architecture::flags_required_for_flag_condition.

fn flag_cond_llil<'a>( &self, base: &CoreArchitecture, cond: FlagCondition, class: Option<CoreFlagClass>, il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

See Architecture::flag_cond_llil.

fn flag_group_llil<'a>( &self, base: &CoreArchitecture, group: CoreFlagGroup, il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

See Architecture::flag_group_llil.

fn registers_all(&self, base: &CoreArchitecture) -> Vec<CoreRegister>

See Architecture::registers_all.

fn register_from_id( &self, base: &CoreArchitecture, id: RegisterId, ) -> Option<CoreRegister>

See Architecture::register_from_id.

fn registers_full_width(&self, base: &CoreArchitecture) -> Vec<CoreRegister>

See Architecture::registers_full_width.

fn registers_global(&self, base: &CoreArchitecture) -> Vec<CoreRegister>

See Architecture::registers_global.

fn registers_system(&self, base: &CoreArchitecture) -> Vec<CoreRegister>

See Architecture::registers_system.

fn stack_pointer_reg(&self, base: &CoreArchitecture) -> Option<CoreRegister>

See Architecture::stack_pointer_reg.

fn link_reg(&self, base: &CoreArchitecture) -> Option<CoreRegister>

See Architecture::link_reg.

fn register_stacks(&self, base: &CoreArchitecture) -> Vec<CoreRegisterStack>

See Architecture::register_stacks.

fn register_stack_from_id( &self, base: &CoreArchitecture, id: RegisterStackId, ) -> Option<CoreRegisterStack>

See Architecture::register_stack_from_id.

fn flags(&self, base: &CoreArchitecture) -> Vec<CoreFlag>

See Architecture::flags.

fn flag_from_id(&self, base: &CoreArchitecture, id: FlagId) -> Option<CoreFlag>

See Architecture::flag_from_id.

fn flag_write_types(&self, base: &CoreArchitecture) -> Vec<CoreFlagWrite>

See Architecture::flag_write_types.

fn flag_write_from_id( &self, base: &CoreArchitecture, id: FlagWriteId, ) -> Option<CoreFlagWrite>

See Architecture::flag_write_from_id.

fn flag_classes(&self, base: &CoreArchitecture) -> Vec<CoreFlagClass>

See Architecture::flag_classes.

fn flag_class_from_id( &self, base: &CoreArchitecture, id: FlagClassId, ) -> Option<CoreFlagClass>

See Architecture::flag_class_from_id.

fn flag_groups(&self, base: &CoreArchitecture) -> Vec<CoreFlagGroup>

See Architecture::flag_groups.

fn flag_group_from_id( &self, base: &CoreArchitecture, id: FlagGroupId, ) -> Option<CoreFlagGroup>

See Architecture::flag_group_from_id.

fn intrinsics(&self, base: &CoreArchitecture) -> Vec<CoreIntrinsic>

See Architecture::intrinsics.

fn intrinsic_class( &self, base: &CoreArchitecture, id: IntrinsicId, ) -> BNIntrinsicClass

See Architecture::intrinsic_class.

fn intrinsic_from_id( &self, base: &CoreArchitecture, id: IntrinsicId, ) -> Option<CoreIntrinsic>

See Architecture::intrinsic_from_id.

fn can_assemble(&self, base: &CoreArchitecture) -> bool

See Architecture::can_assemble.

fn assemble( &self, base: &CoreArchitecture, code: &str, addr: u64, ) -> Result<Vec<u8>, String>

See Architecture::assemble.

fn is_never_branch_patch_available( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> bool

See Architecture::is_never_branch_patch_available.

fn is_always_branch_patch_available( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> bool

See Architecture::is_always_branch_patch_available.

fn is_invert_branch_patch_available( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> bool

See Architecture::is_invert_branch_patch_available.

fn is_skip_and_return_zero_patch_available( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> bool

See Architecture::is_skip_and_return_zero_patch_available.

fn is_skip_and_return_value_patch_available( &self, base: &CoreArchitecture, data: &[u8], addr: u64, ) -> bool

See Architecture::is_skip_and_return_value_patch_available.

fn convert_to_nop( &self, base: &CoreArchitecture, data: &mut [u8], addr: u64, ) -> bool

See Architecture::convert_to_nop.

fn always_branch( &self, base: &CoreArchitecture, data: &mut [u8], addr: u64, ) -> bool

See Architecture::always_branch.

fn invert_branch( &self, base: &CoreArchitecture, data: &mut [u8], addr: u64, ) -> bool

See Architecture::invert_branch.

fn skip_and_return_value( &self, base: &CoreArchitecture, data: &mut [u8], addr: u64, value: u64, ) -> bool

See Architecture::skip_and_return_value.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors