Struct LoopInfo 

pub struct LoopInfo {
    pub header: NodeId,
    pub body: BitSet,
    pub latches: Vec<NodeId>,
    pub preheader: Option<NodeId>,
    pub exits: Vec<LoopExit>,
    pub depth: usize,
    pub loop_type: LoopType,
    pub parent: Option<NodeId>,
    pub children: Vec<NodeId>,
}

Comprehensive loop information.

This extends NaturalLoop with additional structural information needed for loop canonicalization and optimization.

Fields

header: NodeId

The header block (single entry point, dominates all loop nodes).

body: BitSet

All blocks in the loop body (including header).

latches: Vec<NodeId>

Back edge sources (blocks that jump to the header from within the loop).

preheader: Option<NodeId>

Preheader block if one exists (single non-loop predecessor of header). None if header has multiple non-loop predecessors or none.

exits: Vec<LoopExit>

Exit edges from the loop.

depth: usize

Loop nesting depth (0 = outermost).

loop_type: LoopType

Classification of the loop type.

parent: Option<NodeId>

Parent loop header, if this loop is nested.

children: Vec<NodeId>

Immediate child loop headers.

Implementations

impl LoopInfo

pub fn new(header: NodeId, node_count: usize) -> LoopInfo

Creates a new LoopInfo with the given header.

pub fn contains(&self, node: NodeId) -> bool

Returns true if this loop contains the given block.

pub fn size(&self) -> usize

Returns the number of blocks in the loop.

pub fn has_single_latch(&self) -> bool

Returns true if the loop has a single latch (canonical form).

pub fn single_latch(&self) -> Option<NodeId>

Returns the single latch if there is exactly one.

pub fn has_preheader(&self) -> bool

Returns true if the loop has a preheader (canonical form).

pub fn is_canonical(&self) -> bool

Returns true if the loop is in canonical form.

A canonical loop has:

• A single preheader
• A single latch

pub fn is_innermost(&self) -> bool

Returns true if this is an innermost loop (no children).

pub fn is_outermost(&self) -> bool

Returns true if this is an outermost loop (no parent).

pub fn exit_blocks(&self) -> impl Iterator<Item = NodeId>

Returns all exit blocks (blocks outside loop reachable from inside).

pub fn exiting_blocks(&self) -> impl Iterator<Item = NodeId>

Returns all exiting blocks (blocks inside loop that branch out).

pub fn exit_count(&self) -> usize

Returns the number of exits from this loop.

pub fn header_is_exiting(&self) -> bool

Returns true if the header is also an exiting block.

This indicates a pre-tested loop (condition at entry).

pub fn latch_is_exiting(&self) -> bool

Returns true if a latch is also an exiting block.

This indicates a post-tested loop (condition at end).

pub fn find_condition_in_body<T>(&self, ssa: &SsaFunction<T>) -> Option<NodeId>

where T: Target,

Finds the condition block inside the loop body.

For control-flow flattened code (e.g., ConfuserEx), the actual loop condition is often inside a case block rather than at the dispatcher header. This method searches for blocks with Branch instructions within the loop body.

Returns

• Some(NodeId) - The first block found with a conditional branch
• None - No conditional branch found in the loop body

pub fn find_all_conditions_in_body<T>( &self, ssa: &SsaFunction<T>, ) -> Vec<NodeId>

where T: Target,

Finds all conditional blocks within the loop body.

Unlike find_condition_in_body, this returns all blocks with conditional branches, useful for complex loops with multiple exit points.

pub fn find_induction_vars<T>(&self, ssa: &SsaFunction<T>) -> Vec<InductionVar>

where T: Target,

Identifies induction variables in this loop.

An induction variable is identified by finding phi nodes at the loop header where:

• One operand comes from outside the loop (initial value)
• One operand comes from inside the loop (updated value)

The method attempts to classify the update kind (add, sub, etc.) by analyzing the instruction that produces the update value.

Returns

A vector of InductionVar structures describing each induction variable.

Trait Implementations

impl Clone for LoopInfo

fn clone(&self) -> LoopInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoopInfo

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

Formats the value using the given formatter.