Struct ControlFlowSink 

pub struct ControlFlowSink;

This transformation sinks operations as close as possible to their uses, one of two ways:

1. If there exists only a single use of the operation, move it before it’s use so that it is in an ideal position for code generation.

2. If there exist multiple uses, materialize a duplicate operation for all but one of the uses, placing them before the use. The last use will receive the original operation.

To make this rewrite even more useful, we take care to place the operation at a position before the using op, such that when generating code, the operation value will be placed on the stack at the appropriate place relative to the other operands of the using op. This makes the operand stack scheduling optimizer’s job easier.

The purpose of this rewrite is to improve the quality of generated code by reducing the live ranges of values that are trivial to materialize on-demand.

Restrictions

This transform will not sink operations under the following conditions:

• The operation has side effects
• The operation is a block terminator
• The operation has regions

Implementation

Given a list of regions, perform control flow sinking on them. For each region, control-flow sinking moves operations that dominate the region but whose only users are in the region into the regions so that they aren’t executed on paths where their results are not needed.

TODO: For the moment, this is a simple control-flow sink, i.e., no duplicating of ops. It should be made to accept a cost model to determine whether duplicating a particular op is profitable.

Example:

%0 = arith.addi %arg0, %arg1
scf.if %cond {
  scf.yield %0
} else {
  scf.yield %arg2
}

After control-flow sink:

scf.if %cond {
  %0 = arith.addi %arg0, %arg1
  scf.yield %0
} else {
  scf.yield %arg2
}

If using the control_flow_sink function, callers can supply a callback should_move_into_region that determines whether the given operation that only has users in the given operation should be moved into that region. If this returns true, move_into_region is called on the same operation and region.

move_into_region must move the operation into the region such that dominance of the operation is preserved; for example, by moving the operation to the start of the entry block. This ensures the preservation of SSA dominance of the operation’s results.

Trait Implementations

impl Pass for ControlFlowSink

type Target = Operation

The concrete/trait type targeted by this pass.

fn name(&self) -> &'static str

The display name of this pass

fn argument(&self) -> &'static str

The command line option name used to control this pass

fn can_schedule_on(&self, _name: &OperationName) -> bool

Query if this pass can be scheduled to run on the given operation type.

fn run_on_operation( &mut self, op: EntityMut<'_, Self::Target>, state: &mut PassExecutionState, ) -> Result<(), Report>

Run this pass on the current operation

fn as_any(&self) -> &(dyn Any + 'static)

Used for downcasting

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Used for downcasting

fn into_any(self: Box<Self>) -> Box<dyn Any>

Used for downcasting

fn description(&self) -> &'static str

A description of what this pass does.

fn info(&self) -> PassInfo

Obtain the underlying PassInfo object for this pass.

fn target_name(&self, context: &Context) -> Option<OperationName>

The name of the operation that this pass operates on, or None if this is a generic pass.

fn initialize_options(&mut self, options: &str) -> Result<(), Report>

If command-line options are provided for this pass, implementations must parse the raw options here, returning Err if parsing fails for some reason.

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

Prints out the pass in the textual representation of pipelines.

fn has_statistics(&self) -> bool

Returns true if this pass has associated statistics

fn statistics(&self) -> &[Box<dyn Statistic>]

Get pass statistics associated with this pass

fn statistics_mut(&mut self) -> &mut [Box<dyn Statistic>]

Get mutable access to the pass statistics associated with this pass

fn initialize(&mut self, context: Rc<Context>) -> Result<(), Report>

Initialize any complex state necessary for running this pass.

fn run_pipeline( &mut self, pipeline: &mut OpPassManager, op: RawEntityRef<Operation, IntrusiveLink>, state: &mut PassExecutionState, ) -> Result<(), Report>

Schedule an arbitrary pass pipeline on the provided operation.