Struct binaryninja::architecture::CoreArchitecture

pub struct CoreArchitecture(_);

Implementations

impl CoreArchitecture

pub fn list_all() -> CoreArchitectureList

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

pub fn name(&self) -> BnString

Trait Implementations

impl Architecture for CoreArchitecture

type Handle = CoreArchitecture

type RegisterInfo = CoreRegisterInfo

type Register = CoreRegister

type RegisterStackInfo = CoreRegisterStackInfo

type RegisterStack = CoreRegisterStack

type Flag = CoreFlag

type FlagWrite = CoreFlagWrite

type FlagClass = CoreFlagClass

type FlagGroup = CoreFlagGroup

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

fn opcode_display_len(&self) -> usize

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

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

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

fn instruction_llil(
    &self,
    _data: &[u8],
    _addr: u64,
    _il: &mut Lifter<Self>
) -> Option<(usize, bool)>

fn flag_write_llil<'a>(
    &self,
    _flag: Self::Flag,
    _flag_write: Self::FlagWrite,
    _op: FlagWriteOp<Self::Register>,
    _il: &'a mut Lifter<Self>
) -> Option<LiftedExpr<'a, Self>>

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

fn flag_cond_llil<'a>(
    &self,
    _cond: FlagCondition,
    _class: Option<Self::FlagClass>,
    _il: &'a mut Lifter<Self>
) -> Option<LiftedExpr<'a, Self>>

This function MUST NOT append instructions that have side effects.

fn flag_group_llil<'a>(
    &self,
    _group: Self::FlagGroup,
    _il: &'a mut Lifter<Self>
) -> Option<LiftedExpr<'a, Self>>

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 registers_full_width(&self) -> Vec<CoreRegister>

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

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

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

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

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

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

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

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

Determines what flags need to be examined in order to attempt automatic recovery of the semantics of this flag use.

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

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

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

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

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

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

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

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

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

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

fn can_assemble(&self) -> bool

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

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

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

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

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

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

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

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

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

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

fn handle(&self) -> CoreArchitecture

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 copy 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<CoreArchitecture> for CoreArchitecture

fn eq(&self, other: &CoreArchitecture) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 StructuralEq for CoreArchitecture

impl StructuralPartialEq for CoreArchitecture

impl Sync for CoreArchitecture