Enum BrilligOpcode

pub enum BrilligOpcode<F> {
    BinaryFieldOp {
        destination: MemoryAddress,
        op: BinaryFieldOp,
        lhs: MemoryAddress,
        rhs: MemoryAddress,
    },
    BinaryIntOp {
        destination: MemoryAddress,
        op: BinaryIntOp,
        bit_size: IntegerBitSize,
        lhs: MemoryAddress,
        rhs: MemoryAddress,
    },
    Not {
        destination: MemoryAddress,
        source: MemoryAddress,
        bit_size: IntegerBitSize,
    },
    Cast {
        destination: MemoryAddress,
        source: MemoryAddress,
        bit_size: BitSize,
    },
    JumpIfNot {
        condition: MemoryAddress,
        location: Label,
    },
    JumpIf {
        condition: MemoryAddress,
        location: Label,
    },
    Jump {
        location: Label,
    },
    CalldataCopy {
        destination_address: MemoryAddress,
        size_address: MemoryAddress,
        offset_address: MemoryAddress,
    },
    Call {
        location: Label,
    },
    Const {
        destination: MemoryAddress,
        bit_size: BitSize,
        value: F,
    },
    IndirectConst {
        destination_pointer: MemoryAddress,
        bit_size: BitSize,
        value: F,
    },
    Return,
    ForeignCall {
        function: String,
        destinations: Vec<ValueOrArray>,
        destination_value_types: Vec<HeapValueType>,
        inputs: Vec<ValueOrArray>,
        input_value_types: Vec<HeapValueType>,
    },
    Mov {
        destination: MemoryAddress,
        source: MemoryAddress,
    },
    ConditionalMov {
        destination: MemoryAddress,
        source_a: MemoryAddress,
        source_b: MemoryAddress,
        condition: MemoryAddress,
    },
    Load {
        destination: MemoryAddress,
        source_pointer: MemoryAddress,
    },
    Store {
        destination_pointer: MemoryAddress,
        source: MemoryAddress,
    },
    BlackBox(BlackBoxOp),
    Trap {
        revert_data: HeapVector,
    },
    Stop {
        return_data: HeapVector,
    },
}

Variants

BinaryFieldOp

Takes the fields in addresses lhs and rhs Performs the specified binary operation and stores the value in the destination address.

Fields

destination: MemoryAddress

op: BinaryFieldOp

lhs: MemoryAddress

rhs: MemoryAddress

BinaryIntOp

Takes the bit_size size integers in addresses lhs and rhs Performs the specified binary operation and stores the value in the destination address.

Fields

destination: MemoryAddress

op: BinaryIntOp

bit_size: IntegerBitSize

lhs: MemoryAddress

rhs: MemoryAddress

Not

Fields

destination: MemoryAddress

source: MemoryAddress

bit_size: IntegerBitSize

Cast

Fields

destination: MemoryAddress

source: MemoryAddress

bit_size: BitSize

JumpIfNot

Sets the program counter to the value of location if the value at the condition address is zero.

Fields

condition: MemoryAddress

location: Label

JumpIf

Sets the program counter to the value of location If the value at condition is non-zero

Fields

condition: MemoryAddress

location: Label

Jump

Sets the program counter to the value of location.

Fields

location: Label

CalldataCopy

Copies calldata after the offset to the specified address and length

Fields

destination_address: MemoryAddress

size_address: MemoryAddress

offset_address: MemoryAddress

Call

We don’t support dynamic jumps or calls See https://github.com/ethereum/aleth/issues/3404 for reasoning

Pushes the current program counter to the call stack as to set a return location. Sets the program counter to the value of location.

Fields

location: Label

Const

Stores a constant value with a bit_size in the destination address.

Fields

destination: MemoryAddress

bit_size: BitSize

value: F

IndirectConst

Reads the address from destination_pointer, then stores a constant value with a bit_size at that address.

Fields

destination_pointer: MemoryAddress

bit_size: BitSize

value: F

Return

Pops the top element from the call stack, which represents the return location, and sets the program counter to that value. This operation is used to return from a function call.

ForeignCall

Used to get data from an outside source. Also referred to as an Oracle. However, we don’t use that name as this is intended for things like state tree reads, and shouldn’t be confused with e.g. blockchain price oracles.

Fields

function: String

Interpreted by caller context, ie this will have different meanings depending on who the caller is.

destinations: Vec<ValueOrArray>

Destination addresses (may be single values or memory pointers).

destination_value_types: Vec<HeapValueType>

Destination value types

inputs: Vec<ValueOrArray>

Input addresses (may be single values or memory pointers).

input_value_types: Vec<HeapValueType>

Input value types (for heap allocated structures indicates how to retrieve the elements)

Mov

Moves the content in the source address to the destination address.

Fields

destination: MemoryAddress

source: MemoryAddress

ConditionalMov

destination = condition > 0 ? source_a : source_b

Fields

destination: MemoryAddress

source_a: MemoryAddress

source_b: MemoryAddress

condition: MemoryAddress

Load

Reads the source_pointer to obtain a memory address, then retrieves the data stored at that address and writes it to the destination address.

Fields

destination: MemoryAddress

source_pointer: MemoryAddress

Store

Reads the destination_pointer to obtain a memory address, then stores the value from the source address at that location.

Fields

destination_pointer: MemoryAddress

source: MemoryAddress

BlackBox(BlackBoxOp)

Native functions in the VM. These are equivalent to the black box functions in ACIR.

Trap

Used to denote execution failure, halting the VM and returning data specified by a dynamically-sized vector.

Fields

revert_data: HeapVector

Stop

Halts execution and returns data specified by a dynamically-sized vector.

Fields

return_data: HeapVector

Trait Implementations

impl<F: Clone> Clone for BrilligOpcode<F>

fn clone(&self) -> BrilligOpcode<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for BrilligOpcode<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for BrilligOpcode<F>

where F: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: Hash> Hash for BrilligOpcode<F>

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<F: PartialEq> PartialEq for BrilligOpcode<F>

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

where F: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Eq> Eq for BrilligOpcode<F>

impl<F> StructuralPartialEq for BrilligOpcode<F>