Struct midenc_hir_transform::InlineBlocks

pub struct InlineBlocks;

This pass inlines unnecessary blocks, and removes unnecessary block arguments.

Specifically, the blocks affected are those with a single predecessor, as they by definition can be inlined into their immediate predecessor in such cases.

Blocks like this may have been introduced for the following reasons:

• Due to less than optimal lowering to SSA form
• To split critical edges in preparation for dataflow analysis and related transformations, but ultimately no code introduced along those edges, and critical edges no longer present an obstacle to further optimization or codegen.
• During treeification of the CFG, where blocks with multiple predecessors were duplicated to produce a CFG in tree form, where no blocks (other than loop headers) have multiple predecessors. This process removed block arguments from these blocks, and rewrote instructions dominated by those block arguments to reference the values passed from the original predecessor to whom the subtree is attached. This transformation can expose a chain of blocks which all have a single predecessor and successor, introducing branches where none are needed, and by removing those redundant branches, all of the code from blocks in the chain can be inlined in the first block of the chain.

Trait Implementations

impl Default for InlineBlocks

fn default() -> InlineBlocks

Returns the “default value” for a type.

impl PassInfo for InlineBlocks

const FLAG: &'static str = InlineBlocks

The string which should be used as the name of this pass on the command line.

const SUMMARY: &'static str = /// This pass inlines unnecessary blocks, and removes unnecessary block arguments. /// /// Specifically, the blocks affected are those with a single predecessor, as they /// by definition can be inlined into their immediate predecessor in such cases. /// /// Blocks like this may have been introduced for the following reasons: /// /// * Due to less than optimal lowering to SSA form /// * To split critical edges in preparation for dataflow analysis and related transformations, /// but ultimately no code introduced along those edges, and critical edges no longer present /// an obstacle to further optimization or codegen. /// * During treeification of the CFG, where blocks with multiple predecessors were duplicated /// to produce a CFG in tree form, where no blocks (other than loop headers) have multiple /// predecessors. This process removed block arguments from these blocks, and rewrote instructions /// dominated by those block arguments to reference the values passed from the original predecessor /// to whom the subtree is attached. This transformation can expose a chain of blocks which all have /// a single predecessor and successor, introducing branches where none are needed, and by removing /// those redundant branches, all of the code from blocks in the chain can be inlined in the first /// block of the chain. #[derive(Default, PassInfo, ModuleRewritePassAdapter)] pub struct InlineBlocks;

A short, single-line description of what this pass does.

const DESCRIPTION: &'static str = /// This pass inlines unnecessary blocks, and removes unnecessary block arguments. /// /// Specifically, the blocks affected are those with a single predecessor, as they /// by definition can be inlined into their immediate predecessor in such cases. /// /// Blocks like this may have been introduced for the following reasons: /// /// * Due to less than optimal lowering to SSA form /// * To split critical edges in preparation for dataflow analysis and related transformations, /// but ultimately no code introduced along those edges, and critical edges no longer present /// an obstacle to further optimization or codegen. /// * During treeification of the CFG, where blocks with multiple predecessors were duplicated /// to produce a CFG in tree form, where no blocks (other than loop headers) have multiple /// predecessors. This process removed block arguments from these blocks, and rewrote instructions /// dominated by those block arguments to reference the values passed from the original predecessor /// to whom the subtree is attached. This transformation can expose a chain of blocks which all have /// a single predecessor and successor, introducing branches where none are needed, and by removing /// those redundant branches, all of the code from blocks in the chain can be inlined in the first /// block of the chain. #[derive(Default, PassInfo, ModuleRewritePassAdapter)] pub struct InlineBlocks;

A rich, potentially multi-line description of this pass and its configuration.

impl RewritePass for InlineBlocks

type Entity = Function

The entity type to which this rewrite applies

fn apply( &mut self, function: &mut Self::Entity, analyses: &mut AnalysisManager, session: &Session, ) -> RewriteResult

Apply this rewrite to entity

fn should_apply(&self, _entity: &Self::Entity, _session: &Session) -> bool

Returns true if this rewrite should be applied to entity

fn chain<R>(self, next: R) -> RewriteSet<Self::Entity>

where Self: Sized + 'static, R: RewritePass<Entity = Self::Entity> + 'static,

Apply this rewrite, then next as a pipeline of rewrites