Struct cranelift_codegen::cursor::EncCursor

pub struct EncCursor<'f> {
    pub func: &'f mut Function,
    pub isa: &'f dyn TargetIsa,
    // some fields omitted
}

Encoding cursor.

An EncCursor can be used to insert instructions that are immediately assigned an encoding. The cursor holds a mutable reference to the whole function which can be re-borrowed from the public pos.func member.

Fields

func: &'f mut Function

The referenced function.

isa: &'f dyn TargetIsa

The target ISA that will be used to encode instructions.

Methods

impl<'f> EncCursor<'f>

pub fn new(func: &'f mut Function, isa: &'f dyn TargetIsa) -> Self

Create a new EncCursor 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 EncCursor<'f>>

Create an instruction builder that will insert an encoded instruction at the current position.

The builder will panic if it is used to insert an instruction that can't be encoded for self.isa.

pub fn built_inst(&self) -> Inst

Get the last built instruction.

This returns the last instruction that was built using the ins() method on this cursor. Panics if no instruction was built.

pub fn display_inst(&self, inst: Inst) -> DisplayInst

Return an object that can display inst.

This is a convenience wrapper for the DFG equivalent.

Trait Implementations

impl<'f> Cursor for EncCursor<'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 an block at the current position and switch to it.

impl<'c, 'f> InstInserterBase<'c> for &'c mut EncCursor<'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,
    ctrl_typevar: Type
) -> &'c mut DataFlowGraph

Insert a new instruction which belongs to the DFG.