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>, },
}

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

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

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)

recently added

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.

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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: