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}