Enum Terminator 

pub enum Terminator {
    Goto(BbName),
    Switch {
        value: ValueExpr,
        cases: Map<Int, BbName>,
        fallback: BbName,
    },
    Unreachable,
    Intrinsic {
        intrinsic: IntrinsicOp,
        arguments: List<ValueExpr>,
        ret: PlaceExpr,
        next_block: Option<BbName>,
    },
    Call {
        callee: ValueExpr,
        calling_convention: CallingConvention,
        arguments: List<ArgumentExpr>,
        ret: PlaceExpr,
        next_block: Option<BbName>,
        unwind_block: Option<BbName>,
    },
    Return,
    StartUnwind {
        unwind_payload: ValueExpr,
        unwind_block: BbName,
    },
    StopUnwind(BbName),
    ResumeUnwind,
}

Variants

Goto(BbName)

Just jump to the next block.

Switch

value needs to evaluate to a Value::Int. cases map those values to blocks to jump to and therefore have to have the equivalent type. If no value matches we fall back to the block given in fallback.

Fields

value: ValueExpr

cases: Map<Int, BbName>

fallback: BbName

Unreachable

If this is ever executed, we have UB.

Intrinsic

Invoke the given intrinsic operation with the given arguments.

Intrinsics are langauge primitives that can have arbitrary side-effects, including divergence.

Fields

intrinsic: IntrinsicOp

arguments: List<ValueExpr>

The arguments to pass.

ret: PlaceExpr

The place to put the return value into.

next_block: Option<BbName>

The block to jump to when this call returns. If None, UB will be raised when the intrinsic returns.

Call

Call the given function with the given arguments.

Fields

callee: ValueExpr

What function or method to call. This must evaluate to a function pointer and for safe behaviour, the functions signature must match the arguments.

Dynamic dispatch is represented with the callee being the result of VTableMethodLookup(GetMetadata(self)), and the self argument appropriately cast to a thin pointer type.

calling_convention: CallingConvention

The calling convention to use for this call.

arguments: List<ArgumentExpr>

The arguments to pass.

ret: PlaceExpr

The place to put the return value into.

next_block: Option<BbName>

The block to jump to when this call returns. If None, UB will be raised when the function returns.

unwind_block: Option<BbName>

The block to jump to when this call unwinds. If None, UB will be raised when the function unwinds. This comes with a well-formedness requirement: if the current block is a regular block, unwind_block must be either a cleanup block or a catch block; otherwise, unwind_block must be a terminating block.

Return

Return from the current function.

StartUnwind

Starts unwinding, jump to the indicated cleanup block.

Fields

unwind_payload: ValueExpr

The unwinding payload. This should evaluate to a thin pointer.

unwind_block: BbName

The cleanup or catch block the execution jumps to.

StopUnwind(BbName)

Stops unwinding, jump to the indicated regular block. This also removes the topmost unwinding payload. UB if not currently unwinding.

ResumeUnwind

Ends this function call. The unwinding should continue at the caller’s stack frame.

Trait Implementations

impl Clone for Terminator

fn clone(&self) -> Terminator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Terminator

impl Debug for Terminator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Terminator

fn deserialize<__D>( __deserializer: __D, ) -> Result<Terminator, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Terminator

impl Hash for Terminator

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 Ord for Terminator

fn cmp(&self, other: &Terminator) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Terminator

fn eq(&self, other: &Terminator) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Terminator

fn partial_cmp(&self, other: &Terminator) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Terminator

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Terminator