Struct IRRewriter 

pub struct IRRewriter<L>
where
    L: RewriteListener,
{ /* private fields */ }

An implementation of the rewriter trait. Use DummyListener if no listener is needed.

Implementations

impl<L> IRRewriter<L>

where L: RewriteListener,

pub fn set_listener(&mut self, listener: L)

Sets the listener for insertion events.

pub fn get_listener(&self) -> &L

Gets a reference to the listener for insertion events.

pub fn get_listener_mut(&mut self) -> &mut L

Gets a mutable reference to the listener for insertion events.

Trait Implementations

impl<L> Default for IRRewriter<L>

where L: RewriteListener + Default,

fn default() -> IRRewriter<L>

Returns the “default value” for a type.

impl<L> Inserter for IRRewriter<L>

where L: RewriteListener,

fn append_operation(&mut self, ctx: &Context, operation: Ptr<Operation>)

Appends an Operation at the current insertion point. The insertion point is updated to be after this newly inserted Operation.

fn append_op(&mut self, ctx: &Context, op: &(dyn Op + 'static))

Appends an Op at the current insertion point. The insertion point is updated to be after this newly inserted Op.

fn insert_operation(&mut self, ctx: &Context, operation: Ptr<Operation>)

Inserts an Operation at the current insertion point. To insert a sequence in-order, use append_operation.

fn insert_op(&mut self, ctx: &Context, op: &(dyn Op + 'static))

Inserts an Op at the current insertion point. To insert a sequence in-order, use append_op.

fn insert_block( &mut self, ctx: &Context, insertion_point: BlockInsertionPoint, block: Ptr<BasicBlock>, )

Insert BasicBlock at the provided insertion point.

fn create_block( &mut self, ctx: &mut Context, insertion_point: BlockInsertionPoint, label: Option<Identifier>, arg_types: Vec<TypeHandle>, ) -> Ptr<BasicBlock>

Create a new BasicBlock and insert it at the provided insertion point. The internal OpInsertionPoint is updated to be at the end of the newly created block.

fn get_insertion_point(&self) -> OpInsertionPoint

Gets the current insertion point.

fn get_insertion_block(&self, ctx: &Context) -> Option<Ptr<BasicBlock>>

Get the BasicBlock, if known, in which the next Op insertion will occur.

fn set_insertion_point(&mut self, point: OpInsertionPoint)

Set the insertion point.

fn is_insertion_point_set(&self) -> bool

Is insertion point set?

fn set_insertion_point_to_block_start(&mut self, block: Ptr<BasicBlock>)

Sets the insertion point to the start of the given block.

fn set_insertion_point_to_block_end(&mut self, block: Ptr<BasicBlock>)

Sets the insertion point to the end of the given block.

fn set_insertion_point_after_operation(&mut self, op: Ptr<Operation>)

Sets the insertion point to after the given operation.

fn set_insertion_point_before_operation(&mut self, op: Ptr<Operation>)

Sets the insertion point to before the given operation.

impl<L> Rewriter for IRRewriter<L>

where L: RewriteListener,

fn get_config(&self) -> &RewriterConfig

Get the configuration for this rewriter.

fn get_config_mut(&mut self) -> &mut RewriterConfig

Get a mutable reference to the configuration for this rewriter.

fn replace_operation( &mut self, ctx: &mut Context, op: Ptr<Operation>, new_op: Ptr<Operation>, )

Replace an Operation (and delete it) with another operation. Results of the new operation must match the results of the old operation.

fn replace_operation_with_values( &mut self, ctx: &mut Context, op: Ptr<Operation>, new_values: Vec<Value>, )

Replace an Operation (and delete it) with a list of values. Results of the new operation must match the list of values.

fn replace_value_uses_with( &mut self, ctx: &Context, old_value: Value, new_value: Value, )

Replace all uses of a Value with another value.

fn erase_operation(&mut self, ctx: &mut Context, op: Ptr<Operation>)

Erase an Operation. The operation must have no uses.

fn erase_block(&mut self, ctx: &mut Context, block: Ptr<BasicBlock>)

Erase a BasicBlock. The block must have no uses.

fn erase_region(&mut self, ctx: &mut Context, region: Ptr<Region>)

Erase a Region. Affects the index of all regions after it.

fn unlink_operation(&mut self, ctx: &Context, op: Ptr<Operation>)

Unlink an Operation from its current position

fn unlink_block(&mut self, ctx: &Context, block: Ptr<BasicBlock>)

Unlink a BasicBlock from its current position

fn move_operation( &mut self, ctx: &Context, op: Ptr<Operation>, new_point: OpInsertionPoint, )

Move an Operation to a new insertion point.

fn move_block( &mut self, ctx: &Context, block: Ptr<BasicBlock>, new_point: BlockInsertionPoint, )

Move a BasicBlock to a new insertion point.

fn split_block( &mut self, ctx: &mut Context, block: Ptr<BasicBlock>, position: OpInsertionPoint, new_block_label: Option<Identifier>, ) -> Ptr<BasicBlock>

Split a BasicBlock at the given position.

fn inline_region( &mut self, ctx: &Context, src_region: Ptr<Region>, dest_insertion_point: BlockInsertionPoint, )

Inline a Region into another Region at the given insertion point. The source region will be empty after this operation. The caller must take care of transferring control flow and arguments as necessary.

fn set_value_type(&mut self, ctx: &Context, value: Value, new_type: TypeHandle)

Change the type of a Value.

fn is_modified(&self) -> bool

Has the IR been modified via this rewriter?

fn mark_modified(&mut self)

Mark that the IR has been modified via this rewriter.