Struct EmitFuncContext 

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

A context for emitting an LLVM function.

One of the primary interfaces for implementing codegen extensions. We have methods for:

• Converting from hugr Types to LLVM Types;
• Maintaining MailBox for each Wire in the FuncDefn;
• Accessing the CodegenExtsMap;
• Accessing an in internal Builder.

The internal Builder must always be positioned at the end of a BasicBlock. This invariant is not checked when the builder is accessed through EmitFuncContext::builder.

MailBoxes are stack allocations that are allocaed in the first basic block of the function, read from to get the input values of each node, and written to with the output values of each node.

Implementations

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

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

Returns the inkwell Context.

pub fn extensions(&self) -> Rc<CodegenExtsMap<'a, H>>

Returns the internal CodegenExtsMap .

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

Returns a new TypingSession.

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

Convert hugr 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 get_func_defn( &self, node: FatNode<'_, FuncDefn, H>, ) -> Result<FunctionValue<'c>>

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

The name of the result may have been mangled.

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

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

The name of the result may have been mangled.

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

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

The name undergoes no mangling. The FunctionValue will have inkwell::module::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 inkwell::module::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 push_todo_func(&mut self, node: FatNode<'_, FuncDefn, H>)

Used when emitters encounter a scoped definition. node will be returned from EmitFuncContext::finish.

pub fn func(&self) -> FunctionValue<'c>

Returns the current FunctionValue being emitted.

pub fn builder(&self) -> &Builder<'c>

Returns the internal Builder. Callers must ensure that it is positioned at the end of a basic block. This invariant is not checked(it doesn’t seem possible to check it).

pub fn new( emit_context: EmitModuleContext<'c, 'a, H>, func: FunctionValue<'c>, ) -> Result<EmitFuncContext<'c, 'a, H>>

Creates a new EmitFuncContext for func, taking ownership of emit_context. emit_context will be returned in EmitFuncContext::finish.

If func has any existing BasicBlocks we will fail.

TODO on failure return emit_context

pub fn new_row_mail_box<'t>( &mut self, ts: impl IntoIterator<Item = &'t Type>, name: impl AsRef<str>, ) -> Result<RowMailBox<'c>>

Create a new anonymous RowMailBox. This mailbox is not mapped to any Wires, and so will not interact with any mailboxes returned from EmitFuncContext::node_ins_rmb or EmitFuncContext::node_outs_rmb.

pub fn build_positioned_new_block<T>( &mut self, name: impl AsRef<str>, before: Option<BasicBlock<'c>>, f: impl FnOnce(&mut Self, BasicBlock<'c>) -> T, ) -> T

Creates a new BasicBlock and calls f with the internal builder positioned at the start of that BasicBlock. The builder will be repositioned back to it’s location before f before this function returns.

pub fn build_positioned<T>( &mut self, block: BasicBlock<'c>, f: impl FnOnce(&mut Self) -> T, ) -> T

Positions the internal builder at the end of block and calls f. The builder will be repositioned back to it’s location before f before this function returns.

pub fn node_ins_rmb<'hugr, OT: 'hugr>( &mut self, node: FatNode<'hugr, OT, H>, ) -> Result<RowMailBox<'c>>

Returns a RowMailBox mapped to the input wires of node. When emitting a node input values are from this mailbox.

pub fn node_outs_rmb<'hugr, OT: 'hugr>( &mut self, node: FatNode<'hugr, OT, H>, ) -> Result<RowMailBox<'c>>

Returns a RowMailBox mapped to the output wires of node. When emitting a node output values are written to this mailbox.

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

pub fn finish(self) -> Result<(EmitModuleContext<'c, 'a, H>, HashSet<Node>)>

Consumes the EmitFuncContext and returns both the inner EmitModuleContext and the scoped FuncDefns that were encountered.