Struct IrModule 

pub struct IrModule {
    pub name: String,
    pub inputs: Vec<IrValue>,
    pub outputs: Vec<IrValue>,
    pub blocks: IndexMap<BlockId, BasicBlock>,
    pub entry_block: BlockId,
    pub values: IndexMap<IrValue, ValueDef>,
    pub types: IndexMap<IrType, TypeDef>,
}

Intermediate Representation of a computation

Fields

name: String

Module name

inputs: Vec<IrValue>

Input values

outputs: Vec<IrValue>

Output values

blocks: IndexMap<BlockId, BasicBlock>

Basic blocks containing instructions

entry_block: BlockId

Entry block

values: IndexMap<IrValue, ValueDef>

Value definitions

types: IndexMap<IrType, TypeDef>

Type definitions

Implementations

impl IrModule

pub fn new(name: String) -> Self

Create a new empty IR module

pub fn add_block(&mut self) -> BlockId

Add a new basic block

pub fn add_value(&mut self, def: ValueDef) -> IrValue

Add a new value

pub fn add_value_external(&mut self, def: ValueDef) -> IrValue

Add a value (for external access)

pub fn add_type(&mut self, def: TypeDef) -> IrType

Add a new type

pub fn get_block(&self, id: BlockId) -> Option<&BasicBlock>

Get a block by ID

pub fn get_block_mut(&mut self, id: BlockId) -> Option<&mut BasicBlock>

Get a mutable block by ID

pub fn get_value(&self, value: IrValue) -> Option<&ValueDef>

Get value definition

pub fn get_type(&self, ty: IrType) -> Option<&TypeDef>

Get type definition

pub fn validate(&self) -> Result<(), String>

Validate the IR module

pub fn get_function(&self, _name: &str) -> Option<&BasicBlock>

Get a function-like interface for debugging compatibility For now, treat the entry block as the main “function”

pub fn inline_small_functions(&mut self) -> JitResult<()>

Inline small functions (placeholder implementation)

pub fn functions_mut(&mut self) -> impl Iterator<Item = &mut BasicBlock>

Get all functions in the module (returns an iterator over blocks as functions)

pub fn instructions(&self) -> impl Iterator<Item = &Instruction>

Get all instructions in the module

pub fn instructions_mut(&mut self) -> impl Iterator<Item = &mut Instruction>

Get all instructions in the module (mutable)

pub fn retain_instructions<F>(&mut self, predicate: F)

where F: FnMut(usize, &Instruction) -> bool,

Retain instructions that satisfy the predicate

pub fn remove_unused_functions(&mut self) -> JitResult<()>

Remove unused functions (placeholder implementation)

Trait Implementations

impl Clone for IrModule

fn clone(&self) -> IrModule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IrModule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.