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 store_with_annotation_and_flags<Bx: BuilderMethods<'a, 'tcx, Value = V>>( self, bx: &mut Bx, dest: PlaceRef<'tcx, V>, flags: MemFlags, )

Same as store_with_annotation(), but also specify flags for the store.

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.

Note: The use of this is discouraged outside cg_llvm, as some other backends don’t natively support packing multiple things into one like this.

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.

Note: The use of this is discouraged outside cg_llvm, as some other backends don’t natively support packing multiple things into one like this.

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<'tcx, V: Copy> Copy for OperandRef<'tcx, V>

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

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

Formats the value using the given formatter.

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.