Enum Operand 

pub enum Operand<'ctx> {
    Value(BasicValueEnum<'ctx>),
    Block(BasicBlock<'ctx>),
}

Either BasicValueEnum or BasicBlock.

Variants

Value(BasicValueEnum<'ctx>)

Represents a BasicValueEnum.

Block(BasicBlock<'ctx>)

Represents a BasicBlock.

Implementations

impl<'ctx> Operand<'ctx>

pub fn is_value(self) -> bool

Determines if the Operand is a BasicValueEnum.

pub fn is_block(self) -> bool

Determines if the Operand is a BasicBlock.

pub fn value(self) -> Option<BasicValueEnum<'ctx>>

If the Operand is a BasicValueEnum, map it into Option::Some.

pub fn block(self) -> Option<BasicBlock<'ctx>>

If the Operand is a BasicBlock, map it into Option::Some.

pub fn expect_value(self, msg: &str) -> BasicValueEnum<'ctx>

Expect BasicValueEnum, panic with the message if it is not.

pub fn expect_block(self, msg: &str) -> BasicBlock<'ctx>

Expect BasicBlock, panic with the message if it is not.

pub fn unwrap_value(self) -> BasicValueEnum<'ctx>

Unwrap BasicValueEnum. Will panic if it is not.

pub fn unwrap_block(self) -> BasicBlock<'ctx>

Unwrap BasicBlock. Will panic if it is not.

Trait Implementations

impl<'ctx> Clone for Operand<'ctx>

fn clone(&self) -> Operand<'ctx>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'ctx> Debug for Operand<'ctx>

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

Formats the value using the given formatter.

impl<'ctx> Hash for Operand<'ctx>

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<'ctx> PartialEq for Operand<'ctx>

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

impl<'ctx> Eq for Operand<'ctx>

impl<'ctx> StructuralPartialEq for Operand<'ctx>