Struct CoreArchitecture 

pub struct CoreArchitecture { /* private fields */ }

Implementations

impl CoreArchitecture

pub unsafe fn from_raw(handle: *mut BNArchitecture) -> Self

pub fn list_all() -> CoreArchitectureList

pub fn by_name(name: &str) -> Option<Self>

pub fn name(&self) -> String

Trait Implementations

impl Architecture for CoreArchitecture

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

Performs basic block recovery and commits the results to the function analysis.

NOTE: Only implement this method if function-level analysis is required. Otherwise, do not implement to let default basic block analysis take place.

NOTE: The default implementation exists in C++ here: https://github.com/Vector35/binaryninja-api/blob/dev/defaultabb.cpp

type Handle = CoreArchitecture

type RegisterInfo = CoreRegisterInfo

The RegisterInfo associated with this architecture.

type Register = CoreRegister

The Register associated with this architecture.

type RegisterStackInfo = CoreRegisterStackInfo

The RegisterStackInfo associated with this architecture.

type RegisterStack = CoreRegisterStack

The RegisterStack associated with this architecture.

type Flag = CoreFlag

The Flag associated with this architecture.

type FlagWrite = CoreFlagWrite

The FlagWrite associated with this architecture.

type FlagClass = CoreFlagClass

The FlagClass associated with this architecture.

type FlagGroup = CoreFlagGroup

The FlagGroup associated with this architecture.

type Intrinsic = CoreIntrinsic

fn endianness(&self) -> Endianness

fn address_size(&self) -> usize

fn default_integer_size(&self) -> usize

fn instruction_alignment(&self) -> usize

fn max_instr_len(&self) -> usize

The maximum length of an instruction in bytes. This is used to determine the size of the buffer given to callbacks such as Architecture::instruction_info, Architecture::instruction_text and Architecture::instruction_llil.

fn opcode_display_len(&self) -> usize

How many bytes to display in the opcode space before displaying a ..., typically set to the Architecture::max_instr_len, however, can be overridden to display a truncated opcode.

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

In binaries with multiple architectures, you may wish to associate a specific architecture with a given virtual address. This can be seen in armv7 where odd addresses are associated with the thumb architecture.

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

Returns the InstructionInfo at the given virtual address with data.

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

Disassembles a raw byte sequence into a human-readable list of text tokens.

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

Appends arbitrary low-level il instructions to il.

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

fn flag_write_llil<'a>( &self, _flag: Self::Flag, _flag_write: Self::FlagWrite, _op: LowLevelILFlagWriteOp<Self::Register>, _il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

Fallback flag value calculation path. This method is invoked when the core is unable to recover the flag using semantics and resorts to emitting instructions that explicitly set each observed flag to the value of an expression returned by this function.

fn flags_required_for_flag_condition( &self, condition: FlagCondition, class: Option<Self::FlagClass>, ) -> Vec<Self::Flag>

Determines what flags need to be examined to attempt automatic recovery of the flag uses semantics.

fn flag_cond_llil<'a>( &self, _cond: FlagCondition, _class: Option<Self::FlagClass>, _il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

This function MUST NOT append instructions that have side effects.

fn flag_group_llil<'a>( &self, _group: Self::FlagGroup, _il: &'a LowLevelILMutableFunction, ) -> Option<LowLevelILMutableExpression<'a, ValueExpr>>

Performs fallback resolution when the core was unable to recover the semantics of a LLIL_FLAG_GROUP expression. This occurs when multiple instructions may have set the flags at the flag group query, or when the FlagGroup::flag_conditions() map doesn’t have an entry for the FlagClass associated with the FlagWrite type of the expression that last set the flags required by the FlagGroup group.

fn registers_all(&self) -> Vec<CoreRegister>

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

fn registers_full_width(&self) -> Vec<CoreRegister>

fn registers_global(&self) -> Vec<CoreRegister>

fn registers_system(&self) -> Vec<CoreRegister>

fn stack_pointer_reg(&self) -> Option<CoreRegister>

fn link_reg(&self) -> Option<CoreRegister>

fn register_stacks(&self) -> Vec<CoreRegisterStack>

List of concrete register stacks for this architecture.

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

Get the Self::RegisterStack associated with the given RegisterStackId.

fn flags(&self) -> Vec<CoreFlag>

List of concrete flags for this architecture.

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

Get the Self::Flag associated with the given FlagId.

fn flag_write_types(&self) -> Vec<CoreFlagWrite>

List of concrete flag write types for this architecture.

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

Get the Self::FlagWrite associated with the given FlagWriteId.

fn flag_classes(&self) -> Vec<CoreFlagClass>

List of concrete flag classes for this architecture.

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

Get the Self::FlagClass associated with the given FlagClassId.

fn flag_groups(&self) -> Vec<CoreFlagGroup>

List of concrete flag groups for this architecture.

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

Get the Self::FlagGroup associated with the given FlagGroupId.

fn intrinsics(&self) -> Vec<CoreIntrinsic>

List of concrete intrinsics for this architecture.

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

Get the Self::Intrinsic associated with the given IntrinsicId.

fn can_assemble(&self) -> bool

Let the UI display this patch option.

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

Assemble the code at the specified address and return the machine code in bytes.

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

Let the UI display this patch option.

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

Let the UI display this patch option.

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

Let the UI display this patch option.

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

Let the UI display this patch option.

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

Let the UI display this patch option.

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

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

Patch the instruction to always branch.

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

Patch the instruction to invert the branch condition.

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

Patch the instruction to skip and return value.

fn handle(&self) -> CoreArchitecture

fn intrinsic_class(&self, _id: IntrinsicId) -> BNIntrinsicClass

impl AsRef<CoreArchitecture> for CoreArchitecture

fn as_ref(&self) -> &Self

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

impl Clone for CoreArchitecture

fn clone(&self) -> CoreArchitecture

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CoreArchitecture

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

Formats the value using the given formatter.

impl Hash for CoreArchitecture

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 CoreArchitecture

fn eq(&self, other: &CoreArchitecture) -> 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 Copy for CoreArchitecture

impl Eq for CoreArchitecture

impl Send for CoreArchitecture

impl StructuralPartialEq for CoreArchitecture

impl Sync for CoreArchitecture