Trait BorrowArrayCodegen 

pub trait BorrowArrayCodegen: Clone {
    // Required method
    fn emit_panic<H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'_, '_, H>,
        err: BasicValueEnum<'_>,
    ) -> Result<()>;

    // Provided methods
    fn emit_allocate_array<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        size: IntValue<'c>,
    ) -> Result<PointerValue<'c>> { ... }
    fn emit_free_array<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        ptr: PointerValue<'c>,
    ) -> Result<()> { ... }
    fn array_type<'c>(
        &self,
        session: &TypingSession<'c, '_>,
        elem_ty: BasicTypeEnum<'c>,
        _size: u64,
    ) -> impl BasicType<'c> { ... }
    fn emit_array_value<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        value: &BArrayValue,
    ) -> Result<BasicValueEnum<'c>> { ... }
    fn emit_array_op<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayOp,
        inputs: Vec<BasicValueEnum<'c>>,
        outputs: RowPromise<'c>,
    ) -> Result<()> { ... }
    fn emit_array_unsafe_op<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayUnsafeOp,
        inputs: Vec<BasicValueEnum<'c>>,
        outputs: RowPromise<'c>,
    ) -> Result<()> { ... }
    fn emit_array_clone<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayClone,
        array_v: BasicValueEnum<'c>,
    ) -> Result<(BasicValueEnum<'c>, BasicValueEnum<'c>)> { ... }
    fn emit_array_discard<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayDiscard,
        array_v: BasicValueEnum<'c>,
    ) -> Result<()> { ... }
    fn emit_array_repeat<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayRepeat,
        func: BasicValueEnum<'c>,
    ) -> Result<BasicValueEnum<'c>> { ... }
    fn emit_array_scan<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayScan,
        src_array: BasicValueEnum<'c>,
        func: BasicValueEnum<'c>,
        initial_accs: &[BasicValueEnum<'c>],
    ) -> Result<(BasicValueEnum<'c>, Vec<BasicValueEnum<'c>>)> { ... }
    fn emit_to_array_op<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayToArray,
        barray_v: BasicValueEnum<'c>,
    ) -> Result<BasicValueEnum<'c>> { ... }
    fn emit_from_array_op<'c, H: HugrView<Node = Node>>(
        &self,
        ctx: &mut EmitFuncContext<'c, '_, H>,
        op: BArrayFromArray,
        array_v: BasicValueEnum<'c>,
    ) -> Result<BasicValueEnum<'c>> { ... }
}

A helper trait for customising the lowering of borrow_array, including its types, hugr_core::ops::constant::CustomConsts, and ops.

By default, all arrays are allocated on the heap using the standard libc malloc and free functions. This behaviour can be customised by providing a different implementation for BorrowArrayCodegen::emit_allocate_array and BorrowArrayCodegen::emit_free_array.

See crate::extension::collections::borrow_array for details.

Required Methods

fn emit_panic<H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'_, '_, H>, err: BasicValueEnum<'_>, ) -> Result<()>

Emit instructions to halt execution with the error err.

This should be consistent with the panic implementation from the PreludeCodegen.

Provided Methods

fn emit_allocate_array<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, size: IntValue<'c>, ) -> Result<PointerValue<'c>>

Emit an allocation of size bytes and return the corresponding pointer.

The default implementation allocates on the heap by emitting a call to the standard libc malloc function.

fn emit_free_array<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, ptr: PointerValue<'c>, ) -> Result<()>

Emit an deallocation of a pointer.

The default implementation emits a call to the standard libc free function.

fn array_type<'c>( &self, session: &TypingSession<'c, '_>, elem_ty: BasicTypeEnum<'c>, _size: u64, ) -> impl BasicType<'c>

Return the llvm type of hugr_core::std_extensions::collections::borrow_array::BORROW_ARRAY_TYPENAME.

fn emit_array_value<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, value: &BArrayValue, ) -> Result<BasicValueEnum<'c>>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayValue.

fn emit_array_op<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayOp, inputs: Vec<BasicValueEnum<'c>>, outputs: RowPromise<'c>, ) -> Result<()>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayOp.

fn emit_array_unsafe_op<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayUnsafeOp, inputs: Vec<BasicValueEnum<'c>>, outputs: RowPromise<'c>, ) -> Result<()>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayUnsafeOp.

fn emit_array_clone<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayClone, array_v: BasicValueEnum<'c>, ) -> Result<(BasicValueEnum<'c>, BasicValueEnum<'c>)>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayClone operation.

fn emit_array_discard<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayDiscard, array_v: BasicValueEnum<'c>, ) -> Result<()>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayDiscard operation.

fn emit_array_repeat<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayRepeat, func: BasicValueEnum<'c>, ) -> Result<BasicValueEnum<'c>>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayRepeat op.

fn emit_array_scan<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayScan, src_array: BasicValueEnum<'c>, func: BasicValueEnum<'c>, initial_accs: &[BasicValueEnum<'c>], ) -> Result<(BasicValueEnum<'c>, Vec<BasicValueEnum<'c>>)>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayScan op.

Returns the resulting array and the final values of the accumulators.

fn emit_to_array_op<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayToArray, barray_v: BasicValueEnum<'c>, ) -> Result<BasicValueEnum<'c>>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayToArray.

fn emit_from_array_op<'c, H: HugrView<Node = Node>>( &self, ctx: &mut EmitFuncContext<'c, '_, H>, op: BArrayFromArray, array_v: BasicValueEnum<'c>, ) -> Result<BasicValueEnum<'c>>

Emit a hugr_core::std_extensions::collections::borrow_array::BArrayFromArray.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<PCG: PreludeCodegen> BorrowArrayCodegen for DefaultBorrowArrayCodegen<PCG>