llzk 0.3.1

Rust bindings to the LLZK C API.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! LLZK passes.

use llzk_macro::passes;

passes!(
    "LLZKTransformation",
    [
        mlirCreateLLZKTransformationRedundantOperationEliminationPass,
        mlirCreateLLZKTransformationRedundantReadAndWriteEliminationPass,
        mlirCreateLLZKTransformationUnusedDeclarationEliminationPass,
    ]
);

#[cfg(feature = "pcl-backend")]
passes!(
    "PCLTransformation",
    [mlirCreatePCLTransformationPCLLoweringPass,]
);

passes!(
    "LLZKArrayTransformation",
    [mlirCreateLLZKArrayTransformationArrayToScalarPass]
);

passes!(
    "LLZKIncludeTransformation",
    [mlirCreateLLZKIncludeTransformationInlineIncludesPass]
);

passes!(
    "LLZKPolymorphicTransformation",
    [mlirCreateLLZKPolymorphicTransformationFlatteningPass]
);

passes!(
    "LLZKValidation",
    [mlirCreateLLZKValidationMemberWriteValidatorPass]
);

/// Registers all the available LLZK passes.
pub fn register_all_llzk_passes() {
    register_llzk_transformation_passes();
    #[cfg(feature = "pcl-backend")]
    register_pcl_transformation_passes();
    register_llzk_array_transformation_passes();
    register_llzk_include_transformation_passes();
    register_llzk_polymorphic_transformation_passes();
    register_llzk_validation_passes();
}

#[cfg(test)]
mod tests {
    //! Tests to make sure that the expected function were generated.

    use melior::{Context, pass::PassManager};

    #[cfg(feature = "pcl-backend")]
    #[test]
    fn generated_pcl_pass_functions() {
        let ctx = Context::new();
        let pm = PassManager::new(&ctx);
        super::register_pcl_transformation_passes();
        super::register_pcl_lowering_pass();
        pm.add_pass(super::create_pcl_lowering_pass());
    }

    #[test]
    fn generated_pass_functions() {
        let ctx = Context::new();
        // Use a PassManager to manage the lifetime of the created passes to avoid memory leaks.
        let pm = PassManager::new(&ctx);
        super::register_llzk_transformation_passes();
        super::register_redundant_operation_elimination_pass();
        super::register_redundant_read_and_write_elimination_pass();
        super::register_unused_declaration_elimination_pass();
        pm.add_pass(super::create_redundant_operation_elimination_pass());
        pm.add_pass(super::create_redundant_read_and_write_elimination_pass());
        pm.add_pass(super::create_unused_declaration_elimination_pass());

        super::register_llzk_array_transformation_passes();
        super::register_array_to_scalar_pass();
        pm.add_pass(super::create_array_to_scalar_pass());

        super::register_llzk_include_transformation_passes();
        super::register_inline_includes_pass();
        pm.add_pass(super::create_inline_includes_pass());

        super::register_llzk_polymorphic_transformation_passes();
        super::register_flattening_pass();
        pm.add_pass(super::create_flattening_pass());

        super::register_llzk_validation_passes();
        super::register_member_write_validator_pass();
        pm.add_pass(super::create_member_write_validator_pass());
    }
}