Enum LOp 

pub enum LOp {
    Const(u32),
    Mov(LReg),
    Add {
        a: LReg,
        b: LReg,
        cin: LReg,
    },
    Sub {
        a: LReg,
        b: LReg,
        bin: LReg,
    },
    Mul {
        a: LReg,
        b: LReg,
    },
    And {
        a: LReg,
        b: LReg,
    },
    Or {
        a: LReg,
        b: LReg,
    },
    Xor {
        a: LReg,
        b: LReg,
    },
    Not {
        a: LReg,
    },
    Shl {
        a: LReg,
        k: u32,
    },
    Shr {
        a: LReg,
        k: u32,
    },
    Ltu {
        a: LReg,
        b: LReg,
    },
    Eq {
        a: LReg,
        b: LReg,
    },
    Sel {
        c: LReg,
        t: LReg,
        f: LReg,
    },
}

One lane operation. Operands are registers; results are words, carries and predicates are 0 or 1.

Variants

Const(u32)

dst = k.

Mov(LReg)

dst = a.

Add

dst = (a + b + cin) mod 2^w, dst2 = (a + b + cin) >> w; cin is 0 or 1.

Fields

a: LReg

b: LReg

cin: LReg

Sub

dst = (a − b − bin) mod 2^w, dst2 = 1 when it borrowed; bin is 0 or 1.

Fields

a: LReg

b: LReg

bin: LReg

Mul

dst = a × b for mul-bit operands: the exact product, one word.

Fields

a: LReg

b: LReg

And

Fields

a: LReg

b: LReg

Or

Fields

a: LReg

b: LReg

Xor

Fields

a: LReg

b: LReg

Not

dst = !a within the word.

Fields

a: LReg

Shl

dst = (a << k) mod 2^w, k < w.

Fields

a: LReg

k: u32

Shr

dst = a >> k (logical), k < w.

Fields

a: LReg

k: u32

Ltu

dst = 1 when a < b (unsigned), else 0.

Fields

a: LReg

b: LReg

Eq

dst = 1 when a == b, else 0.

Fields

a: LReg

b: LReg

Sel

dst = c != 0 ? t : f.

Fields

c: LReg

t: LReg

f: LReg

Trait Implementations

impl Clone for LOp

fn clone(&self) -> LOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for LOp

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 LOp

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for LOp

impl Eq for LOp

impl StructuralPartialEq for LOp