Auto merge of rust-lang#133944 - ricci009:master, r=<try>

bors · bors · commit 240d72314dc1 · 2025-01-29T03:55:31.000Z
Run-make test to check `core::ffi::c_*` types against clang Hello, I have been working on issue rust-lang#133058 for a bit of time now and would love some feedback as I seem to be stuck and not sure if I am approaching this correctly. I currently have the following setup: 1. Get the rust target list 2. Use rust target to query the llvm target 3. Get clang definitions through querying the clang command with llvm target. I only save the necessary defines. Here is an example of the saved info (code can easily be modified to store Width as well): Target: riscv64-unknown-linux-musl __CHAR_BIT__ = 8 __CHAR_UNSIGNED__ = 1 __SIZEOF_DOUBLE__ = 8 __SIZEOF_INT__ = 4 __SIZEOF_LONG__ = 8 __SIZEOF_PTRDIFF_T__ = 8 __SIZEOF_SIZE_T__ = 8 __SIZEOF_FLOAT__ = 4 __SIZEOF_LONG_LONG__ = 8 __SIZEOF_SHORT__ = 2 Target: riscv64-unknown-fuchsia __CHAR_UNSIGNED__ = 1 __SIZEOF_SHORT__ = 2 __CHAR_BIT__ = 8 __SIZEOF_INT__ = 4 __SIZEOF_SIZE_T__ = 8 __SIZEOF_FLOAT__ = 4 __SIZEOF_LONG__ = 8 __SIZEOF_DOUBLE__ = 8 __SIZEOF_PTRDIFF_T__ = 8 __SIZEOF_LONG_LONG__ = 8 - I then save this into a hash map with the following format: <LLVM TARGET, <DEFINE NAME, DEFINE VALUE>> - Ex: <x86_64-unknown-linux-gnu, <__SIZEOF_INT__, 4>> This is where it gets a bit shaky as I have been brainstorming ways to get the available c types in core::ffi to verify the size of the defined types but do not think I have the expertise to do this. For the current implementation I specifically focus on the c_char type (unsigned vs signed). The test is currently failing as there are type mismatches which are expected (issue rust-lang#129945 highlights this). I just do not know how to continue executing tests even with the type mismatches as it creates an error when running the run-make test. Or maybe I am doing something wrong in generating the test? Not too sure but would love your input. Thanks r? `@tgross35` `@jieyouxu` try-job: x86_64-gnu-debug
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
@@ -17,9 +17,64 @@
 #![feature(no_core, lang_items, rustc_attrs, decl_macro, naked_functions, f16, f128)]
 #![allow(unused, improper_ctypes_definitions, internal_features)]
 #![feature(asm_experimental_arch)]
+#![feature(intrinsics)]
 #![no_std]
 #![no_core]
 
+/// Vendored from the 'cfg_if' crate
+
+macro_rules! cfg_if {
+    // match if/else chains with a final `else`
+    (
+        $(
+            if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
+        ) else+
+        else { $( $e_tokens:tt )* }
+    ) => {
+        cfg_if! {
+            @__items () ;
+            $(
+                (( $i_meta ) ( $( $i_tokens )* )) ,
+            )+
+            (() ( $( $e_tokens )* )) ,
+        }
+    };
+
+    // Internal and recursive macro to emit all the items
+    //
+    // Collects all the previous cfgs in a list at the beginning, so they can be
+    // negated. After the semicolon is all the remaining items.
+    (@__items ( $( $_:meta , )* ) ; ) => {};
+    (
+        @__items ( $( $no:meta , )* ) ;
+        (( $( $yes:meta )? ) ( $( $tokens:tt )* )) ,
+        $( $rest:tt , )*
+    ) => {
+        // Emit all items within one block, applying an appropriate #[cfg]. The
+        // #[cfg] will require all `$yes` matchers specified and must also negate
+        // all previous matchers.
+        #[cfg(all(
+            $( $yes , )?
+            not(any( $( $no ),* ))
+        ))]
+        cfg_if! { @__identity $( $tokens )* }
+
+        // Recurse to emit all other items in `$rest`, and when we do so add all
+        // our `$yes` matchers to the list of `$no` matchers as future emissions
+        // will have to negate everything we just matched as well.
+        cfg_if! {
+            @__items ( $( $no , )* $( $yes , )? ) ;
+            $( $rest , )*
+        }
+    };
+
+    // Internal macro to make __apply work out right for different match types,
+    // because of how macros match/expand stuff.
+    (@__identity $( $tokens:tt )* ) => {
+        $( $tokens )*
+    };
+}
+
 // `core` has some exotic `marker_impls!` macro for handling the with-generics cases, but for our
 // purposes, just use a simple macro_rules macro.
 macro_rules! impl_marker_trait {
@@ -101,10 +156,70 @@ macro_rules! concat {
         /* compiler built-in */
     };
 }
+
 #[rustc_builtin_macro]
 #[macro_export]
 macro_rules! stringify {
     ($($t:tt)*) => {
         /* compiler built-in */
     };
 }
+
+#[macro_export]
+macro_rules! panic {
+    ($msg:literal) => {
+        $crate::panic(&$msg)
+    };
+}
+
+#[rustc_intrinsic]
+#[rustc_intrinsic_const_stable_indirect]
+#[rustc_intrinsic_must_be_overridden]
+pub const fn size_of<T>() -> usize {
+    loop {}
+}
+
+#[rustc_intrinsic]
+#[rustc_intrinsic_must_be_overridden]
+pub const fn abort() -> ! {
+    loop {}
+}
+
+#[lang = "panic"]
+#[rustc_const_panic_str]
+const fn panic(_expr: &&'static str) -> ! {
+    abort();
+}
+
+#[lang = "eq"]
+pub trait PartialEq<Rhs: ?Sized = Self> {
+    fn eq(&self, other: &Rhs) -> bool;
+    fn ne(&self, other: &Rhs) -> bool {
+        !self.eq(other)
+    }
+}
+
+impl PartialEq for usize {
+    fn eq(&self, other: &usize) -> bool {
+        (*self) == (*other)
+    }
+}
+
+impl PartialEq for bool {
+    fn eq(&self, other: &bool) -> bool {
+        (*self) == (*other)
+    }
+}
+
+#[lang = "not"]
+pub trait Not {
+    type Output;
+    fn not(self) -> Self::Output;
+}
+
+impl Not for bool {
+    type Output = bool;
+    fn not(self) -> Self {
+        !self
+    }
+}
diff --git a/tests/run-make/core-ffi-typecheck-clang/rmake.rs b/tests/run-make/core-ffi-typecheck-clang/rmake.rs
@@ -0,0 +1,238 @@
+//@ 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.
+//
+// If this test fails because Rust adds a target that Clang does not support, this target should be
+// added to SKIPPED_TARGETS.
+
+use run_make_support::{clang, llvm_components_contain, regex, rfs, rustc};
+
+// It is not possible to run the Rust test-suite on these targets.
+const SKIPPED_TARGETS: &[&str] = &[
+    "wasm32v1-none",
+    "xtensa-esp32-espidf",
+    "xtensa-esp32-none-elf",
+    "xtensa-esp32s2-espidf",
+    "xtensa-esp32s2-none-elf",
+    "xtensa-esp32s3-espidf",
+    "xtensa-esp32s3-none-elf",
+    "csky-unknown-linux-gnuabiv2",
+    "csky-unknown-linux-gnuabiv2hf",
+];
+
+/// Map from a Rust target to the Clang target if they are not the same.
+const MAPPED_TARGETS: &[(&str, &str)] = &[
+    ("aarch64-apple-ios-sim", "aarch64-apple-ios"),
+    ("aarch64-apple-tvos-sim", "aarch64-apple-tvos"),
+    ("aarch64-apple-visionos-sim", "aarch64-apple-visionos"),
+    ("aarch64-apple-watchos-sim", "aarch64-apple-watchos"),
+    ("x86_64-apple-watchos-sim", "x86_64-apple-watchos"),
+    ("aarch64-pc-windows-gnullvm", "aarch64-pc-windows-gnu"),
+    ("aarch64-unknown-linux-gnu_ilp32", "aarch64-unknown-linux-gnu"),
+    ("aarch64-unknown-none-softfloat", "aarch64-unknown-none"),
+    ("aarch64-unknown-nto-qnx700", "aarch64-unknown-nto-700"),
+    ("aarch64-unknown-nto-qnx710", "aarch64-unknown-nto-710"),
+    ("aarch64-unknown-uefi", "aarch64-unknown"),
+    ("aarch64_be-unknown-linux-gnu_ilp32", "aarch64_be-unknown-linux-gnu"),
+    ("armv5te-unknown-linux-uclibceabi", "armv5te-unknown-linux"),
+    ("armv7-sony-vita-newlibeabihf", "armv7-sony-vita"),
+    ("armv7-unknown-linux-uclibceabi", "armv7-unknown-linux"),
+    ("armv7-unknown-linux-uclibceabihf", "armv7-unknown-linux"),
+    ("avr-unknown-gnu-atmega328", "avr-unknown-gnu"),
+    ("csky-unknown-linux-gnuabiv2", "csky-unknown-linux-gnu"),
+    ("i586-pc-nto-qnx700", "i586-pc-nto-700"),
+    ("i686-pc-windows-gnullvm", "i686-pc-windows-gnu"),
+    ("i686-unknown-uefi", "i686-unknown"),
+    ("loongarch64-unknown-none-softfloat", "loongarch64-unknown-none"),
+    ("mips-unknown-linux-uclibc", "mips-unknown-linux"),
+    ("mipsel-unknown-linux-uclibc", "mipsel-unknown-linux"),
+    ("powerpc-unknown-linux-gnuspe", "powerpc-unknown-linux-gnu"),
+    ("powerpc-unknown-linux-muslspe", "powerpc-unknown-linux-musl"),
+    ("powerpc-wrs-vxworks-spe", "powerpc-wrs-vxworks"),
+    ("x86_64-fortanix-unknown-sgx", "x86_64-fortanix-unknown"),
+    ("x86_64-pc-nto-qnx710", "x86_64-pc-nto-710"),
+    ("x86_64-pc-windows-gnullvm", "x86_64-pc-windows-gnu"),
+    ("x86_64-unknown-l4re-uclibc", "x86_64-unknown-l4re"),
+];
+
+fn main() {
+    let targets = get_target_list();
+
+    let minicore_path = run_make_support::source_root().join("tests/auxiliary/minicore.rs");
+
+    preprocess_core_ffi();
+
+    for target in targets.lines() {
+        if SKIPPED_TARGETS.iter().any(|&to_skip_target| target == to_skip_target) {
+            continue;
+        }
+
+        // Map the Rust target string to a Clang target string if needed
+        // Also replace riscv with necessary replacements to match clang
+        // If neither just use target string
+        let ctarget = MAPPED_TARGETS
+            .iter()
+            .find(|(rtarget, _)| *rtarget == target)
+            .map(|(_, ctarget)| ctarget.to_string())
+            .unwrap_or_else(|| {
+                if target.starts_with("riscv") {
+                    target
+                        .replace("imac-", "-")
+                        .replace("gc-", "-")
+                        .replace("imafc-", "-")
+                        .replace("imc-", "-")
+                        .replace("ima-", "-")
+                        .replace("im-", "-")
+                        .replace("emc-", "-")
+                        .replace("em-", "-")
+                        .replace("e-", "-")
+                        .replace("i-", "-")
+                } else {
+                    target.to_string()
+                }
+            });
+
+        // Run Clang's preprocessor for the relevant target, printing default macro definitions.
+        let clang_output =
+            clang().args(&["-E", "-dM", "-x", "c", "/dev/null", "-target", &ctarget]).run();
+
+        let defines = String::from_utf8(clang_output.stdout()).expect("Invalid UTF-8");
+
+        let minicore_content = rfs::read_to_string(&minicore_path);
+        let mut rmake_content = format!(
+            r#"
+            #![no_std]
+            #![no_core]
+            #![feature(link_cfg)]
+            #![allow(unused)]
+            #![crate_type = "rlib"]
+
+            /* begin minicore content */
+            {minicore_content}
+            /* end minicore content */
+
+            #[path = "processed_mod.rs"]
+            mod ffi;
+            #[path = "tests.rs"]
+            mod tests;
+            "#
+        );
+
+        rmake_content.push_str(&format!(
+            "
+            const CLANG_C_CHAR_SIZE: usize = {};
+            const CLANG_C_CHAR_SIGNED: bool = {};
+            const CLANG_C_SHORT_SIZE: usize = {};
+            const CLANG_C_INT_SIZE: usize = {};
+            const CLANG_C_LONG_SIZE: usize = {};
+            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),
+            parse_size(&defines, "SHORT"),
+            parse_size(&defines, "INT"),
+            parse_size(&defines, "LONG"),
+            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.
+        // If type misalignments occur,
+        // generated rmake file name used to identify the failing target.
+        let file_name = format!("{}_rmake.rs", target.replace("-", "_").replace(".", "_"));
+
+        // Attempt to build the test file for the relevant target.
+        // Tests use constant evaluation, so running is not necessary.
+        rfs::write(&file_name, rmake_content);
+        let rustc_output = rustc()
+            .arg("-Zunstable-options")
+            .arg("--emit=metadata")
+            .arg("--target")
+            .arg(target)
+            .arg("-o-")
+            .arg(&file_name)
+            .run();
+        rfs::remove_file(&file_name);
+        if !rustc_output.status().success() {
+            panic!("Failed for target {}", target);
+        }
+    }
+
+    // Cleanup
+    rfs::remove_file("processed_mod.rs");
+}
+
+/// Get a list of available targets for 'rustc'.
+fn get_target_list() -> String {
+    let completed_process = rustc().arg("--print").arg("target-list").run();
+    String::from_utf8(completed_process.stdout()).expect("error not a string")
+}
+
+// Helper to parse size from clang defines
+fn parse_size(defines: &str, type_name: &str) -> usize {
+    let search_pattern = format!("__SIZEOF_{}__ ", type_name.to_uppercase());
+    for line in defines.lines() {
+        if line.contains(&search_pattern) {
+            if let Some(size_str) = line.split_whitespace().last() {
+                return size_str.parse().unwrap_or(0);
+            }
+        }
+    }
+
+    // Only allow CHAR to default to 1
+    if type_name.to_uppercase() == "CHAR" {
+        return 1;
+    }
+
+    panic!("Could not find size definition for type: {}", type_name);
+}
+
+fn char_is_signed(defines: &str) -> bool {
+    !defines.lines().any(|line| line.contains("__CHAR_UNSIGNED__"))
+}
+
+/// Parse core/ffi/mod.rs to retrieve only necessary macros and type defines
+fn preprocess_core_ffi() {
+    let mod_path = run_make_support::source_root().join("library/core/src/ffi/mod.rs");
+    let mut content = rfs::read_to_string(&mod_path);
+
+    //remove stability features #![unstable]
+    let mut re = regex::Regex::new(r"#!?\[(un)?stable[^]]*?\]").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //remove doc features #[doc...]
+    re = regex::Regex::new(r"#\[doc[^]]*?\]").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //remove lang feature #[lang...]
+    re = regex::Regex::new(r"#\[lang[^]]*?\]").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //remove non inline modules
+    re = regex::Regex::new(r".*mod.*;").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //remove use
+    re = regex::Regex::new(r".*use.*;").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //remove fn fmt {...}
+    re = regex::Regex::new(r"(?s)fn fmt.*?\{.*?\}").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    //rmv impl fmt {...}
+    re = regex::Regex::new(r"(?s)impl fmt::Debug for.*?\{.*?\}").unwrap();
+    content = re.replace_all(&content, "").to_string();
+
+    let file_name = "processed_mod.rs";
+
+    rfs::write(&file_name, content);
+}
diff --git a/tests/run-make/core-ffi-typecheck-clang/tests.rs b/tests/run-make/core-ffi-typecheck-clang/tests.rs
