Enum CoverageSuccessors

enum CoverageSuccessors<'a> {
    Chainable(BasicBlock),
    NotChainable(&'a [BasicBlock]),
    Yield(BasicBlock),
}

Holds the coverage-relevant successors of a basic block’s terminator, and indicates whether that block can potentially be combined into the same BCB as its sole successor.

Variants

Chainable(BasicBlock)

The terminator has exactly one straight-line successor, so its block can potentially be combined into the same BCB as that successor.

NotChainable(&'a [BasicBlock])

The block cannot be combined into the same BCB as its successor(s).

Yield(BasicBlock)

Yield terminators are not chainable, and their execution count can also differ from the execution count of their out-edge.

Implementations

impl CoverageSuccessors<'_>

fn is_chainable(&self) -> bool

fn is_out_summable(&self) -> bool

Returns true if the terminator itself is assumed to have the same execution count as the sum of its out-edges (assuming no panics).

Trait Implementations

impl<'a> Clone for CoverageSuccessors<'a>

fn clone(&self) -> CoverageSuccessors<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CoverageSuccessors<'a>

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

Formats the value using the given formatter.

impl IntoIterator for CoverageSuccessors<'_>

type Item = BasicBlock

The type of the elements being iterated over.

type IntoIter = impl DoubleEndedIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> Copy for CoverageSuccessors<'a>

Layout

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: 24 bytes

Size for each variant:

• Chainable: 4 bytes
• NotChainable: 20 bytes
• Yield: 4 bytes