Struct rustc_codegen_ssa::mir::operand::OperandRef

pub struct OperandRef<'tcx, V> {
    pub val: OperandValue<V>,
    pub layout: TyAndLayout<'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>

layout: TyAndLayout<'tcx>

Implementations

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

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

pub fn from_const<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
    bx: &mut Bx,
    val: ConstValue<'tcx>,
    ty: Ty<'tcx>
) -> 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: LayoutTypeMethods<'tcx>>(self, cx: &Cx) -> PlaceRef<'tcx, V>

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 fn extract_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
    &self,
    bx: &mut Bx,
    i: usize
) -> Self

Trait Implementations

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

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

Returns a copy 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.