Improve tests

Author: hyd-dev

tests/compile-fail/function_calls/check_callback_abi.rs

@@ -6,6 +6,8 @@ extern "C" fn try_fn(_: *mut u8) {
 
 fn main() {
     unsafe {
+        // Make sure we check the ABI when Miri itself invokes a function
+        // as part of a shim implementation.
         std::intrinsics::r#try( //~ ERROR calling a function with ABI C using caller ABI Rust
             std::mem::transmute::<extern "C" fn(*mut u8), _>(try_fn),
             std::ptr::null_mut(),

tests/compile-fail/function_calls/exported_symbol_abi_mismatch.rs

@@ -1,22 +1,29 @@
-// revisions: no_cache cache
+// revisions: no_cache cache fn_ptr
 
 #[no_mangle]
 fn foo() {}
 
 fn main() {
+    #[cfg(any(cache, fn_ptr))]
+    extern "Rust" {
+        fn foo();
+    }
+
+    #[cfg(fn_ptr)]
+    unsafe { std::mem::transmute::<unsafe fn(), unsafe extern "C" fn()>(foo)() }
+    //[fn_ptr]~^ ERROR calling a function with ABI Rust using caller ABI C
+
+    // `Instance` caching should not suppress ABI check.
     #[cfg(cache)]
+    unsafe { foo() }
+
     {
-        // `Instance` caching should not suppress ABI check.
-        extern "Rust" {
+        #[cfg_attr(any(cache, fn_ptr), allow(clashing_extern_declarations))]
+        extern "C" {
             fn foo();
         }
         unsafe { foo() }
+        //[no_cache]~^ ERROR calling a function with ABI Rust using caller ABI C
+        //[cache]~^^ ERROR calling a function with ABI Rust using caller ABI C
     }
-    #[cfg_attr(cache, allow(clashing_extern_declarations))]
-    extern "C" {
-        fn foo();
-    }
-    unsafe { foo() }
-    //[no_cache]~^ ERROR Undefined Behavior: calling a function with ABI Rust using caller ABI C
-    //[cache]~^^ ERROR Undefined Behavior: calling a function with ABI Rust using caller ABI C
 }

tests/compile-fail/function_calls/exported_symbol_bad_unwind3.rs

@@ -1,5 +1,4 @@
 #![feature(unwind_attributes)]
-#![feature(c_unwind)] // make sure it doesn't insert abort-on-unwind for the `#[unwind(allowed)]` function
 
 #[unwind(allowed)]
 #[no_mangle]

tests/run-pass/function_calls/exported_symbol.rs

@@ -32,13 +32,42 @@ fn main() {
         extern "C" {
             fn foo() -> i32;
         }
+
         assert_eq!(unsafe { foo() }, -1);
-        assert_eq!(unsafe { foo() }, -1);
+
         extern "Rust" {
             fn bar() -> i32;
             fn baz() -> i32;
         }
+
         assert_eq!(unsafe { bar() }, -2);
         assert_eq!(unsafe { baz() }, -3);
+
+        #[allow(clashing_extern_declarations)]
+        {
+            extern "Rust" {
+                fn foo() -> i32;
+            }
+
+            assert_eq!(
+                unsafe {
+                    std::mem::transmute::<unsafe fn() -> i32, unsafe extern "C" fn() -> i32>(foo)()
+                },
+                -1
+            );
+
+            extern "C" {
+                fn bar() -> i32;
+                fn baz() -> i32;
+            }
+
+            unsafe {
+                let transmute = |f| {
+                    std::mem::transmute::<unsafe extern "C" fn() -> i32, unsafe fn() -> i32>(f)
+                };
+                assert_eq!(transmute(bar)(), -2);
+                assert_eq!(transmute(baz)(), -3);
+            }
+        }
     }
 }