Struct fuel_vm::prelude::Instruction

pub struct Instruction { /* private fields */ }

A version of Opcode that can used without unnecessary branching

Implementations

impl Instruction

pub const LEN: usize = 4usize

Size of an opcode in bytes

pub const fn new(instruction: u32) -> Instruction

Extracts fields from a raw instruction

pub const fn op(&self) -> u8

Opcode

pub const fn ra(&self) -> usize

Register A

pub const fn rb(&self) -> usize

Register B

pub const fn rc(&self) -> usize

Register C

pub const fn rd(&self) -> usize

Register D

pub const fn imm06(&self) -> u8

Immediate with 6 bits

pub const fn imm12(&self) -> u16

Immediate with 12 bits

pub const fn imm18(&self) -> u32

Immediate with 18 bits

pub const fn imm24(&self) -> u32

Immediate with 24 bits

pub unsafe fn from_slice_unchecked(buf: &[u8]) -> Instruction

Create a Instruction from a slice of bytes

Safety

The caller must ensure that the slice is has at least Self::LEN bytes.

pub fn to_bytes(self) -> [u8; 4]

Convert the opcode to bytes representation

pub const fn parse_word(word: u64) -> (Instruction, Instruction)

Splits a Word into two Instruction that can be used to construct crate::Opcode

pub const fn into_inner(self) -> (OpcodeRepr, usize, usize, usize, usize, u64)

Convert the instruction into its internal representation

(repr, $ra, $rb, $rc, $rd, immediate)

impl Instruction

pub fn from_bytes(bytes: &[u8]) -> Result<Instruction, Error>

Create a Instruction from a slice of bytes

This function will fail if the length of the bytes is smaller than Instruction::LEN.

pub fn from_bytes_iter<I>(bytes: I) -> Vec<Instruction, Global> where
    I: IntoIterator<Item = u8>, 

Create a set of Instruction from an iterator of bytes

If not padded to Self::LEN, will consume the unaligned bytes but won’t try to parse an instruction from them.

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Default for Instruction

fn default() -> Instruction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Instruction

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

Deserialize this value from the given Serde deserializer.

impl From<[u8; 4]> for Instruction

fn from(instruction: [u8; 4]) -> Instruction

Converts to this type from the input type.

impl From<Instruction> for Opcode

fn from(parsed: Instruction) -> Opcode

Converts to this type from the input type.

impl From<InstructionResult> for Instruction

fn from(r: InstructionResult) -> Instruction

Converts to this type from the input type.

impl From<Opcode> for Instruction

fn from(op: Opcode) -> Instruction

Converts to this type from the input type.

impl From<u32> for Instruction

fn from(instruction: u32) -> Instruction

Converts to this type from the input type.

impl Hash for Instruction

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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 PartialEq<Instruction> for Instruction

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

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

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

This method tests for !=.

impl Serialize for Instruction

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

Serialize this value into the given Serde serializer.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralEq for Instruction

impl StructuralPartialEq for Instruction