Struct InstructionFilter

pub struct InstructionFilter {
    pub data: ArrayVec<ByteFilter, 16>,
}

A filter that can match groups of instructions.

Fields

data: ArrayVec<ByteFilter, 16>

The filters for each byte in the instruction.

Implementations

impl InstructionFilter

pub fn new<I: IntoIterator<Item = ByteFilter>>(data: I) -> InstructionFilter

Creates a new InstructionFilter from the provided iterator. The iterator should not yield more than 15 elements.

pub fn parse(s: &str) -> InstructionFilter

Parses an instruction filter from a string.

pub fn intersect(&self, other: &InstructionFilter) -> InstructionFilter

Computes the intersection of the InstructionFilters.

pub fn matches(&self, instr: &Instruction) -> bool

Returns true if the filter matches instr.

pub fn matches_smaller_instr_partially(&self, instr: &Instruction) -> bool

Returns true if the filter matches all bytes in instr, even if not all instructions that start with instr are matched by this filter.

For example: the filter 03AB partially matches the instruction 03. However, it does not match all instructions starting with 03. For example, 0300.

pub fn len(&self) -> usize

Returns the byte length of the instructions matched by the InstructionFilter.

pub fn is_empty(&self) -> bool

Returns true if the InstructionFilter is empty.

pub fn bit_len(&self) -> usize

Returns the bitlength of the instructions matched by the InstructionFilter.

pub fn byte_len(&self) -> usize

Returns the byte length of the instructions matched by the InstructionFilter.

pub fn nth_bit_from_left(&self, index: usize) -> FilterBit

Returns the bit at position index, counting from the left.

pub fn nth_bit_from_right(&self, index: usize) -> FilterBit

Returns the bit at position index, counting from the right.

pub fn value_as_u128(&self) -> u128

Returns the values of the ByteFilters concatenated into an u128.

pub fn mask_as_u128(&self) -> u128

Returns the masks of the ByteFilters concatenated into an u128.

pub fn covers(&self, other: &InstructionFilter) -> bool

Returns true if the filter matches all instructions matched by other.

pub fn overlaps(&self, other: &InstructionFilter) -> bool

Returns true if there is at least one instruction which both filters match.

pub fn try_merge(&self, other: &InstructionFilter) -> Option<InstructionFilter>

Tries to merge the filters into a filter that matches all instructions matched by either self or other.

pub fn try_exclude( &self, other: &InstructionFilter, ) -> Option<InstructionFilter>

Tries to compute self - other.

pub fn smallest_matching_instruction(&self) -> Instruction

Returns the smallest matching instruction. In other words, the instruction with all wildcard bits set to 0.

pub fn largest_matching_instruction(&self) -> Instruction

Returns the largest matching instruction. In other words, the instruction with all wildcard bits set to 1.

pub fn next_matching_instruction( &self, instr: &Instruction, ) -> Option<Instruction>

When instr does not match the filter, returns the first instruction after instr that matches the filter. When instr does match the filter, returns instr.

pub fn num_wildcard_bits(&self) -> usize

Returns the number of wildcard bits in the InstructionFilter.

pub fn set_nth_bit_from_right(&mut self, index: usize, bit: FilterBit)

Sets the bit at position index, counting from the right, to bit.

pub fn set_nth_bit_from_left(&mut self, index: usize, bit: FilterBit)

Sets the bit at position index, counting from the left, to bit.

pub fn find_uncovered_instr( &self, covering_filters: Vec<InstructionFilter>, ) -> Option<Instruction>

Returns an crate::instr::Instruction that matches this filter, but none of the filters in covering_filters.

Trait Implementations

impl Clone for InstructionFilter

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionFilter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InstructionFilter

fn deserialize<D>(deserializer: D) -> Result<InstructionFilter, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Instruction> for InstructionFilter

fn from(instr: &Instruction) -> Self

Converts to this type from the input type.

impl From<&str> for InstructionFilter

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<Instruction> for InstructionFilter

fn from(instr: Instruction) -> Self

Converts to this type from the input type.

impl FromStr for InstructionFilter

type Err = FromHexError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for InstructionFilter

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 Ord for InstructionFilter

fn cmp(&self, other: &InstructionFilter) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for InstructionFilter

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

fn partial_cmp(&self, other: &InstructionFilter) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for InstructionFilter

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for InstructionFilter

impl StructuralPartialEq for InstructionFilter