Merge pull request rust-lang#57 from RReverser/llvm4-0

TheDan64 · web-flow · commit 949634db3b37 · 2018-10-27T12:30:41.000-04:00
Provide safe function wrappers
diff --git a/README.md b/README.md
@@ -53,14 +53,14 @@ extern crate inkwell;
 use inkwell::OptimizationLevel;
 use inkwell::builder::Builder;
 use inkwell::context::Context;
-use inkwell::execution_engine::{ExecutionEngine, Symbol};
+use inkwell::execution_engine::{ExecutionEngine, JitFunction};
 use inkwell::module::Module;
 use inkwell::targets::{InitializationConfig, Target};
 use std::error::Error;
 
 /// Convenience type alias for the `sum` function.
 ///
-/// Calling `sum` is innately `unsafe` because there's no guarantee it doesn't
+/// Calling this is innately `unsafe` because there's no guarantee it doesn't
 /// do `unsafe` operations internally.
 type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;
 
@@ -83,22 +83,21 @@ fn run() -> Result<(), Box<Error>> {
     let z = 3u64;
 
     unsafe {
-        println!("{} + {} + {} = {}", x, y, z, sum(x, y, z));
-        assert_eq!(sum(x, y, z), x + y + z);
+        println!("{} + {} + {} = {}", x, y, z, sum.call(x, y, z));
+        assert_eq!(sum.call(x, y, z), x + y + z);
     }
 
     Ok(())
 }
 
-fn jit_compile_sum(
+fn jit_compile_sum<'engine>(
     context: &Context,
     module: &Module,
     builder: &Builder,
-    execution_engine: &ExecutionEngine,
-) -> Option<Symbol<SumFunc>> {
+    execution_engine: &'engine ExecutionEngine,
+) -> Option<JitFunction<'engine, SumFunc>> {
     let i64_type = context.i64_type();
-    let fn_type_params = [i64_type.into(), i64_type.into(), i64_type.into()];
-    let fn_type = i64_type.fn_type(&fn_type_params, false);
+    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");
diff --git a/examples/jit.rs b/examples/jit.rs
@@ -3,7 +3,7 @@ extern crate inkwell;
 use inkwell::OptimizationLevel;
 use inkwell::builder::Builder;
 use inkwell::context::Context;
-use inkwell::execution_engine::{ExecutionEngine, Symbol};
+use inkwell::execution_engine::{ExecutionEngine, JitFunction};
 use inkwell::module::Module;
 use inkwell::targets::{InitializationConfig, Target};
 use std::error::Error;
@@ -14,12 +14,12 @@ use std::error::Error;
 /// do `unsafe` operations internally.
 type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;
 
-fn jit_compile_sum(
+fn jit_compile_sum<'engine>(
     context: &Context,
     module: &Module,
     builder: &Builder,
-    execution_engine: &ExecutionEngine,
-) -> Option<Symbol<SumFunc>> {
+    execution_engine: &'engine ExecutionEngine,
+) -> Option<JitFunction<'engine, SumFunc>> {
     let i64_type = context.i64_type();
     let fn_type = i64_type.fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);
 
@@ -54,8 +54,8 @@ fn run() -> Result<(), Box<Error>> {
     let z = 3u64;
 
     unsafe {
-        println!("{} + {} + {} = {}", x, y, z, sum(x, y, z));
-        assert_eq!(sum(x, y, z), x + y + z);
+        println!("{} + {} + {} = {}", x, y, z, sum.call(x, y, z));
+        assert_eq!(sum.call(x, y, z), x + y + z);
     }
 
     Ok(())
diff --git a/examples/kaleidoscope/main.rs b/examples/kaleidoscope/main.rs
@@ -1330,7 +1330,7 @@ pub fn main() {
             };
 
             unsafe {
-                println!("=> {}", compiled_fn());
+                println!("=> {}", compiled_fn.call());
             }
         }
     }
diff --git a/src/execution_engine.rs b/src/execution_engine.rs
@@ -11,6 +11,7 @@ use std::rc::Rc;
 use std::ops::Deref;
 use std::ffi::CString;
 use std::fmt::{self, Debug, Display, Formatter};
+use std::marker::PhantomData;
 use std::mem::{forget, zeroed, transmute_copy, size_of};
 
 #[derive(Debug, PartialEq, Eq)]
@@ -270,7 +271,7 @@ impl ExecutionEngine {
     /// // fetch our JIT'd function and execute it
     /// unsafe {
     ///     let test_fn = ee.get_function::<unsafe extern "C" fn() -> f64>("test_fn").unwrap();
-    ///     let return_value = test_fn();
+    ///     let return_value = test_fn.call();
     ///     assert_eq!(return_value, 64.0);
     /// }
     /// ```
@@ -280,12 +281,12 @@ impl ExecutionEngine {
     /// It is the caller's responsibility to ensure they call the function with
     /// the correct signature and calling convention.
     ///
-    /// The `Symbol` wrapper ensures a function won't accidentally outlive the
+    /// The `JitFunction` wrapper ensures a function won't accidentally outlive the
     /// execution engine it came from, but adding functions after calling this
     /// method *may* invalidate the function pointer.
     ///
     /// [`UnsafeFunctionPointer`]: trait.UnsafeFunctionPointer.html
-    pub unsafe fn get_function<F>(&self, fn_name: &str) -> Result<Symbol<F>, FunctionLookupError>
+    pub unsafe fn get_function<'engine, F>(&'engine self, fn_name: &str) -> Result<JitFunction<'engine, F>, FunctionLookupError>
     where
         F: UnsafeFunctionPointer,
     {
@@ -313,8 +314,8 @@ impl ExecutionEngine {
         assert_eq!(size_of::<F>(), size_of::<usize>(),
             "The type `F` must have the same size as a function pointer");
 
-        Ok(Symbol {
-            _execution_engine: self.execution_engine.clone(),
+        Ok(JitFunction {
+            _execution_engine: PhantomData,
             inner: transmute_copy(&address),
         })
     }
@@ -432,59 +433,58 @@ impl Deref for ExecEngineInner {
     }
 }
 
-/// A wrapper around a function pointer which ensures the symbol being pointed
+/// A wrapper around a function pointer which ensures the function being pointed
 /// to doesn't accidentally outlive its execution engine.
 #[derive(Clone)]
-pub struct Symbol<F> {
-    _execution_engine: ExecEngineInner,
+pub struct JitFunction<'engine, F> {
+    _execution_engine: PhantomData<&'engine ExecutionEngine>,
     inner: F,
 }
 
-impl<F: UnsafeFunctionPointer> Deref for Symbol<F> {
-    type Target = F;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<F> Debug for Symbol<F> {
+impl<'engine, F> Debug for JitFunction<'engine, F> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.debug_tuple("Symbol")
+        f.debug_tuple("JitFunction")
             .field(&"<unnamed>")
             .finish()
     }
 }
 
 /// Marker trait representing an unsafe function pointer (`unsafe extern "C" fn(A, B, ...) -> Output`).
-pub trait UnsafeFunctionPointer: private::Sealed + Copy {}
+pub trait UnsafeFunctionPointer: private::SealedUnsafeFunctionPointer {}
 
 mod private {
     /// A sealed trait which ensures nobody outside this crate can implement
     /// `UnsafeFunctionPointer`.
     ///
     /// See https://rust-lang-nursery.github.io/api-guidelines/future-proofing.html
-    pub trait Sealed {}
+    pub trait SealedUnsafeFunctionPointer: Copy {}
 }
 
+impl<F: private::SealedUnsafeFunctionPointer> UnsafeFunctionPointer for F {}
+
 macro_rules! impl_unsafe_fn {
+    (@recurse $first:ident $( , $rest:ident )*) => {
+        impl_unsafe_fn!($( $rest ),*);
+    };
+
+    (@recurse) => {};
+
     ($( $param:ident ),*) => {
-        impl<Output, $( $param ),*> private::Sealed for unsafe extern "C" fn($( $param ),*) -> Output {}
-        impl<Output, $( $param ),*> UnsafeFunctionPointer for unsafe extern "C" fn($( $param ),*) -> Output {}
+        impl<'engine, Output, $( $param ),*> private::SealedUnsafeFunctionPointer for unsafe extern "C" fn($( $param ),*) -> Output {}
+
+        impl<'engine, Output, $( $param ),*> JitFunction<'engine, unsafe extern "C" fn($( $param ),*) -> Output> {
+            /// This method allows you to call the underlying function while making
+            /// sure that the backing storage is not dropped too early and
+            /// preserves the `unsafe` marker for any calls.
+            #[allow(non_snake_case)]
+            #[inline(always)]
+            pub unsafe fn call(&self, $( $param: $param ),*) -> Output {
+                (self.inner)($( $param ),*)
+            }
+        }
+
+        impl_unsafe_fn!(@recurse $( $param ),*);
     };
 }
 
-impl_unsafe_fn!();
-impl_unsafe_fn!(A);
-impl_unsafe_fn!(A, B);
-impl_unsafe_fn!(A, B, C);
-impl_unsafe_fn!(A, B, C, D);
-impl_unsafe_fn!(A, B, C, D, E);
-impl_unsafe_fn!(A, B, C, D, E, F);
-impl_unsafe_fn!(A, B, C, D, E, F, G);
-impl_unsafe_fn!(A, B, C, D, E, F, G, H);
-impl_unsafe_fn!(A, B, C, D, E, F, G, H, I);
-impl_unsafe_fn!(A, B, C, D, E, F, G, H, I, J);
-impl_unsafe_fn!(A, B, C, D, E, F, G, H, I, J, K);
-impl_unsafe_fn!(A, B, C, D, E, F, G, H, I, J, K, L);
 impl_unsafe_fn!(A, B, C, D, E, F, G, H, I, J, K, L, M);
diff --git a/src/targets.rs b/src/targets.rs
@@ -1,3 +1,4 @@
+#[llvm_versions(7.0 => latest)]
 use either::Either;
 use llvm_sys::target::{LLVMTargetDataRef, LLVMCopyStringRepOfTargetData, LLVMSizeOfTypeInBits, LLVMCreateTargetData, LLVMByteOrder, LLVMPointerSize, LLVMByteOrdering, LLVMStoreSizeOfType, LLVMABISizeOfType, LLVMABIAlignmentOfType, LLVMCallFrameAlignmentOfType, LLVMPreferredAlignmentOfType, LLVMPreferredAlignmentOfGlobal, LLVMElementAtOffset, LLVMOffsetOfElement, LLVMDisposeTargetData, LLVMPointerSizeForAS, LLVMIntPtrType, LLVMIntPtrTypeForAS, LLVMIntPtrTypeInContext, LLVMIntPtrTypeForASInContext};
 use llvm_sys::target_machine::{LLVMGetFirstTarget, LLVMTargetRef, LLVMGetNextTarget, LLVMGetTargetFromName, LLVMGetTargetFromTriple, LLVMGetTargetName, LLVMGetTargetDescription, LLVMTargetHasJIT, LLVMTargetHasTargetMachine, LLVMTargetHasAsmBackend, LLVMTargetMachineRef, LLVMDisposeTargetMachine, LLVMGetTargetMachineTarget, LLVMGetTargetMachineTriple, LLVMSetTargetMachineAsmVerbosity, LLVMCreateTargetMachine, LLVMGetTargetMachineCPU, LLVMGetTargetMachineFeatureString, LLVMGetDefaultTargetTriple, LLVMAddAnalysisPasses, LLVMCodeGenOptLevel, LLVMCodeModel, LLVMRelocMode, LLVMCodeGenFileType, LLVMTargetMachineEmitToMemoryBuffer, LLVMTargetMachineEmitToFile};
diff --git a/tests/all/test_builder.rs b/tests/all/test_builder.rs
@@ -4,7 +4,6 @@ use self::inkwell::{AddressSpace, OptimizationLevel};
 use self::inkwell::context::Context;
 use self::inkwell::builder::Builder;
 use self::inkwell::targets::{InitializationConfig, Target};
-use self::inkwell::execution_engine::Symbol;
 
 use std::ffi::CString;
 use std::ptr::null;
@@ -137,17 +136,17 @@ fn test_null_checked_ptr_ops() {
     let execution_engine = module.create_jit_execution_engine(OptimizationLevel::None).unwrap();
 
     unsafe {
-        let check_null_index1: Symbol<unsafe extern "C" fn(*const i8) -> i8> = execution_engine.get_function("check_null_index1").unwrap();
+        let check_null_index1 = execution_engine.get_function::<unsafe extern "C" fn(*const i8) -> i8>("check_null_index1").unwrap();
 
         let array = &[100i8, 42i8];
 
-        assert_eq!(check_null_index1(null()), -1i8);
-        assert_eq!(check_null_index1(array.as_ptr()), 42i8);
+        assert_eq!(check_null_index1.call(null()), -1i8);
+        assert_eq!(check_null_index1.call(array.as_ptr()), 42i8);
 
-        let check_null_index2: Symbol<unsafe extern "C" fn(*const i8) -> i8> = execution_engine.get_function("check_null_index2").unwrap();
+        let check_null_index2 = execution_engine.get_function::<unsafe extern "C" fn(*const i8) -> i8>("check_null_index2").unwrap();
 
-        assert_eq!(check_null_index2(null()), -1i8);
-        assert_eq!(check_null_index2(array.as_ptr()), 42i8);
+        assert_eq!(check_null_index2.call(null()), -1i8);
+        assert_eq!(check_null_index2.call(array.as_ptr()), 42i8);
     }
 }
 
@@ -216,24 +215,24 @@ fn test_binary_ops() {
     unsafe {
         type BoolFunc = unsafe extern "C" fn(bool, bool) -> bool;
 
-        let and: Symbol<BoolFunc> = execution_engine.get_function("and").unwrap();
-        let or: Symbol<BoolFunc> = execution_engine.get_function("or").unwrap();
-        let xor: Symbol<BoolFunc> = execution_engine.get_function("xor").unwrap();
+        let and = execution_engine.get_function::<BoolFunc>("and").unwrap();
+        let or = execution_engine.get_function::<BoolFunc>("or").unwrap();
+        let xor = execution_engine.get_function::<BoolFunc>("xor").unwrap();
 
-        assert!(!and(false, false));
-        assert!(!and(true, false));
-        assert!(!and(false, true));
-        assert!(and(true, true));
+        assert!(!and.call(false, false));
+        assert!(!and.call(true, false));
+        assert!(!and.call(false, true));
+        assert!(and.call(true, true));
 
-        assert!(!or(false, false));
-        assert!(or(true, false));
-        assert!(or(false, true));
-        assert!(or(true, true));
+        assert!(!or.call(false, false));
+        assert!(or.call(true, false));
+        assert!(or.call(false, true));
+        assert!(or.call(true, true));
 
-        assert!(!xor(false, false));
-        assert!(xor(true, false));
-        assert!(xor(false, true));
-        assert!(!xor(true, true));
+        assert!(!xor.call(false, false));
+        assert!(xor.call(true, false));
+        assert!(xor.call(false, true));
+        assert!(!xor.call(true, true));
     }
 }
 
@@ -287,13 +286,13 @@ fn test_switch() {
     builder.build_return(Some(&double));
 
     unsafe {
-        let switch: Symbol<unsafe extern "C" fn(u8) -> u8> = execution_engine.get_function("switch").unwrap();
+        let switch = execution_engine.get_function::<unsafe extern "C" fn(u8) -> u8>("switch").unwrap();
 
-        assert_eq!(switch(0), 1);
-        assert_eq!(switch(1), 2);
-        assert_eq!(switch(3), 6);
-        assert_eq!(switch(10), 20);
-        assert_eq!(switch(42), 255);
+        assert_eq!(switch.call(0), 1);
+        assert_eq!(switch.call(1), 2);
+        assert_eq!(switch.call(3), 6);
+        assert_eq!(switch.call(10), 20);
+        assert_eq!(switch.call(42), 255);
     }
 }
 
@@ -357,37 +356,37 @@ fn test_bit_shifts() {
     builder.build_return(Some(&shift));
 
     unsafe {
-        let left_shift: Symbol<unsafe extern "C" fn(u8, u8) -> u8> = execution_engine.get_function("left_shift").unwrap();
-        let right_shift: Symbol<unsafe extern "C" fn(u8, u8) -> u8>  = execution_engine.get_function("right_shift").unwrap();
-        let right_shift_sign_extend: Symbol<unsafe extern "C" fn(i8, u8) -> i8> = execution_engine.get_function("right_shift_sign_extend").unwrap();
-
-        assert_eq!(left_shift(0, 0), 0);
-        assert_eq!(left_shift(0, 4), 0);
-        assert_eq!(left_shift(1, 0), 1);
-        assert_eq!(left_shift(1, 1), 2);
-        assert_eq!(left_shift(1, 2), 4);
-        assert_eq!(left_shift(1, 3), 8);
-        assert_eq!(left_shift(64, 1), 128);
-
-        assert_eq!(right_shift(128, 1), 64);
-        assert_eq!(right_shift(8, 3), 1);
-        assert_eq!(right_shift(4, 2), 1);
-        assert_eq!(right_shift(2, 1), 1);
-        assert_eq!(right_shift(1, 0), 1);
-        assert_eq!(right_shift(0, 4), 0);
-        assert_eq!(right_shift(0, 0), 0);
-
-        assert_eq!(right_shift_sign_extend(8, 3), 1);
-        assert_eq!(right_shift_sign_extend(4, 2), 1);
-        assert_eq!(right_shift_sign_extend(2, 1), 1);
-        assert_eq!(right_shift_sign_extend(1, 0), 1);
-        assert_eq!(right_shift_sign_extend(0, 4), 0);
-        assert_eq!(right_shift_sign_extend(0, 0), 0);
-        assert_eq!(right_shift_sign_extend(-127, 1), -64);
-        assert_eq!(right_shift_sign_extend(-127, 8), -1);
-        assert_eq!(right_shift_sign_extend(-65, 3), -9);
-        assert_eq!(right_shift_sign_extend(-64, 3), -8);
-        assert_eq!(right_shift_sign_extend(-63, 3), -8);
+        let left_shift = execution_engine.get_function::<unsafe extern "C" fn(u8, u8) -> u8>("left_shift").unwrap();
+        let right_shift  = execution_engine.get_function::<unsafe extern "C" fn(u8, u8) -> u8>("right_shift").unwrap();
+        let right_shift_sign_extend = execution_engine.get_function::<unsafe extern "C" fn(i8, u8) -> i8>("right_shift_sign_extend").unwrap();
+
+        assert_eq!(left_shift.call(0, 0), 0);
+        assert_eq!(left_shift.call(0, 4), 0);
+        assert_eq!(left_shift.call(1, 0), 1);
+        assert_eq!(left_shift.call(1, 1), 2);
+        assert_eq!(left_shift.call(1, 2), 4);
+        assert_eq!(left_shift.call(1, 3), 8);
+        assert_eq!(left_shift.call(64, 1), 128);
+
+        assert_eq!(right_shift.call(128, 1), 64);
+        assert_eq!(right_shift.call(8, 3), 1);
+        assert_eq!(right_shift.call(4, 2), 1);
+        assert_eq!(right_shift.call(2, 1), 1);
+        assert_eq!(right_shift.call(1, 0), 1);
+        assert_eq!(right_shift.call(0, 4), 0);
+        assert_eq!(right_shift.call(0, 0), 0);
+
+        assert_eq!(right_shift_sign_extend.call(8, 3), 1);
+        assert_eq!(right_shift_sign_extend.call(4, 2), 1);
+        assert_eq!(right_shift_sign_extend.call(2, 1), 1);
+        assert_eq!(right_shift_sign_extend.call(1, 0), 1);
+        assert_eq!(right_shift_sign_extend.call(0, 4), 0);
+        assert_eq!(right_shift_sign_extend.call(0, 0), 0);
+        assert_eq!(right_shift_sign_extend.call(-127, 1), -64);
+        assert_eq!(right_shift_sign_extend.call(-127, 8), -1);
+        assert_eq!(right_shift_sign_extend.call(-65, 3), -9);
+        assert_eq!(right_shift_sign_extend.call(-64, 3), -8);
+        assert_eq!(right_shift_sign_extend.call(-63, 3), -8);
     }
 }
 
diff --git a/tests/all/test_targets.rs b/tests/all/test_targets.rs
diff --git a/tests/all/test_tari_example.rs b/tests/all/test_tari_example.rs
diff --git a/tests/all/test_values.rs b/tests/all/test_values.rs

Original file line number	Diff line number	Diff line change
`@@ -1330,7 +1330,7 @@ pub fn main() {`
`1330`	`1330`	`};`
`1331`	`1331`
`1332`	`1332`	`unsafe {`
`1333`		`- println!("=> {}", compiled_fn());`
	`1333`	`+ println!("=> {}", compiled_fn.call());`
`1334`	`1334`	`}`
`1335`	`1335`	`}`
`1336`	`1336`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+#[llvm_versions(7.0 => latest)]`
`1`	`2`	`use either::Either;`
`2`	`3`	use llvm_sys::target::{LLVMTargetDataRef, LLVMCopyStringRepOfTargetData, LLVMSizeOfTypeInBits, LLVMCreateTargetData, LLVMByteOrder, LLVMPointerSize, LLVMByteOrdering, LLVMStoreSizeOfType, LLVMABISizeOfType, LLVMABIAlignmentOfType, LLVMCallFrameAlignmentOfType, LLVMPreferredAlignmentOfType, LLVMPreferredAlignmentOfGlobal, LLVMElementAtOffset, LLVMOffsetOfElement, LLVMDisposeTargetData, LLVMPointerSizeForAS, LLVMIntPtrType, LLVMIntPtrTypeForAS, LLVMIntPtrTypeInContext, LLVMIntPtrTypeForASInContext};
`3`	`4`	use llvm_sys::target_machine::{LLVMGetFirstTarget, LLVMTargetRef, LLVMGetNextTarget, LLVMGetTargetFromName, LLVMGetTargetFromTriple, LLVMGetTargetName, LLVMGetTargetDescription, LLVMTargetHasJIT, LLVMTargetHasTargetMachine, LLVMTargetHasAsmBackend, LLVMTargetMachineRef, LLVMDisposeTargetMachine, LLVMGetTargetMachineTarget, LLVMGetTargetMachineTriple, LLVMSetTargetMachineAsmVerbosity, LLVMCreateTargetMachine, LLVMGetTargetMachineCPU, LLVMGetTargetMachineFeatureString, LLVMGetDefaultTargetTriple, LLVMAddAnalysisPasses, LLVMCodeGenOptLevel, LLVMCodeModel, LLVMRelocMode, LLVMCodeGenFileType, LLVMTargetMachineEmitToMemoryBuffer, LLVMTargetMachineEmitToFile};