Struct Function 

pub struct Function {
    pub name: String,
    pub ty: TypeId,
    pub args: Vec<Argument>,
    pub blocks: Vec<BasicBlock>,
    pub instructions: Vec<Instruction>,
    pub instr_dbg_locs: HashMap<InstrId, u32>,
    pub instr_metadata: HashMap<InstrId, Vec<(String, String)>>,
    pub value_names: HashMap<String, InstrId>,
    pub arg_names: HashMap<String, ArgId>,
    pub is_declaration: bool,
    pub linkage: Linkage,
    /* private fields */
}

A function definition or declaration.

Fields

name: String

Public API for name.

ty: TypeId

Function type (FunctionType TypeId).

args: Vec<Argument>

Formal arguments.

blocks: Vec<BasicBlock>

Basic blocks in program order.

instructions: Vec<Instruction>

Flat instruction pool; InstrId(i) indexes instructions[i].

instr_dbg_locs: HashMap<InstrId, u32>

Optional !dbg !N attachment for each instruction id.

instr_metadata: HashMap<InstrId, Vec<(String, String)>>

Arbitrary metadata attachments per instruction, e.g. !dbg !12, !tbaa !7.

value_names: HashMap<String, InstrId>

Maps result name → InstrId.

arg_names: HashMap<String, ArgId>

Maps argument name → ArgId.

is_declaration: bool

True if this is a declaration (no body).

linkage: Linkage

Public API for linkage.

Implementations

impl Function

pub fn new( name: impl Into<String>, ty: TypeId, args: Vec<Argument>, linkage: Linkage, ) -> Self

Public API for new.

pub fn new_declaration( name: impl Into<String>, ty: TypeId, args: Vec<Argument>, linkage: Linkage, ) -> Self

Public API for new_declaration.

pub fn add_block(&mut self, bb: BasicBlock) -> BlockId

Add a new basic block and return its BlockId.

pub fn block(&self, id: BlockId) -> &BasicBlock

Public API for block.

pub fn block_mut(&mut self, id: BlockId) -> &mut BasicBlock

Public API for block_mut.

pub fn num_blocks(&self) -> usize

Public API for num_blocks.

pub fn alloc_instr(&mut self, instr: Instruction) -> InstrId

Allocate an instruction in the flat pool, register its name if any, and return the InstrId.

pub fn instr(&self, id: InstrId) -> &Instruction

Public API for instr.

pub fn instr_mut(&mut self, id: InstrId) -> &mut Instruction

Public API for instr_mut.

pub fn num_instrs(&self) -> usize

Public API for num_instrs.

pub fn set_instr_dbg_loc(&mut self, id: InstrId, loc_id: u32)

Public API for set_instr_dbg_loc.

pub fn instr_dbg_loc(&self, id: InstrId) -> Option<u32>

Public API for instr_dbg_loc.

pub fn add_instr_metadata( &mut self, id: InstrId, key: impl Into<String>, value: impl Into<String>, )

Public API for add_instr_metadata.

pub fn instr_metadata(&self, id: InstrId) -> Option<&[(String, String)]>

Public API for instr_metadata.

pub fn arg(&self, id: ArgId) -> &Argument

Public API for arg.

pub fn num_args(&self) -> usize

Public API for num_args.

pub fn lookup_value(&self, name: &str) -> Option<ValueRef>

Public API for lookup_value.

pub fn lookup_block(&self, name: &str) -> Option<BlockId>

Public API for lookup_block.

pub fn type_of_value(&self, vref: ValueRef) -> Option<TypeId>

Public API for type_of_value.

pub fn fresh_name(&mut self) -> String

Produce a unique name like "1", "2", … for unnamed SSA values.