Skip to main content

autophagy_mlir/
lib.rs

1#![doc = include_str!("../README.md")]
2
3mod compiler;
4mod error;
5#[cfg(test)]
6mod test;
7
8pub use compiler::Compiler;
9pub use error::Error;
10
11#[cfg(test)]
12mod tests {
13    use super::*;
14    use crate::test::create_test_context;
15    use autophagy::Fn;
16    use melior::{
17        ir::{Location, Module},
18        pass::{self, PassManager},
19        Context, ExecutionEngine,
20    };
21
22    fn compile<'c>(context: &'c Context, module: &Module<'c>, r#fn: &Fn) -> Result<(), Error> {
23        Compiler::new(context, module).compile_fn(r#fn)?;
24
25        Ok(())
26    }
27
28    #[allow(clippy::assign_op_pattern)]
29    #[autophagy::quote]
30    fn factorial(mut x: i32) -> i32 {
31        let mut y = 1i32;
32
33        while x > 0i32 {
34            y = y * x;
35            x = x - 1i32;
36        }
37
38        y
39    }
40
41    #[test]
42    fn compile_factorial() {
43        let context = create_test_context();
44        let location = Location::unknown(&context);
45
46        let mut module = Module::new(location);
47
48        compile(&context, &module, &factorial_fn()).unwrap();
49
50        assert!(module.as_operation().verify());
51
52        let pass_manager = PassManager::new(&context);
53        pass_manager.add_pass(pass::conversion::create_func_to_llvm());
54
55        pass_manager
56            .nested_under("func.func")
57            .add_pass(pass::conversion::create_arith_to_llvm());
58        pass_manager
59            .nested_under("func.func")
60            .add_pass(pass::conversion::create_index_to_llvm());
61        pass_manager.add_pass(pass::conversion::create_scf_to_control_flow());
62        pass_manager.add_pass(pass::conversion::create_control_flow_to_llvm());
63        pass_manager.add_pass(pass::conversion::create_finalize_mem_ref_to_llvm());
64
65        assert_eq!(pass_manager.run(&mut module), Ok(()));
66        assert!(module.as_operation().verify());
67
68        let engine = ExecutionEngine::new(&module, 2, &[], false);
69
70        let mut argument = 5;
71        let mut result = -1;
72
73        assert_eq!(
74            unsafe {
75                engine.invoke_packed(
76                    "factorial",
77                    &mut [
78                        &mut argument as *mut _ as *mut _,
79                        &mut result as *mut _ as *mut _,
80                    ],
81                )
82            },
83            Ok(())
84        );
85
86        assert_eq!(argument, 5);
87        assert_eq!(result, factorial(argument));
88    }
89
90    #[autophagy::quote]
91    fn fibonacci(x: i32) -> i32 {
92        if x <= 0i32 {
93            0i32
94        } else if x == 1i32 {
95            1i32
96        } else {
97            fibonacci(x - 1i32) + fibonacci(x - 2i32)
98        }
99    }
100
101    #[test]
102    fn compile_fibonacci() {
103        let context = create_test_context();
104        let location = Location::unknown(&context);
105
106        let mut module = Module::new(location);
107
108        compile(&context, &module, &fibonacci_fn()).unwrap();
109
110        assert!(module.as_operation().verify());
111
112        let pass_manager = PassManager::new(&context);
113        pass_manager.add_pass(pass::conversion::create_func_to_llvm());
114
115        pass_manager
116            .nested_under("func.func")
117            .add_pass(pass::conversion::create_arith_to_llvm());
118        pass_manager
119            .nested_under("func.func")
120            .add_pass(pass::conversion::create_index_to_llvm());
121        pass_manager.add_pass(pass::conversion::create_scf_to_control_flow());
122        pass_manager.add_pass(pass::conversion::create_control_flow_to_llvm());
123        pass_manager.add_pass(pass::conversion::create_finalize_mem_ref_to_llvm());
124
125        assert_eq!(pass_manager.run(&mut module), Ok(()));
126        assert!(module.as_operation().verify());
127
128        let engine = ExecutionEngine::new(&module, 2, &[], false);
129
130        let mut argument = 5;
131        let mut result = -1;
132
133        assert_eq!(
134            unsafe {
135                engine.invoke_packed(
136                    "fibonacci",
137                    &mut [
138                        &mut argument as *mut _ as *mut _,
139                        &mut result as *mut _ as *mut _,
140                    ],
141                )
142            },
143            Ok(())
144        );
145
146        assert_eq!(argument, 5);
147        assert_eq!(result, fibonacci(argument));
148    }
149}