Enum vtil_parser::Op[−][src]

pub enum Op {

Show variants    Mov(Operand, Operand),
    Movsx(Operand, Operand),
    Str(Operand, Operand, Operand),
    Ldd(Operand, Operand, Operand),
    Neg(Operand),
    Add(Operand, Operand),
    Sub(Operand, Operand),
    Mul(Operand, Operand),
    Mulhi(Operand, Operand),
    Imul(Operand, Operand),
    Imulhi(Operand, Operand),
    Div(Operand, Operand, Operand),
    Rem(Operand, Operand, Operand),
    Idiv(Operand, Operand, Operand),
    Irem(Operand, Operand, Operand),
    Popcnt(Operand),
    Bsf(Operand),
    Bsr(Operand),
    Not(Operand),
    Shr(Operand, Operand),
    Shl(Operand, Operand),
    Xor(Operand, Operand),
    Or(Operand, Operand),
    And(Operand, Operand),
    Ror(Operand, Operand),
    Rol(Operand, Operand),
    Tg(Operand, Operand, Operand),
    Tge(Operand, Operand, Operand),
    Te(Operand, Operand, Operand),
    Tne(Operand, Operand, Operand),
    Tl(Operand, Operand, Operand),
    Tle(Operand, Operand, Operand),
    Tug(Operand, Operand, Operand),
    Tuge(Operand, Operand, Operand),
    Tul(Operand, Operand, Operand),
    Tule(Operand, Operand, Operand),
    Ifs(Operand, Operand, Operand),
    Js(Operand, Operand, Operand),
    Jmp(Operand),
    Vexit(Operand),
    Vxcall(Operand),
    Nop,
    Sfence,
    Lfence,
    Vemit(Operand),
    Vpinr(Operand),
    Vpinw(Operand),
    Vpinrm(Operand, Operand, Operand),
    Vpinwm(Operand, Operand, Operand),

}

VTIL operator and operands

Variants

OP1 = ZX(OP2)

Movsx(Operand, Operand)

OP1 = SX(OP2)

[OP1+OP2] <= OP3

OP1 <= [OP2+OP3]

Neg(Operand)

OP1 = -OP1

OP1 = OP1 + OP2

OP1 = OP1 - OP2

OP1 = OP1 * OP2

Mulhi(Operand, Operand)

OP1 = [OP1 * OP2]>>N

OP1 = OP1 * OP2 (Signed)

Imulhi(Operand, Operand)

OP1 = [OP1 * OP2]>>N (Signed)

OP1 = [OP2:OP1] / OP3

OP1 = [OP2:OP1] % OP3

OP1 = [OP2:OP1] / OP3 (Signed)

OP1 = [OP2:OP1] % OP3 (Signed)

Popcnt(Operand)

OP1 = popcnt OP1

Bsf(Operand)

OP1 = OP1 ? BitScanForward OP1 + 1 : 0

Bsr(Operand)

OP1 = OP1 ? BitScanReverse OP1 + 1 : 0

Not(Operand)

OP1 = ~OP1

OP1 >>= OP2

OP1 <<= OP2

OP1 ^= OP2

OP1 |= OP2

OP1 &= OP2

OP1 = (OP1>>OP2) | (OP1<<(N-OP2))

OP1 = (OP1<<OP2) | (OP1>>(N-OP2))

OP1 = OP2 > OP3

OP1 = OP2 >= OP3

OP1 = OP2 == OP3

OP1 = OP2 != OP3

OP1 = OP2 < OP3

OP1 = OP2 <= OP3

OP1 = OP2 <= OP3

OP1 = OP2 u>= OP3

OP1 = OP2 u< OP3

OP1 = OP2 u<= OP3

OP1 = OP2 ? OP3 : 0

Jumps to OP1 ? OP2 : OP3, continues virtual execution

Jmp(Operand)

Jumps to OP1, continues virtual execution

Vexit(Operand)

Jumps to OP1, continues real execution

Vxcall(Operand)

Calls into OP1, pauses virtual execution until the call returns

Nop

Placeholder

Sfence

Assumes all memory is read from

Lfence

Assumes all memory is written to

Vemit(Operand)

Emits the opcode as is to the final instruction stream

Vpinr(Operand)

Pins the register for read

Vpinw(Operand)

Pins the register for write

Vpinrm(Operand, Operand, Operand)

Pins the memory location for read, with size = OP3

Vpinwm(Operand, Operand, Operand)

Pins the memory location for write, with size = OP3

Implementations

impl Op[src]

pub fn name(&self) -> &'static str[src]

Name of the operand

pub fn operands(&self) -> Vec<&Operand>[src]

Operands for operator

pub fn operands_mut(&mut self) -> Vec<&mut Operand>[src]

Mutable operands for operator

pub fn is_volatile(&self) -> bool[src]

Returns if the instruction is volatile

Trait Implementations

impl Debug for Op[src]

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

Formats the value using the given formatter. Read more

impl SizeWith<Op> for Op[src]

fn size_with(op: &Op) -> usize[src]

impl<'a> TryFromCtx<'a, Endian, [u8]> for Op[src]

type Error = Error

fn try_from_ctx(source: &'a [u8], endian: Endian) -> Result<(Self, usize)>[src]

impl TryIntoCtx<Endian, [u8]> for Op[src]

type Error = Error

fn try_into_ctx(self, sink: &mut [u8], _endian: Endian) -> Result<usize>[src]

Auto Trait Implementations

impl RefUnwindSafe for Op

impl Send for Op

impl Sync for Op

impl Unpin for Op

impl UnwindSafe for Op

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>, [src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]

Performs the conversion.