Struct cranelift_codegen::cursor::FuncCursor

pub struct FuncCursor<'f> {
    pub func: &'f mut Function,
    /* private fields */
}

Function cursor.

A FuncCursor holds a mutable reference to a whole ir::Function while keeping a position too. The function can be re-borrowed by accessing the public cur.func member.

This cursor is for use before legalization. The inserted instructions are not given an encoding.

Fields

func: &'f mut Function

The referenced function.

Implementations

impl<'f> FuncCursor<'f>

pub fn new(func: &'f mut Function) -> Self

Create a new FuncCursor pointing nowhere.

pub fn use_srcloc(&mut self, inst: Inst)

Use the source location of inst for future instructions.

pub fn ins(&mut self) -> InsertBuilder<'_, &mut FuncCursor<'f>>

Create an instruction builder that inserts an instruction at the current position.

Trait Implementations

impl<'f> Cursor for FuncCursor<'f>

fn position(&self) -> CursorPosition

Get the current cursor position.

fn set_position(&mut self, pos: CursorPosition)

Set the current position.

fn srcloc(&self) -> SourceLoc

Get the source location that should be assigned to new instructions.

fn set_srcloc(&mut self, srcloc: SourceLoc)

Set the source location that should be assigned to new instructions.

fn layout(&self) -> &Layout

Borrow a reference to the function layout that this cursor is navigating.

fn layout_mut(&mut self) -> &mut Layout

Borrow a mutable reference to the function layout that this cursor is navigating.

fn with_srcloc(self, srcloc: SourceLoc) -> Self where
    Self: Sized, 

Exchange this cursor for one with a set source location.

fn at_position(self, pos: CursorPosition) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at pos.

fn at_inst(self, inst: Inst) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at inst.

fn at_first_insertion_point(self, block: Block) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at the first insertion point for block. This differs from at_first_inst in that it doesn’t assume that any instructions have been inserted into block yet.

fn at_first_inst(self, block: Block) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at the first instruction in block.

fn at_last_inst(self, block: Block) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at the last instruction in block.

fn after_inst(self, inst: Inst) -> Self where
    Self: Sized, 

Rebuild this cursor positioned after inst.

fn at_top(self, block: Block) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at the top of block.

fn at_bottom(self, block: Block) -> Self where
    Self: Sized, 

Rebuild this cursor positioned at the bottom of block.

fn current_block(&self) -> Option<Block>

Get the block corresponding to the current position.

fn current_inst(&self) -> Option<Inst>

Get the instruction corresponding to the current position, if any.

fn goto_after_inst(&mut self, inst: Inst)

Go to the position after a specific instruction, which must be inserted in the layout. New instructions will be inserted after inst.

fn goto_inst(&mut self, inst: Inst)

Go to a specific instruction which must be inserted in the layout. New instructions will be inserted before inst.

fn goto_first_insertion_point(&mut self, block: Block)

Go to the position for inserting instructions at the beginning of block, which unlike goto_first_inst doesn’t assume that any instructions have been inserted into block yet.

fn goto_first_inst(&mut self, block: Block)

Go to the first instruction in block.

fn goto_last_inst(&mut self, block: Block)

Go to the last instruction in block.

fn goto_top(&mut self, block: Block)

Go to the top of block which must be inserted into the layout. At this position, instructions cannot be inserted, but next_inst() will move to the first instruction in block.

fn goto_bottom(&mut self, block: Block)

Go to the bottom of block which must be inserted into the layout. At this position, inserted instructions will be appended to block.

fn next_block(&mut self) -> Option<Block>

Go to the top of the next block in layout order and return it.

fn prev_block(&mut self) -> Option<Block>

Go to the bottom of the previous block in layout order and return it.

fn next_inst(&mut self) -> Option<Inst>

Move to the next instruction in the same block and return it.

fn prev_inst(&mut self) -> Option<Inst>

Move to the previous instruction in the same block and return it.

fn insert_inst(&mut self, inst: Inst)

Insert an instruction at the current position.

fn remove_inst(&mut self) -> Inst

Remove the instruction under the cursor.

fn remove_inst_and_step_back(&mut self) -> Inst

Remove the instruction under the cursor.

fn insert_block(&mut self, new_block: Block)

Insert a block at the current position and switch to it.

impl<'c, 'f> InstInserterBase<'c> for &'c mut FuncCursor<'f>

fn data_flow_graph(&self) -> &DataFlowGraph

Get an immutable reference to the data flow graph.

fn data_flow_graph_mut(&mut self) -> &mut DataFlowGraph

Get a mutable reference to the data flow graph.

fn insert_built_inst(self, inst: Inst) -> &'c mut DataFlowGraph

Insert a new instruction which belongs to the DFG.