Enum rustc_middle::mir::terminator::TerminatorKind

pub enum TerminatorKind<'tcx> {
    Goto {
        target: BasicBlock,
    },
    SwitchInt {
        discr: Operand<'tcx>,
        switch_ty: Ty<'tcx>,
        targets: SwitchTargets,
    },
    Resume,
    Abort,
    Return,
    Unreachable,
    Drop {
        place: Place<'tcx>,
        target: BasicBlock,
        unwind: Option<BasicBlock>,
    },
    DropAndReplace {
        place: Place<'tcx>,
        value: Operand<'tcx>,
        target: BasicBlock,
        unwind: Option<BasicBlock>,
    },
    Call {
        func: Operand<'tcx>,
        args: Vec<Operand<'tcx>>,
        destination: Option<(Place<'tcx>, BasicBlock)>,
        cleanup: Option<BasicBlock>,
        from_hir_call: bool,
        fn_span: Span,
    },
    Assert {
        cond: Operand<'tcx>,
        expected: bool,
        msg: AssertMessage<'tcx>,
        target: BasicBlock,
        cleanup: Option<BasicBlock>,
    },
    Yield {
        value: Operand<'tcx>,
        resume: BasicBlock,
        resume_arg: Place<'tcx>,
        drop: Option<BasicBlock>,
    },
    GeneratorDrop,
    FalseEdge {
        real_target: BasicBlock,
        imaginary_target: BasicBlock,
    },
    FalseUnwind {
        real_target: BasicBlock,
        unwind: Option<BasicBlock>,
    },
    InlineAsm {
        template: &'tcx [InlineAsmTemplatePiece],
        operands: Vec<InlineAsmOperand<'tcx>>,
        options: InlineAsmOptions,
        line_spans: &'tcx [Span],
        destination: Option<BasicBlock>,
    },
}

Variants

Goto

Block should have one successor in the graph; we jump there.

Fields of Goto

target: BasicBlock

SwitchInt

Operand evaluates to an integer; jump depending on its value to one of the targets, and otherwise fallback to otherwise.

Fields of SwitchInt

discr: Operand<'tcx>

The discriminant value being tested.

switch_ty: Ty<'tcx>

The type of value being tested. This is always the same as the type of discr. FIXME: remove this redundant information. Currently, it is relied on by pretty-printing.

targets: SwitchTargets

Resume

Indicates that the landing pad is finished and unwinding should continue. Emitted by build::scope::diverge_cleanup.

Abort

Indicates that the landing pad is finished and that the process should abort. Used to prevent unwinding for foreign items.

Return

Indicates a normal return. The return place should have been filled in before this executes. This can occur multiple times in different basic blocks.

Unreachable

Indicates a terminator that can never be reached.

Drop

Drop the Place.

Fields of Drop

place: Place<'tcx>target: BasicBlockunwind: Option<BasicBlock>

DropAndReplace

Drop the Place and assign the new value over it. This ensures that the assignment to P occurs even if the destructor for place unwinds. Its semantics are best explained by the elaboration:

BB0 {
  DropAndReplace(P <- V, goto BB1, unwind BB2)
}

becomes

BB0 {
  Drop(P, goto BB1, unwind BB2)
}
BB1 {
  // P is now uninitialized
  P <- V
}
BB2 {
  // P is now uninitialized -- its dtor panicked
  P <- V
}

Note that DropAndReplace is eliminated as part of the ElaborateDrops pass.

Fields of DropAndReplace

place: Place<'tcx>value: Operand<'tcx>target: BasicBlockunwind: Option<BasicBlock>

Call

Block ends with a call of a function.

Fields of Call

func: Operand<'tcx>

The function that’s being called.

args: Vec<Operand<'tcx>>

Arguments the function is called with. These are owned by the callee, which is free to modify them. This allows the memory occupied by "by-value" arguments to be reused across function calls without duplicating the contents.

destination: Option<(Place<'tcx>, BasicBlock)>

Destination for the return value. If some, the call is converging.

cleanup: Option<BasicBlock>

Cleanups to be done if the call unwinds.

from_hir_call: bool

true if this is from a call in HIR rather than from an overloaded operator. True for overloaded function call.

fn_span: Span

This Span is the span of the function, without the dot and receiver (e.g. foo(a, b) in x.foo(a, b)

Assert

Jump to the target if the condition has the expected value, otherwise panic with a message and a cleanup target.

Fields of Assert

cond: Operand<'tcx>expected: boolmsg: AssertMessage<'tcx>target: BasicBlockcleanup: Option<BasicBlock>

Yield

A suspend point.

Fields of Yield

value: Operand<'tcx>

The value to return.

resume: BasicBlock

Where to resume to.

resume_arg: Place<'tcx>

The place to store the resume argument in.

drop: Option<BasicBlock>

Cleanup to be done if the generator is dropped at this suspend point.

GeneratorDrop

Indicates the end of the dropping of a generator.

FalseEdge

A block where control flow only ever takes one real path, but borrowck needs to be more conservative.

Fields of FalseEdge

real_target: BasicBlock

The target normal control flow will take.

imaginary_target: BasicBlock

A block control flow could conceptually jump to, but won't in practice.

FalseUnwind

A terminator for blocks that only take one path in reality, but where we reserve the right to unwind in borrowck, even if it won't happen in practice. This can arise in infinite loops with no function calls for example.

Fields of FalseUnwind

real_target: BasicBlock

The target normal control flow will take.

unwind: Option<BasicBlock>

The imaginary cleanup block link. This particular path will never be taken in practice, but in order to avoid fragility we want to always consider it in borrowck. We don't want to accept programs which pass borrowck only when panic=abort or some assertions are disabled due to release vs. debug mode builds. This needs to be an Option because of the remove_noop_landing_pads and no_landing_pads passes.

InlineAsm

Block ends with an inline assembly block. This is a terminator since inline assembly is allowed to diverge.

Fields of InlineAsm

template: &'tcx [InlineAsmTemplatePiece]

The template for the inline assembly, with placeholders.

operands: Vec<InlineAsmOperand<'tcx>>

The operands for the inline assembly, as Operands or Places.

options: InlineAsmOptions

Miscellaneous options for the inline assembly.

line_spans: &'tcx [Span]

Source spans for each line of the inline assembly code. These are used to map assembler errors back to the line in the source code.

destination: Option<BasicBlock>

Destination block after the inline assembly returns, unless it is diverging (InlineAsmOptions::NORETURN).

Implementations

impl<'tcx> TerminatorKind<'tcx>

pub fn if_(
    tcx: TyCtxt<'tcx>,
    cond: Operand<'tcx>,
    t: BasicBlock,
    f: BasicBlock
) -> TerminatorKind<'tcx>

pub fn successors(&self) -> Successors<'_>

pub fn successors_mut(&mut self) -> SuccessorsMut<'_>

pub fn unwind(&self) -> Option<&Option<BasicBlock>>

pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>>

impl<'tcx> TerminatorKind<'tcx>

pub fn fmt_head<W: Write>(&self, fmt: &mut W) -> Result

Writes the "head" part of the terminator; that is, its name and the data it uses to pick the successor basic block, if any. The only information not included is the list of possible successors, which may be rendered differently between the text and the graphviz format.

pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>>

Returns the list of labels for the edges to the successor basic blocks.

Trait Implementations

impl<'tcx> Clone for TerminatorKind<'tcx>

pub fn clone(&self) -> TerminatorKind<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for TerminatorKind<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for TerminatorKind<'tcx>

pub fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for TerminatorKind<'tcx>

pub fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for TerminatorKind<'tcx>

pub fn hash_stable(
    &self,
    __hcx: &mut StableHashingContext<'__ctx>,
    __hasher: &mut StableHasher
)

impl<'tcx> PartialEq<TerminatorKind<'tcx>> for TerminatorKind<'tcx>

pub fn eq(&self, other: &TerminatorKind<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &TerminatorKind<'tcx>) -> bool

This method tests for !=.

impl<'tcx> StructuralPartialEq for TerminatorKind<'tcx>