haloumi-llzk 0.5.15

Haloumi backend to LLZK.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#![doc = include_str!("../README.md")]
#![deny(rustdoc::broken_intra_doc_links)]
#![deny(missing_debug_implementations)]
#![deny(missing_docs)]

use std::io::Write;

use codegen::LlzkCodegen;
use haloumi_backend::Backend;
use llzk::prelude::ModuleExt;
use melior::ir::Module;
use state::LlzkCodegenState;

pub use params::LlzkParams;

mod codegen;
mod counter;
pub mod error;
mod extras;
mod factory;
mod lowering;
mod params;
mod state;

/// Instance of a [`Backend`] prepared for lowering to LLZK.
pub type LlzkBackend<'c, 's> = Backend<LlzkCodegen<'c, 's>, LlzkCodegenState<'c>>;

/// Output produced by the LLZK backend.
#[derive(Debug)]
pub struct LlzkOutput<'c> {
    module: Module<'c>,
}

impl<'c> LlzkOutput<'c> {
    /// Returns the inner [`melior::ir::Module`].
    pub fn module(&self) -> &Module<'c> {
        &self.module
    }

    /// Writes the output as bytecode.
    ///
    /// This method is meant for clients that need to write the result of the LLZK backend but
    /// don't want to bring the `llzk` as a dependency.
    pub fn dump(&self, dest: &mut dyn Write) -> std::io::Result<()> {
        self.module.write_bytecode(dest)
    }
}

impl<'c> From<Module<'c>> for LlzkOutput<'c> {
    fn from(module: Module<'c>) -> Self {
        Self { module }
    }
}

impl std::fmt::Display for LlzkOutput<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.module.as_operation())
    }
}