Enum Terminator 

pub enum Terminator {
    Return(Option<Value>),
    Jump(Block, Vec<Value>),
    Branch {
        cond: Value,
        then_block: Block,
        then_args: Vec<Value>,
        else_block: Block,
        else_args: Vec<Value>,
    },
}

The single instruction that ends a basic block and transfers control.

Exactly one terminator ends every block. A Jump or the two arms of a Branch carry an argument per parameter of the target block — that is how a value is threaded across a control-flow join in SSA form, in place of a phi node. A Return leaves the function.

Examples

use ir_lang::{Builder, Type, Terminator};

let mut b = Builder::new("f", &[], Type::Unit);
b.ret(None);
let func = b.finish();
assert!(matches!(func.terminator(func.entry()), Some(Terminator::Return(None))));

Variants

Return(Option<Value>)

Return from the function, optionally with a value. Some(v) returns v, whose type must match the function’s return type; None returns from a function whose return type is Unit.

Jump(Block, Vec<Value>)

Jump unconditionally to a block, passing one argument per target parameter.

Branch

Branch on a Bool condition: take the first block (and its arguments) when the condition is true, the second otherwise. Each block’s arguments are matched against that block’s parameters.

Fields

cond: Value

The boolean condition selecting which arm runs.

then_block: Block

The block taken when cond is true.

then_args: Vec<Value>

Arguments passed to then_block’s parameters.

else_block: Block

The block taken when cond is false.

else_args: Vec<Value>

Arguments passed to else_block’s parameters.

Implementations

impl Terminator

pub fn each_successor(&self, f: impl FnMut(Block))

Calls f once for each block this terminator can transfer control to, in order. A Return calls f zero times.

This is how the control-flow graph is read: the successors of a block are the targets of its terminator.

Examples

use ir_lang::{Builder, Type};

let mut b = Builder::new("f", &[], Type::Unit);
let exit = b.create_block(&[]);
b.jump(exit, &[]);
b.switch_to(exit);
b.ret(None);
let func = b.finish();

let mut succs = Vec::new();
if let Some(term) = func.terminator(func.entry()) {
    term.each_successor(|blk| succs.push(blk));
}
assert_eq!(succs, vec![exit]);

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

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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Terminator

fn eq(&self, other: &Terminator) -> 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 Serialize for Terminator

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Terminator