Enum rustc_middle::mir::terminator::TerminatorKind[][src]

pub enum TerminatorKind<'tcx> {
Show 15 variants 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>, cleanup: Option<BasicBlock>, },




target: BasicBlock

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



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

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


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


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


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


Indicates a terminator that can never be reached.



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

Drop the Place.



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

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)


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.



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)

Block ends with a call of a function.



cond: Operand<'tcx>
expected: bool
msg: AssertMessage<'tcx>
target: BasicBlock
cleanup: Option<BasicBlock>

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



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.

A suspend point.


Indicates the end of the dropping of a generator.



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.

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



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 abort_unwinding_calls passes.

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.



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).

cleanup: Option<BasicBlock>

Cleanup to be done if the inline assembly unwinds. This is present if and only if InlineAsmOptions::MAY_UNWIND is set.

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


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.

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

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

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

This method tests for !=.

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

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

This method turns the parameters of a DepNodeConstructor into an opaque Fingerprint to be used in DepNode. Not all DepNodeParams support being turned into a Fingerprint (they don’t need to if the corresponding DepNode is anonymous). Read more

This method tries to recover the query key from the given DepNode, something which is needed when forcing DepNodes during red-green evaluation. The query system will only call this method if fingerprint_style() is not FingerprintStyle::Opaque. It is always valid to return None here, in which case incremental compilation will treat the query as having changed instead of forcing it. Read more

Performs the conversion.

Performs the conversion.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

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

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.


Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 96 bytes

Size for each variant: