implemented checks for size_t, ssize_t, ptrdiff_t, & schar_t

Author: ricci009

tests/run-make/core-ffi-typecheck-clang/rmake.rs

@@ -1,4 +1,3 @@
-//@ needs-force-clang-based-tests
 // This test checks that the clang defines for each target allign with the core ffi types defined in
 // mod.rs. Therefore each rust target is queried and the clang defines for each target are read and
 // compared to the core sizes to verify all types and sizes allign at buildtime.
@@ -101,6 +100,8 @@ fn main() {
             const CLANG_C_LONGLONG_SIZE: usize = {};
             const CLANG_C_FLOAT_SIZE: usize = {};
             const CLANG_C_DOUBLE_SIZE: usize = {};
+            const CLANG_C_SIZE_T_SIZE: usize = {};
+            const CLANG_C_PTRDIFF_T_SIZE: usize = {};
             ",
             parse_size(&defines, "CHAR"),
             char_is_signed(&defines),
@@ -110,6 +111,8 @@ fn main() {
             parse_size(&defines, "LONG_LONG"),
             parse_size(&defines, "FLOAT"),
             parse_size(&defines, "DOUBLE"),
+            parse_size(&defines, "SIZE_T"),
+            parse_size(&defines, "PTRDIFF_T"),
         ));
 
         // Generate a target-specific rmake file.

tests/run-make/core-ffi-typecheck-clang/tests.rs

@@ -63,6 +63,54 @@ cfg_if! {
     }
 }
 
+// Verify Rust's 'c_size_t' is correct
+cfg_if! {
+    if #[cfg(all(target_arch = "aarch64", target_abi = "ilp32"))] {
+        // FIXME: size_t is not short enough on aarch64 ilp32, should be 4, defaulting to 8
+        const XFAIL_C_SIZE_T_SIZE: usize = 4;
+        pub const TEST_C_SIZE_T_SIZE: () = if size_of::<ffi::c_size_t>() != XFAIL_C_SIZE_T_SIZE {
+            panic!("wrong c_size_t size, target_arch: aarch64, target_abi: ilp32");
+        };
+    }
+    else {
+        pub const TEST_C_SIZE_T_SIZE: () = if size_of::<ffi::c_size_t>() != CLANG_C_SIZE_T_SIZE {
+            panic!("wrong c_size_t size");
+        };
+    }
+}
+
+// Verify Rust's 'c_ssize_t' is correct
+cfg_if! {
+    if #[cfg(all(target_arch = "aarch64", target_abi = "ilp32"))] {
+        // FIXME: ssize_t is not short enough on aarch64 ilp32, should be 4, defaulting to 8
+        const XFAIL_C_SSIZE_T_SIZE: usize = 4;
+        pub const TEST_C_SSIZE_T_SIZE: () = if size_of::<ffi::c_ssize_t>() != XFAIL_C_SSIZE_T_SIZE {
+            panic!("wrong c_ssize_t size, target_arch: aarch64, target_abi: ilp32");
+        };
+    }
+    else {
+        pub const TEST_C_SSIZE_T_SIZE: () = if size_of::<ffi::c_ssize_t>() != CLANG_C_SIZE_T_SIZE {
+            panic!("wrong c_size_t size");
+        };
+    }
+}
+
+// Verify Rust's 'c_ptrdiff_t' is correct
+cfg_if! {
+    if #[cfg(all(target_arch = "aarch64", target_abi = "ilp32"))] {
+        // FIXME: c_ptrdiff_t is not short enough on aarch64 ilp32, should be 4, defaulting to 8
+        const XFAIL_C_PTRDIFF_T_SIZE: usize = 4;
+        pub const TEST_C_PTRDIFF_T_SIZE: () = if size_of::<ffi::c_ptrdiff_t>() != XFAIL_C_PTRDIFF_T_SIZE {
+            panic!("wrong c_ssize_t size, target_arch: aarch64, target_abi: ilp32");
+        };
+    }
+    else {
+        pub const TEST_C_PTRDIFF_T_SIZE: () = if size_of::<ffi::c_ptrdiff_t>() != CLANG_C_PTRDIFF_T_SIZE {
+            panic!("wrong c_size_t size");
+        };
+    }
+}
+
 impl Signed for i8 {
     const SIGNED: bool = true;
 }
@@ -95,3 +143,28 @@ pub const TEST_C_LONGLONG_SIZE: () = if size_of::<ffi::c_longlong>() != CLANG_C_
 pub const TEST_C_FLOAT_SIZE: () = if size_of::<ffi::c_float>() != CLANG_C_FLOAT_SIZE {
     panic!("wrong c_float size");
 };
+
+//c_schar size
+pub const TEST_C_SCHAR_SIZE: () = if size_of::<ffi::c_schar>() != CLANG_C_CHAR_SIZE {
+    panic!("wrong c_schar size");
+};
+
+//c_uchar size
+pub const TEST_C_UCHAR_SIZE: () = if size_of::<ffi::c_uchar>() != CLANG_C_CHAR_SIZE {
+    panic!("wrong c_uchar size");
+};
+
+//c_uint size
+pub const TEST_C_UINT_SIZE: () = if size_of::<ffi::c_int>() != CLANG_C_INT_SIZE {
+    panic!("mismatched c_uint size");
+};
+
+//c_ushort size
+pub const TEST_C_USHORT_SIZE: () = if size_of::<ffi::c_short>() != CLANG_C_SHORT_SIZE {
+    panic!("wrong c_ushort size");
+};
+
+//c_ulonglong size
+pub const TEST_C_ULONGLONG_SIZE: () = if size_of::<ffi::c_ulonglong>() != CLANG_C_LONGLONG_SIZE {
+    panic!("wrong c_ulonglong size");
+};