Enum falcon::il::Expression

pub enum Expression {
    Scalar(Scalar),
    Constant(Constant),
    Add(Box<Expression>, Box<Expression>),
    Sub(Box<Expression>, Box<Expression>),
    Mul(Box<Expression>, Box<Expression>),
    Divu(Box<Expression>, Box<Expression>),
    Modu(Box<Expression>, Box<Expression>),
    Divs(Box<Expression>, Box<Expression>),
    Mods(Box<Expression>, Box<Expression>),
    And(Box<Expression>, Box<Expression>),
    Or(Box<Expression>, Box<Expression>),
    Xor(Box<Expression>, Box<Expression>),
    Shl(Box<Expression>, Box<Expression>),
    Shr(Box<Expression>, Box<Expression>),
    Cmpeq(Box<Expression>, Box<Expression>),
    Cmpneq(Box<Expression>, Box<Expression>),
    Cmplts(Box<Expression>, Box<Expression>),
    Cmpltu(Box<Expression>, Box<Expression>),
    Zext(usize, Box<Expression>),
    Sext(usize, Box<Expression>),
    Trun(usize, Box<Expression>),
    Ite(Box<Expression>, Box<Expression>, Box<Expression>),
}

An IL Expression.

Variants

Scalar(Scalar)

Constant(Constant)

Add(Box<Expression>, Box<Expression>)

Sub(Box<Expression>, Box<Expression>)

Mul(Box<Expression>, Box<Expression>)

Divu(Box<Expression>, Box<Expression>)

Modu(Box<Expression>, Box<Expression>)

Divs(Box<Expression>, Box<Expression>)

Mods(Box<Expression>, Box<Expression>)

And(Box<Expression>, Box<Expression>)

Or(Box<Expression>, Box<Expression>)

Xor(Box<Expression>, Box<Expression>)

Shl(Box<Expression>, Box<Expression>)

Shr(Box<Expression>, Box<Expression>)

Cmpeq(Box<Expression>, Box<Expression>)

Cmpneq(Box<Expression>, Box<Expression>)

Cmplts(Box<Expression>, Box<Expression>)

Cmpltu(Box<Expression>, Box<Expression>)

Zext(usize, Box<Expression>)

Sext(usize, Box<Expression>)

Trun(usize, Box<Expression>)

Ite(Box<Expression>, Box<Expression>, Box<Expression>)

Methods

impl Expression

pub fn bits(&self) -> usize

Return the bitness of this expression.

pub fn replace_scalar(
    &self,
    scalar: &Scalar,
    expression: &Expression
) -> Result<Expression>

Return a clone of this expression, but with every occurrence of the given scalar replaced with the given expression

pub fn all_constants(&self) -> bool

Return true if all terminals in this expression are Constant

pub fn scalars(&self) -> Vec<&Scalar>

Returns all Scalars used in this Expression

pub fn scalars_mut(&mut self) -> Vec<&mut Scalar>

Return mutable references to all Scalars in this Expression.

pub fn get_scalar(&self) -> Option<&Scalar>

If this expression is a scalar, return the scalar

pub fn get_constant(&self) -> Option<&Constant>

If this expression is a constant, return the constant

pub fn scalar(scalar: Scalar) -> Expression

Create a new Expression from a Scalar.

pub fn constant(constant: Constant) -> Expression

Create a new Expression from a Constant.

pub fn add(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an addition Expression.

Error

The sort of the lhs and the rhs are not the same

pub fn sub(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a subtraction Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn mul(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an unsigned multiplication Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn divu(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an unsigned division Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn modu(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an unsigned modulus Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn divs(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a signed division Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn mods(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a signed modulus Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn and(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a binary and Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn or(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a binary or Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn xor(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a binary xor Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn shl(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a logical shift-left Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn shr(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a logical shift-right Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn cmpeq(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an equals comparison Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn cmpneq(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an not equals comparison Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn cmpltu(lhs: Expression, rhs: Expression) -> Result<Expression>

Create an unsigned less-than comparison Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn cmplts(lhs: Expression, rhs: Expression) -> Result<Expression>

Create a signed less-than comparison Expression.

Error

The sort of the lhs and the rhs are not the same.

pub fn zext(bits: usize, src: Expression) -> Result<Expression>

Create an expression to zero-extend src to the number of bits specified in bits.

Error

src has more or equal number of bits than bits

pub fn sext(bits: usize, src: Expression) -> Result<Expression>

Create an expression to sign-extend src to the number of bits specified

Error

src has more or equal number of bits than bits

pub fn trun(bits: usize, src: Expression) -> Result<Expression>

Create an expression to truncate the number of bits in src to the number of bits given.

Error

src has less-than or equal bits than bits

pub fn ite(
    cond: Expression,
    then: Expression,
    else_: Expression
) -> Result<Expression>

Create an if-than-else expression

Error

condition is not 1-bit, or bitness of then and else_ do not match.

pub fn sra(lhs: Expression, rhs: Expression) -> Result<Expression>

Perform a shift-right arithmetic

This is a pseudo-expression, and emits an expression with sub-expressions

pub fn rotl(e: Expression, s: Expression) -> Result<Expression>

Perform a left-rotation

This is a pseudo-expression, and emits an expression with sub-expressions

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Expression

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

Formats the value using the given formatter.

impl Eq for Expression

impl Hash for Expression

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, 

Feeds a slice of this type into the given [Hasher].

impl Into<Expression> for Constant

fn into(self) -> Expression

Performs the conversion.

impl Into<Expression> for Scalar

fn into(self) -> Expression

Performs the conversion.

impl Ord for Expression

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Expression> for Expression

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

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

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

This method tests for !=.

impl PartialOrd<Expression> for Expression

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Expression

impl StructuralPartialEq for Expression

impl Value for Expression

fn constant(constant: Constant) -> Self

Turn an il::Constant into a representation of this Value

fn bits(&self) -> usize

Return the number of bits contained in this value

fn shl(&self, bits: usize) -> Result<Self>

Shift the value left by the given number of bits

fn shr(&self, bits: usize) -> Result<Self>

Shift the value right by the given number of bits

fn trun(&self, bits: usize) -> Result<Self>

Truncate the value to the given number of bits

fn zext(&self, bits: usize) -> Result<Self>

Zero-extend the value to the given number of bits

fn or(&self, other: &Self) -> Result<Self>

Or this value with the given value