Struct llhd::ir::Module

pub struct Module { /* fields omitted */ }

A module.

This is the root node of an LLHD intermediate representation. Contains Function, Process, and Entity declarations and definitions.

Methods

impl Module

pub fn new() -> Self

Create a new empty module.

pub fn dump(&self) -> ModuleDumper

Dump the module in human-readable form.

pub fn add_function(&mut self, func: Function) -> ModUnit

Add a function to the module.

pub fn add_process(&mut self, prok: Process) -> ModUnit

Add a process to the module.

pub fn add_entity(&mut self, ent: Entity) -> ModUnit

Add an entity to the module.

pub fn declare(&mut self, name: UnitName, sig: Signature) -> ModUnit

Declare an external unit.

pub fn remove_unit(&mut self, unit: ModUnit)

Remove a unit from the module.

pub fn units<'a>(&'a self) -> impl Iterator<Item = ModUnit> + 'a

Return an iterator over the units in this module.

pub fn functions<'a>(&'a self) -> impl Iterator<Item = &'a Function> + 'a

Return an iterator over the functions in this module.

pub fn processes<'a>(&'a self) -> impl Iterator<Item = &'a Process> + 'a

Return an iterator over the processes in this module.

pub fn entities<'a>(&'a self) -> impl Iterator<Item = &'a Entity> + 'a

Return an iterator over the entities in this module.

pub fn declarations<'a>(
    &'a self
) -> impl Iterator<Item = (&'a UnitName, &'a Signature)> + 'a

Return an iterator over the external unit declarations in this module.

pub fn is_function(&self, unit: ModUnit) -> bool

Check whether a unit is a function.

pub fn is_process(&self, unit: ModUnit) -> bool

Check whether a unit is a process.

pub fn is_entity(&self, unit: ModUnit) -> bool

Check whether a unit is an entity.

pub fn is_declaration(&self, unit: ModUnit) -> bool

Check whether a unit is externally declared.

pub fn unit_name(&self, unit: ModUnit) -> &UnitName

Get the name of a unit.

pub fn unit_sig(&self, unit: ModUnit) -> &Signature

Get the signature of a unit.

pub fn get_function(&self, unit: ModUnit) -> Option<&Function>

Return a function in the module, or None if the unit is not a function.

pub fn get_function_mut(&mut self, unit: ModUnit) -> Option<&mut Function>

Return a mutable function in the module, or None if the unit is not a function.

pub fn function(&self, unit: ModUnit) -> &Function

Return a function in the module. Panic if the unit is not a function.

pub fn function_mut(&mut self, unit: ModUnit) -> &mut Function

Return a mutable function in the module. Panic if the unit is not a function.

pub fn get_process(&self, unit: ModUnit) -> Option<&Process>

Return a process in the module, or None if the unit is not a process.

pub fn get_process_mut(&mut self, unit: ModUnit) -> Option<&mut Process>

Return a mutable process in the module, or None if the unit is not a process.

pub fn process(&self, unit: ModUnit) -> &Process

Return a process in the module. Panic if the unit is not a process.

pub fn process_mut(&mut self, unit: ModUnit) -> &mut Process

Return a mutable process in the module. Panic if the unit is not a process.

pub fn get_entity(&self, unit: ModUnit) -> Option<&Entity>

Return an entity in the module, or None if the unit is not an entity.

pub fn get_entity_mut(&mut self, unit: ModUnit) -> Option<&mut Entity>

Return a mutable entity in the module, or None if the unit is not an entity.

pub fn entity(&self, unit: ModUnit) -> &Entity

Return an entity in the module. Panic if the unit is not an entity.

pub fn entity_mut(&mut self, unit: ModUnit) -> &mut Entity

Return a mutable entity in the module. Panic if the unit is not an entity.

pub fn symbols<'a>(&'a self) -> impl Iterator<Item = (&UnitName, ModUnit)> + 'a

Return an iterator over the symbols in the module.

pub fn local_symbols<'a>(
    &'a self
) -> impl Iterator<Item = (&UnitName, ModUnit)> + 'a

Return an iterator over the local symbols in the module.

pub fn global_symbols<'a>(
    &'a self
) -> impl Iterator<Item = (&UnitName, ModUnit)> + 'a

Return an iterator over the global symbols in the module.

pub fn is_linked(&self) -> bool

Check whether the module is internally linked.

Adding or modifying a unit invalidates the linkage within the module.

pub fn link(&mut self)

Locally link the module.

pub fn verify(&self)

Panic if the module is not well-formed.

Trait Implementations

impl Index<ModUnit> for Module

type Output = ModUnitData

The returned type after indexing.

fn index(&self, idx: ModUnit) -> &ModUnitData

Performs the indexing (container[index]) operation.

impl IndexMut<ModUnit> for Module

fn index_mut(&mut self, idx: ModUnit) -> &mut ModUnitData

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