Struct OperandRef 

pub struct OperandRef<'tcx, V> {
    pub val: OperandValue<V>,
    pub layout: TyAndLayout<'tcx>,
    pub move_annotation: Option<Instance<'tcx>>,
}

An OperandRef is an “SSA” reference to a Rust value, along with its type.

NOTE: unless you know a value’s type exactly, you should not generate LLVM opcodes acting on it and instead act via methods, to avoid nasty edge cases. In particular, using Builder::store directly is sure to cause problems – use OperandRef::store instead.

Fields

val: OperandValue<V>

The value.

layout: TyAndLayout<'tcx>

The layout of value, based on its Rust type.

move_annotation: Option<Instance<'tcx>>

Annotation for profiler visibility of move/copy operations. When set, the store operation should appear as an inlined call to this function.

Implementations

impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V>

pub fn zero_sized(layout: TyAndLayout<'tcx>) -> OperandRef<'tcx, V>

pub(crate) fn from_const<Bx: BuilderMethods<'a, 'tcx, Value = V>>( bx: &mut Bx, val: ConstValue, ty: Ty<'tcx>, ) -> Self

fn from_const_alloc<Bx: BuilderMethods<'a, 'tcx, Value = V>>( bx: &mut Bx, layout: TyAndLayout<'tcx>, alloc: ConstAllocation<'tcx>, offset: Size, ) -> Self

pub fn immediate(self) -> V

Asserts that this operand refers to a scalar and returns a reference to its value.

pub fn deref<Cx: CodegenMethods<'tcx>>(self, cx: &Cx) -> PlaceRef<'tcx, V>

Asserts that this operand is a pointer (or reference) and returns the place to which it points. (This requires no code to be emitted as we represent places using the pointer to the place.)

This uses Ty::builtin_deref to include the type of the place and assumes the place is aligned to the pointee’s usual ABI alignment.

If you don’t need the type, see OperandValue::pointer_parts or OperandValue::deref.

pub fn store_with_annotation<Bx: BuilderMethods<'a, 'tcx, Value = V>>( self, bx: &mut Bx, dest: PlaceRef<'tcx, V>, )

Store this operand into a place, applying move/copy annotation if present.

This is the preferred method for storing operands, as it automatically applies profiler annotations for tracked move/copy operations.

pub fn immediate_or_packed_pair<Bx: BuilderMethods<'a, 'tcx, Value = V>>( self, bx: &mut Bx, ) -> V

If this operand is a Pair, we return an aggregate with the two values. For other cases, see immediate.

pub fn from_immediate_or_packed_pair<Bx: BuilderMethods<'a, 'tcx, Value = V>>( bx: &mut Bx, llval: V, layout: TyAndLayout<'tcx>, ) -> Self

If the type is a pair, we return a Pair, otherwise, an Immediate.

pub(crate) fn extract_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>( &self, fx: &mut FunctionCx<'a, 'tcx, Bx>, bx: &mut Bx, i: usize, ) -> Self

pub fn codegen_get_discr<Bx: BuilderMethods<'a, 'tcx, Value = V>>( self, fx: &mut FunctionCx<'a, 'tcx, Bx>, bx: &mut Bx, cast_to: Ty<'tcx>, ) -> V

Obtain the actual discriminant of a value.

Trait Implementations

impl<'tcx, V: Clone> Clone for OperandRef<'tcx, V>

fn clone(&self) -> OperandRef<'tcx, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: CodegenObject> Debug for OperandRef<'_, V>

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

Formats the value using the given formatter.

impl<'tcx, V: Copy> Copy for OperandRef<'tcx, V>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.