Enum hir_ty::mir::Operand

pub enum Operand {
    Copy(Place),
    Move(Place),
    Constant(Const),
    Static(StaticId),
}

An operand in MIR represents a “value” in Rust, the definition of which is undecided and part of the memory model. One proposal for a definition of values can be found on UCG.

The most common way to create values is via loading a place. Loading a place is an operation which reads the memory of the place and converts it to a value. This is a fundamentally typed operation. The nature of the value produced depends on the type of the conversion. Furthermore, there may be other effects: if the type has a validity constraint loading the place might be UB if the validity constraint is not met.

Needs clarification: Ralf proposes that loading a place not have side-effects. This is what is implemented in miri today. Are these the semantics we want for MIR? Is this something we can even decide without knowing more about Rust’s memory model?

Needs clarification: Is loading a place that has its variant index set well-formed? Miri currently implements it, but it seems like this may be something to check against in the validator.

Variants

Copy(Place)

Creates a value by loading the given place.

Before drop elaboration, the type of the place must be Copy. After drop elaboration there is no such requirement.

Move(Place)

Creates a value by performing loading the place, just like the Copy operand.

This may additionally overwrite the place with uninit bytes, depending on how we decide in UCG#188. You should not emit MIR that may attempt a subsequent second load of this place without first re-initializing it.

Constant(Const)

Constants are already semantically values, and remain unchanged.

Static(StaticId)

NON STANDARD: This kind of operand returns an immutable reference to that static memory. Rustc handles it with the Constant variant somehow.

Trait Implementations

impl Clone for Operand

fn clone(&self) -> Operand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Operand

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

Formats the value using the given formatter.

impl From<Operand> for Rvalue

fn from(x: Operand) -> Self

Converts to this type from the input type.

impl PartialEq for Operand

fn eq(&self, other: &Operand) -> 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 Eq for Operand

impl StructuralPartialEq for Operand