Struct EmitHugr 

pub struct EmitHugr<'c, 'a, H>
where
    'a: 'c,
{ /* private fields */ }

Emits HugrViews into an LLVM Module.

Implementations

impl<'c, 'a, H: HugrView<Node = Node>> EmitHugr<'c, 'a, H>

pub fn iw_context(&self) -> &'c Context

Returns a reference to the inner Context.

pub fn module(&self) -> &Module<'c>

Returns a reference to the inner Module. Note that this type has “interior mutability”, and this reference can be used to add functions and globals to the Module.

pub fn new( iw_context: &'c Context, module: Module<'c>, namer: Rc<Namer>, extensions: Rc<CodegenExtsMap<'a, H>>, ) -> Self

Creates a new EmitHugr. We take ownership of the Module, and return it in Self::finish.

pub fn emit_func(self, node: FatNode<'_, FuncDefn, H>) -> Result<Self>

Emits a FuncDefn into the inner Module.

node need not be a child of a hugr Module, but it will be emitted as a top-level function in the inner Module. Indeed, there are only top-level functions in LLVM IR.

Any child FuncDefn will also be emitted.

It is safe to emit the same node multiple times: the second and further emissions will be no-ops.

If any LLVM IR declaration which is to be emitted already exists in the Module and it differs from what would be emitted, then we fail.

pub fn emit_module(self, node: FatNode<'_, Module, H>) -> Result<Self>

Emits all children of a hugr Module.

Note that type aliases are not supported, and that hugr_core::ops::Const and hugr_core::ops::FuncDecl nodes are not emitted directly, but instead by emission of ops with static edges from them. So FuncDefn are the only interesting children.

pub fn finish(self) -> Module<'c>

Consumes the EmitHugr and returns the internal Module.