Updated JIT example to use lifetimes

Author: TheDan64

README.md

@@ -63,14 +63,48 @@ use std::error::Error;
 /// do `unsafe` operations internally.
 type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;
 
-fn main() -> Result<(), Box<Error>> {
+struct CodeGen<'ctx> {
+    context: &'ctx Context,
+    module: Module<'ctx>,
+    builder: Builder<'ctx>,
+    execution_engine: ExecutionEngine<'ctx>,
+}
+
+impl<'ctx> CodeGen<'ctx> {
+    fn jit_compile_sum(&self) -> Option<JitFunction<SumFunc>> {
+        let i64_type = self.context.i64_type();
+        let fn_type = i64_type.fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);
+        let function = self.module.add_function("sum", fn_type, None);
+        let basic_block = self.context.append_basic_block(function, "entry");
+
+        self.builder.position_at_end(&basic_block);
+
+        let x = function.get_nth_param(0)?.into_int_value();
+        let y = function.get_nth_param(1)?.into_int_value();
+        let z = function.get_nth_param(2)?.into_int_value();
+
+        let sum = self.builder.build_int_add(x, y, "sum");
+        let sum = self.builder.build_int_add(sum, z, "sum");
+
+        self.builder.build_return(Some(&sum));
+
+        unsafe { self.execution_engine.get_function("sum").ok() }
+    }
+}
+
+
+fn main() -> Result<(), Box<dyn Error>> {
     let context = Context::create();
     let module = context.create_module("sum");
-    let builder = context.create_builder();
     let execution_engine = module.create_jit_execution_engine(OptimizationLevel::None)?;
+    let codegen = CodeGen {
+        context: &context,
+        module,
+        builder: context.create_builder(),
+        execution_engine,
+    };
 
-    let sum = jit_compile_sum(&context, &module, &builder, &execution_engine)
-        .ok_or("Unable to JIT compile `sum`")?;
+    let sum = codegen.jit_compile_sum().ok_or("Unable to JIT compile `sum`")?;
 
     let x = 1u64;
     let y = 2u64;
@@ -83,32 +117,6 @@ fn main() -> Result<(), Box<Error>> {
 
     Ok(())
 }
-
-fn jit_compile_sum(
-    context: &Context,
-    module: &Module,
-    builder: &Builder,
-    execution_engine: &ExecutionEngine,
-) -> Option<JitFunction<SumFunc>> {
-    let i64_type = context.i64_type();
-    let fn_type = i64_type.fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);
-
-    let function = module.add_function("sum", fn_type, None);
-    let basic_block = context.append_basic_block(&function, "entry");
-
-    builder.position_at_end(&basic_block);
-
-    let x = function.get_nth_param(0)?.into_int_value();
-    let y = function.get_nth_param(1)?.into_int_value();
-    let z = function.get_nth_param(2)?.into_int_value();
-
-    let sum = builder.build_int_add(x, y, "sum");
-    let sum = builder.build_int_add(sum, z, "sum");
-
-    builder.build_return(Some(&sum));
-
-    unsafe { execution_engine.get_function("sum").ok() }
-}
 ```
 
 <sup>1</sup> There are two uses of `unsafe` in this example because the actual

examples/jit.rs

@@ -14,40 +14,48 @@ use std::error::Error;
 /// do `unsafe` operations internally.
 type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;
 
-fn jit_compile_sum<'ctx>(
+struct CodeGen<'ctx> {
     context: &'ctx Context,
-    module: &Module<'ctx>,
-    builder: &Builder<'ctx>,
-    execution_engine: &ExecutionEngine<'ctx>,
-) -> Option<JitFunction<SumFunc>> {
-    let i64_type = context.i64_type();
-    let fn_type = i64_type.fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);
+    module: Module<'ctx>,
+    builder: Builder<'ctx>,
+    execution_engine: ExecutionEngine<'ctx>,
+}
 
-    let function = module.add_function("sum", fn_type, None);
-    let basic_block = context.append_basic_block(function, "entry");
+impl<'ctx> CodeGen<'ctx> {
+    fn jit_compile_sum(&self) -> Option<JitFunction<SumFunc>> {
+        let i64_type = self.context.i64_type();
+        let fn_type = i64_type.fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);
+        let function = self.module.add_function("sum", fn_type, None);
+        let basic_block = self.context.append_basic_block(function, "entry");
 
-    builder.position_at_end(&basic_block);
+        self.builder.position_at_end(&basic_block);
 
-    let x = function.get_nth_param(0)?.into_int_value();
-    let y = function.get_nth_param(1)?.into_int_value();
-    let z = function.get_nth_param(2)?.into_int_value();
+        let x = function.get_nth_param(0)?.into_int_value();
+        let y = function.get_nth_param(1)?.into_int_value();
+        let z = function.get_nth_param(2)?.into_int_value();
 
-    let sum = builder.build_int_add(x, y, "sum");
-    let sum = builder.build_int_add(sum, z, "sum");
+        let sum = self.builder.build_int_add(x, y, "sum");
+        let sum = self.builder.build_int_add(sum, z, "sum");
 
-    builder.build_return(Some(&sum));
+        self.builder.build_return(Some(&sum));
 
-    unsafe { execution_engine.get_function("sum").ok() }
+        unsafe { self.execution_engine.get_function("sum").ok() }
+    }
 }
 
+
 fn main() -> Result<(), Box<dyn Error>> {
     let context = Context::create();
     let module = context.create_module("sum");
-    let builder = context.create_builder();
     let execution_engine = module.create_jit_execution_engine(OptimizationLevel::None)?;
+    let codegen = CodeGen {
+        context: &context,
+        module,
+        builder: context.create_builder(),
+        execution_engine,
+    };
 
-    let sum = jit_compile_sum(&context, &module, &builder, &execution_engine)
-        .ok_or("Unable to JIT compile `sum`")?;
+    let sum = codegen.jit_compile_sum().ok_or("Unable to JIT compile `sum`")?;
 
     let x = 1u64;
     let y = 2u64;