Struct midenc_hir::DataFlowGraph

pub struct DataFlowGraph {
    pub entry: Block,
    pub attrs: AttributeSet,
    pub blocks: OrderedArenaMap<Block, BlockData>,
    pub insts: ArenaMap<Inst, InstNode>,
    pub results: SecondaryMap<Inst, ValueList>,
    pub values: PrimaryMap<Value, ValueData>,
    pub value_lists: ValueListPool,
    pub imports: FxHashMap<FunctionIdent, ExternalFunction>,
    pub globals: PrimaryMap<GlobalValue, GlobalValueData>,
    pub locals: PrimaryMap<LocalId, Local>,
    pub constants: ConstantPool,
}

Fields

entry: Block

attrs: AttributeSet

blocks: OrderedArenaMap<Block, BlockData>

insts: ArenaMap<Inst, InstNode>

results: SecondaryMap<Inst, ValueList>

values: PrimaryMap<Value, ValueData>

value_lists: ValueListPool

imports: FxHashMap<FunctionIdent, ExternalFunction>

globals: PrimaryMap<GlobalValue, GlobalValueData>

locals: PrimaryMap<LocalId, Local>

constants: ConstantPool

Implementations

impl DataFlowGraph

pub fn new_uninit() -> Self

Create a new, completely uninitialized DataFlowGraph

pub fn get_attribute<Q>(&self, name: &Q) -> Option<&AttributeValue>

where Symbol: Borrow<Q>, Q: Ord + ?Sized,

Return the value associated with attribute name for this function

pub fn has_attribute<Q>(&self, name: &Q) -> bool

where Symbol: Borrow<Q>, Q: Ord + ?Sized,

Return true if this function has an attributed named name

pub fn set_attribute( &mut self, name: impl Into<Symbol>, value: impl Into<AttributeValue>, )

Set the attribute name with value for this function.

pub fn remove_attribute<Q>(&mut self, name: &Q)

where Symbol: Borrow<Q>, Q: Ord + ?Sized,

Remove any attribute with the given name from this function

pub fn get_import(&self, id: &FunctionIdent) -> Option<&ExternalFunction>

Returns an ExternalFunction given its FunctionIdent

pub fn get_import_by_name<M: AsRef<str>, F: AsRef<str>>( &self, module: M, name: F, ) -> Option<&ExternalFunction>

Look up an ExternalFunction given it’s module and function name

pub fn imports<'a, 'b: 'a>( &'b self, ) -> impl Iterator<Item = &'a ExternalFunction> + 'a

Returns an iterator over the ExternalFunctions imported by this function

pub fn import_function( &mut self, module: Ident, name: Ident, signature: Signature, ) -> Result<FunctionIdent, SymbolConflictError>

Imports function name from module, with signature, returning a FunctionIdent corresponding to the import.

If the function is already imported, and the signature doesn’t match, Err is returned.

pub fn create_global_value(&mut self, data: GlobalValueData) -> GlobalValue

Create a new global value reference

pub fn global_value(&self, gv: GlobalValue) -> &GlobalValueData

Gets the data associated with the given GlobalValue

pub fn is_global_addr(&self, gv: GlobalValue) -> bool

Returns true if the given GlobalValue represents an address

pub fn global_type(&self, gv: GlobalValue) -> Type

Returns the type of the given global value

pub fn make_value(&mut self, data: ValueData) -> Value

pub fn value_type(&self, v: Value) -> &Type

pub fn value_span(&self, v: Value) -> SourceSpan

pub fn value_data(&self, v: Value) -> &ValueData

pub fn set_value_type(&mut self, v: Value, ty: Type)

pub fn get_value(&self, v: Value) -> ValueData

pub fn value_block(&self, v: Value) -> Block

pub fn inst_node(&self, inst: Inst) -> &InstNode

Get a reference to the metadata for an instruction

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

Get a reference to the data for an instruction

pub fn inst_mut(&mut self, inst: Inst) -> &mut Instruction

Get a mutable reference to the metadata for an instruction

pub fn inst_span(&self, inst: Inst) -> SourceSpan

pub fn inst_args(&self, inst: Inst) -> &[Value]

pub fn inst_block(&self, inst: Inst) -> Option<Block>

pub fn inst_results(&self, inst: Inst) -> &[Value]

pub fn append_inst( &mut self, block: Block, data: Instruction, ctrl_ty: Type, span: SourceSpan, ) -> Inst

Append a new instruction to the end of block, using the provided instruction data, controlling type variable, and source span

pub fn insert_inst( &mut self, ip: InsertionPoint, data: Instruction, ctrl_ty: Type, span: SourceSpan, ) -> Inst

Insert a new instruction at ip, using the provided instruction data, controlling type variable, and source span

pub fn clone_inst(&mut self, inst: Inst) -> Inst

Create a new instruction which is a clone of inst, but detached from any block.

NOTE: The instruction is in a temporarily invalid state, because if it has arguments, they will reference values from the scope of the original instruction, but the clone hasn’t been inserted anywhere yet. It is up to the caller to ensure that the cloned instruction is updated appropriately once inserted.

pub fn replace(&mut self, inst: Inst) -> ReplaceBuilder<'_>

Create a ReplaceBuilder that will replace inst with a new instruction in-place.

pub fn append_result(&mut self, inst: Inst, ty: Type) -> Value

pub fn first_result(&self, inst: Inst) -> Value

pub fn has_results(&self, inst: Inst) -> bool

pub fn replace_uses(&mut self, inst: Inst, value: Value, replacement: Value)

Replace uses of value with replacement in the arguments of inst

pub fn replace_argument(&mut self, inst: Inst, index: usize, replacement: Value)

Replace argument at index in the argument list of inst

NOTE: This should not be used for successor arguments, as each successor gets its own distinct argument list, separate from the instruction argument list.

pub fn replace_successor_argument( &mut self, inst: Inst, succ_index: usize, index: usize, replacement: Value, )

Replace the block argument at index, for the successor argument list of the successor at succ_index, in the set of successors for inst.

pub fn pp_block(&self, pp: ProgramPoint) -> Block

pub fn pp_cmp<A, B>(&self, a: A, b: B) -> Ordering

where A: Into<ProgramPoint>, B: Into<ProgramPoint>,

pub fn call_signature(&self, inst: Inst) -> Option<&Signature>

pub fn analyze_call(&self, inst: Inst) -> CallInfo<'_>

pub fn analyze_branch(&self, inst: Inst) -> BranchInfo<'_>

pub fn blocks(&self) -> impl Iterator<Item = (Block, &BlockData)>

pub fn entry_block(&self) -> Block

Get the block identifier for the entry block

pub fn entry(&self) -> &BlockData

Get a reference to the data for the entry block

pub fn entry_mut(&mut self) -> &mut BlockData

Get a mutable reference to the data for the entry block

pub fn num_blocks(&self) -> usize

pub fn block(&self, block: Block) -> &BlockData

Get an immutable reference to the block data for block

pub fn block_mut(&mut self, block: Block) -> &mut BlockData

Get a mutable reference to the block data for block

pub fn block_args(&self, block: Block) -> &[Value]

pub fn block_insts(&self, block: Block) -> impl Iterator<Item = Inst> + '_

pub fn block_cursor(&self, block: Block) -> InstructionCursor<'_>

pub fn block_cursor_at(&self, inst: Inst) -> InstructionCursor<'_>

pub fn last_inst(&self, block: Block) -> Option<Inst>

pub fn is_block_linked(&self, block: Block) -> bool

pub fn is_block_empty(&self, block: Block) -> bool

pub fn create_block(&mut self) -> Block

pub fn append_block(&mut self, block: Block)

pub fn create_block_after(&mut self, block: Block) -> Block

Creates a new block, inserted into the function layout just after block

pub fn detach_block(&mut self, block: Block)

Removes block from the body of this function, without destroying it’s data

pub fn num_block_params(&self, block: Block) -> usize

pub fn block_params(&self, block: Block) -> &[Value]

pub fn block_param(&self, block: Block, index: usize) -> &ValueData

pub fn block_param_types(&self, block: Block) -> SmallVec<[Type; 1]>

pub fn clone_block_params(&mut self, src: Block, dest: Block)

Clone the block parameters of src as a new set of values, derived from the data used to crate the originals, and use them to populate the block arguments of dest, in the same order.

pub fn append_block_param( &mut self, block: Block, ty: Type, span: SourceSpan, ) -> Value

pub fn is_block_terminated(&self, block: Block) -> bool

pub fn remove_block_param(&mut self, val: Value)

Removes val from block‘s parameters by a standard linear time list removal which preserves ordering. Also updates the values’ data.

pub fn append_branch_destination_argument( &mut self, branch_inst: Inst, dest: Block, value: Value, )

Appends value as an argument to the branch_inst instruction arguments list if the destination block of the branch_inst is dest. Panics if branch_inst is not a branch instruction.

pub fn nearest_definition_in_block( &self, user: Inst, value: Value, ) -> Option<Value>

Try to locate a valid definition of value in the current block, looking up the block from user

pub fn alloc_local(&mut self, ty: Type) -> LocalId

pub fn local_type(&self, id: LocalId) -> &Type

pub fn locals(&self) -> impl Iterator<Item = &Local> + '_

Trait Implementations

impl Default for DataFlowGraph

fn default() -> Self

Returns the “default value” for a type.

impl Index<Inst> for DataFlowGraph

type Output = Instruction

The returned type after indexing.

fn index(&self, inst: Inst) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Inst> for DataFlowGraph

fn index_mut(&mut self, inst: Inst) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.