# [−] [src] Enum parity_wasm::elements::Instruction

    pub enum Instruction {
        Unreachable,
        Nop,
        Block(BlockType),
        Loop(BlockType),
        If(BlockType),
        Else,
        End,
        Br(u32),
        BrIf(u32),
        BrTable(Box<BrTableData>),
        Return,
        Call(u32),
        CallIndirect(u32, u8),
        Drop,
        Select,
        GetLocal(u32),
        SetLocal(u32),
        TeeLocal(u32),
        GetGlobal(u32),
        SetGlobal(u32),
        I32Load(u32, u32),
        I64Load(u32, u32),
        F32Load(u32, u32),
        F64Load(u32, u32),
        I32Load8S(u32, u32),
        I32Load8U(u32, u32),
        I32Load16S(u32, u32),
        I32Load16U(u32, u32),
        I64Load8S(u32, u32),
        I64Load8U(u32, u32),
        I64Load16S(u32, u32),
        I64Load16U(u32, u32),
        I64Load32S(u32, u32),
        I64Load32U(u32, u32),
        I32Store(u32, u32),
        I64Store(u32, u32),
        F32Store(u32, u32),
        F64Store(u32, u32),
        I32Store8(u32, u32),
        I32Store16(u32, u32),
        I64Store8(u32, u32),
        I64Store16(u32, u32),
        I64Store32(u32, u32),
        CurrentMemory(u8),
        GrowMemory(u8),
        I32Const(i32),
        I64Const(i64),
        F32Const(u32),
        F64Const(u64),
        I32Eqz,
        I32Eq,
        I32Ne,
        I32LtS,
        I32LtU,
        I32GtS,
        I32GtU,
        I32LeS,
        I32LeU,
        I32GeS,
        I32GeU,
        I64Eqz,
        I64Eq,
        I64Ne,
        I64LtS,
        I64LtU,
        I64GtS,
        I64GtU,
        I64LeS,
        I64LeU,
        I64GeS,
        I64GeU,
        F32Eq,
        F32Ne,
        F32Lt,
        F32Gt,
        F32Le,
        F32Ge,
        F64Eq,
        F64Ne,
        F64Lt,
        F64Gt,
        F64Le,
        F64Ge,
        I32Clz,
        I32Ctz,
        I32Popcnt,
        I32Add,
        I32Sub,
        I32Mul,
        I32DivS,
        I32DivU,
        I32RemS,
        I32RemU,
        I32And,
        I32Or,
        I32Xor,
        I32Shl,
        I32ShrS,
        I32ShrU,
        I32Rotl,
        I32Rotr,
        I64Clz,
        I64Ctz,
        I64Popcnt,
        I64Add,
        I64Sub,
        I64Mul,
        I64DivS,
        I64DivU,
        I64RemS,
        I64RemU,
        I64And,
        I64Or,
        I64Xor,
        I64Shl,
        I64ShrS,
        I64ShrU,
        I64Rotl,
        I64Rotr,
        F32Abs,
        F32Neg,
        F32Ceil,
        F32Floor,
        F32Trunc,
        F32Nearest,
        F32Sqrt,
        F32Add,
        F32Sub,
        F32Mul,
        F32Div,
        F32Min,
        F32Max,
        F32Copysign,
        F64Abs,
        F64Neg,
        F64Ceil,
        F64Floor,
        F64Trunc,
        F64Nearest,
        F64Sqrt,
        F64Add,
        F64Sub,
        F64Mul,
        F64Div,
        F64Min,
        F64Max,
        F64Copysign,
        I32WrapI64,
        I32TruncSF32,
        I32TruncUF32,
        I32TruncSF64,
        I32TruncUF64,
        I64ExtendSI32,
        I64ExtendUI32,
        I64TruncSF32,
        I64TruncUF32,
        I64TruncSF64,
        I64TruncUF64,
        F32ConvertSI32,
        F32ConvertUI32,
        F32ConvertSI64,
        F32ConvertUI64,
        F32DemoteF64,
        F64ConvertSI32,
        F64ConvertUI32,
        F64ConvertSI64,
        F64ConvertUI64,
        F64PromoteF32,
        I32ReinterpretF32,
        I64ReinterpretF64,
        F32ReinterpretI32,
        F64ReinterpretI64,
    }

Instruction.

## Variants

`Unreachable`
`Nop`
`Block(BlockType)`
`Loop(BlockType)`
`If(BlockType)`
`Else`
`End`
`Br(u32)`
`BrIf(u32)`
`BrTable(Box<BrTableData>)`
`Return`
`Call(u32)`
`CallIndirect(u32, u8)`
`Drop`
`Select`
`GetLocal(u32)`
`SetLocal(u32)`
`TeeLocal(u32)`
`GetGlobal(u32)`
`SetGlobal(u32)`
`I32Load(u32, u32)`
`I64Load(u32, u32)`
`F32Load(u32, u32)`
`F64Load(u32, u32)`
`I32Load8S(u32, u32)`
`I32Load8U(u32, u32)`
`I32Load16S(u32, u32)`
`I32Load16U(u32, u32)`
`I64Load8S(u32, u32)`
`I64Load8U(u32, u32)`
`I64Load16S(u32, u32)`
`I64Load16U(u32, u32)`
`I64Load32S(u32, u32)`
`I64Load32U(u32, u32)`
`I32Store(u32, u32)`
`I64Store(u32, u32)`
`F32Store(u32, u32)`
`F64Store(u32, u32)`
`I32Store8(u32, u32)`
`I32Store16(u32, u32)`
`I64Store8(u32, u32)`
`I64Store16(u32, u32)`
`I64Store32(u32, u32)`
`CurrentMemory(u8)`
`GrowMemory(u8)`
`I32Const(i32)`
`I64Const(i64)`
`F32Const(u32)`
`F64Const(u64)`
`I32Eqz`
`I32Eq`
`I32Ne`
`I32LtS`
`I32LtU`
`I32GtS`
`I32GtU`
`I32LeS`
`I32LeU`
`I32GeS`
`I32GeU`
`I64Eqz`
`I64Eq`
`I64Ne`
`I64LtS`
`I64LtU`
`I64GtS`
`I64GtU`
`I64LeS`
`I64LeU`
`I64GeS`
`I64GeU`
`F32Eq`
`F32Ne`
`F32Lt`
`F32Gt`
`F32Le`
`F32Ge`
`F64Eq`
`F64Ne`
`F64Lt`
`F64Gt`
`F64Le`
`F64Ge`
`I32Clz`
`I32Ctz`
`I32Popcnt`
`I32Add`
`I32Sub`
`I32Mul`
`I32DivS`
`I32DivU`
`I32RemS`
`I32RemU`
`I32And`
`I32Or`
`I32Xor`
`I32Shl`
`I32ShrS`
`I32ShrU`
`I32Rotl`
`I32Rotr`
`I64Clz`
`I64Ctz`
`I64Popcnt`
`I64Add`
`I64Sub`
`I64Mul`
`I64DivS`
`I64DivU`
`I64RemS`
`I64RemU`
`I64And`
`I64Or`
`I64Xor`
`I64Shl`
`I64ShrS`
`I64ShrU`
`I64Rotl`
`I64Rotr`
`F32Abs`
`F32Neg`
`F32Ceil`
`F32Floor`
`F32Trunc`
`F32Nearest`
`F32Sqrt`
`F32Add`
`F32Sub`
`F32Mul`
`F32Div`
`F32Min`
`F32Max`
`F32Copysign`
`F64Abs`
`F64Neg`
`F64Ceil`
`F64Floor`
`F64Trunc`
`F64Nearest`
`F64Sqrt`
`F64Add`
`F64Sub`
`F64Mul`
`F64Div`
`F64Min`
`F64Max`
`F64Copysign`
`I32WrapI64`
`I32TruncSF32`
`I32TruncUF32`
`I32TruncSF64`
`I32TruncUF64`
`I64ExtendSI32`
`I64ExtendUI32`
`I64TruncSF32`
`I64TruncUF32`
`I64TruncSF64`
`I64TruncUF64`
`F32ConvertSI32`
`F32ConvertUI32`
`F32ConvertSI64`
`F32ConvertUI64`
`F32DemoteF64`
`F64ConvertSI32`
`F64ConvertUI32`
`F64ConvertSI64`
`F64ConvertUI64`
`F64PromoteF32`
`I32ReinterpretF32`
`I64ReinterpretF64`
`F32ReinterpretI32`
`F64ReinterpretI64`

## Methods

### `impl Instruction` [src]

#### `pub fn is_block(&self) -> bool` [src]

Is this instruction starts the new block (which should end with terminal instruction).

#### `pub fn is_terminal(&self) -> bool` [src]

Is this instruction determines the termination of instruction sequence?

`true` for `Instruction::End`

## Trait Implementations

### `impl Deserialize for Instruction` [src]

#### `type Error = Error`

Serialization error produced by deserialization routine.

#### `fn deserialize<R: Read>(reader: &mut R) -> Result<Self, Self::Error>` [src]

Deserialize type from serial i/o

### `impl Serialize for Instruction` [src]

#### `type Error = Error`

Serialization error produced by serialization routine.

#### `fn serialize<W: Write>(self, writer: &mut W) -> Result<(), Self::Error>` [src]

Serialize type to serial i/o

### `impl Clone for Instruction` [src]

#### `fn clone(&self) -> Instruction` [src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl Eq for Instruction` [src]

### `impl PartialEq<Instruction> for Instruction` [src]

#### `fn eq(&self, other: &Instruction) -> bool` [src]

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

#### `fn ne(&self, other: &Instruction) -> bool` [src]

This method tests for `!=`.

### `impl Display for Instruction` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Debug for Instruction` [src]

#### `fn fmt(&self, f: &mut Formatter) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl Hash for Instruction` [src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)` [src]

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

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

## Auto Trait Implementations

### `impl Send for Instruction`

### `impl Sync for Instruction`

### `impl Unpin for Instruction`

### `impl UnwindSafe for Instruction`

### `impl RefUnwindSafe for Instruction`

## Blanket Implementations

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

#### `fn into(self) -> U` [src]

Performs the conversion.

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

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

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)` [src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

### `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.

#### `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.

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

Performs the conversion.

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

####
ⓘImportant traits for &'_ mut R

### Important traits for &'_ mut R

`impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

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

####
ⓘImportant traits for &'_ mut R

### Important traits for &'_ mut R

`impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`
`fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

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

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

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)