Struct EmitModuleContext

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

A context holding data required for emitting HUGRs into an LLVM module. This includes the module itself, a set of extensions for lowering custom elements, and policy for naming various HUGR elements.

'c names the lifetime of the LLVM context, while 'a names the lifetime of other internal references.

Implementations

impl<'c, 'a, H> EmitModuleContext<'c, 'a, H>

pub fn llvm_type(&self, hugr_type: &HugrType) -> Result<BasicTypeEnum<'c>>

Convert a HugrType into an LLVM Type.

pub fn llvm_func_type( &self, hugr_type: &HugrFuncType, ) -> Result<FunctionType<'c>>

Convert a HugrFuncType into an LLVM FunctionType.

pub fn llvm_sum_type(&self, sum_type: HugrSumType) -> Result<LLVMSumType<'c>>

Convert a hugr HugrSumType into an LLVM LLVMSumType.

pub fn name_func(&self, name: impl AsRef<str>, node: Node) -> String

Mangle the name of a FuncDefn or a FuncDecl.

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

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

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

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 extensions(&self) -> Rc<CodegenExtsMap<'a, H>>

Returns a reference to the inner CodegenExtsMap.

pub fn typing_session(&self) -> TypingSession<'c, 'a>

Returns a TypingSession constructed from it’s members.

pub fn get_func_defn<'hugr>( &self, node: FatNode<'hugr, FuncDefn, H>, ) -> Result<FunctionValue<'c>>

where H: HugrView<Node = Node>,

Adds or gets the FunctionValue in the Module corresponding to the given FuncDefn.

The name of the result is mangled by EmitModuleContext::name_func.

pub fn get_func_decl<'hugr>( &self, node: FatNode<'hugr, FuncDecl, H>, ) -> Result<FunctionValue<'c>>

where H: HugrView<Node = Node>,

Adds or gets the FunctionValue in the Module corresponding to the given FuncDecl.

The name of the result is mangled by EmitModuleContext::name_func.

pub fn get_extern_func( &self, symbol: impl AsRef<str>, typ: FunctionType<'c>, ) -> Result<FunctionValue<'c>>

Adds or get the FunctionValue in the Module with the given symbol and function type.

The name undergoes no mangling. The FunctionValue will have Linkage::External.

If this function is called multiple times with the same arguments it will return the same FunctionValue.

If a function with the given name exists but the type does not match then an Error is returned.

pub fn get_global( &self, symbol: impl AsRef<str>, typ: impl BasicType<'c>, constant: bool, ) -> Result<GlobalValue<'c>>

Adds or gets the GlobalValue in the Module corresponding to the given symbol and LLVM type.

The name will not be mangled.

If a global with the given name exists but the type or constant-ness does not match then an error will be returned.

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

Consumes the EmitModuleContext and returns the internal Module.