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,
    },
    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

Takes the value from the source address, inverts it, and stores the value in the destination address.

Fields

destination: MemoryAddress

source: MemoryAddress

bit_size: IntegerBitSize

Cast

Takes the value from the source address, casts it into the type indicated by bit_size, and stores the value in the destination address.

Fields

destination: MemoryAddress

source: MemoryAddress

bit_size: BitSize

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_address with length indicated by size_address to the specified destination_address.

Fields

destination_address: MemoryAddress

size_address: MemoryAddress

offset_address: MemoryAddress

Call

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

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

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, intended for things like state tree reads; it 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).

Output vectors are passed as a ValueOrArray::MemoryAddress. Since their size is not known up front, we cannot allocate space for them on the heap. Instead, the VM is expected to write their data after the current free memory pointer, and store the heap address into the destination.

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

If the value at condition is non-zero, moves the content in the source_a address to the destination address, otherwise moves the content from the source_b address instead.

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

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

Formats the value using the given formatter.

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>