Add new test directive needs-target-has-atomic to support rust-lang#87377

Author: kei519

src/tools/compiletest/src/common.rs

@@ -477,6 +477,24 @@ impl Config {
         ASM_SUPPORTED_ARCHS.contains(&self.target_cfg().arch.as_str())
     }
 
+    pub fn has_atomic(&self, size: &str) -> bool {
+        for config in
+            rustc_output(self, &["--print=cfg", "--target", &self.target], Default::default())
+                .trim()
+                .lines()
+        {
+            let Some((key, value)) = config.split_once("=\"").map(|(k, v)| {
+                (k, v.strip_suffix('"').expect("key-value pair should be properly quoted"))
+            }) else {
+                continue;
+            };
+            if key == "target_has_atomic" && value == size {
+                return true;
+            }
+        }
+        false
+    }
+
     pub fn git_config(&self) -> GitConfig<'_> {
         GitConfig {
             git_repository: &self.git_repository,

src/tools/compiletest/src/directive-list.rs

@@ -154,6 +154,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "needs-sanitizer-thread",
     "needs-std-debug-assertions",
     "needs-symlink",
+    "needs-target-has-atomic",
     "needs-threads",
     "needs-unwind",
     "needs-wasmtime",

src/tools/compiletest/src/header/needs.rs

@@ -171,9 +171,12 @@ pub(super) fn handle_needs(
         },
     ];
 
-    let (name, comment) = match ln.split_once([':', ' ']) {
-        Some((name, comment)) => (name, Some(comment)),
-        None => (ln, None),
+    // Because `needs-target-has-atomic` accepts comma separated arguments after a colon to specify
+    // data sizes, we check whether comment starts with colon.
+    let (name, comment, comment_starts_with_colon) = if let Some(index) = ln.find([':', ' ']) {
+        (&ln[..index], Some(&ln[index + 1..]), ln.as_bytes()[index] == b':')
+    } else {
+        (ln, None, false)
     };
 
     if !name.starts_with("needs-") {
@@ -185,6 +188,39 @@ pub(super) fn handle_needs(
         return IgnoreDecision::Continue;
     }
 
+    // Check here because `needs-target-has-atomic` requires parsing comments.
+    if name == "needs-target-has-atomic" {
+        // `needs-target-has-atomic` requires comma-separated data sizes.
+        if !comment_starts_with_colon || comment.is_none() {
+            return IgnoreDecision::Error {
+                message: "`needs-target-has-atomic` requires data sizes for atomic operations"
+                    .into(),
+            };
+        }
+        let comment = comment.unwrap();
+
+        // Parse the comment to specify data sizes.
+        for size in comment.split(',').map(|size| size.trim()) {
+            if !["ptr", "128", "64", "32", "16", "8"].contains(&size) {
+                return IgnoreDecision::Error {
+                    message: "expected values for `needs-target-has-atomic` are: `128`, `16`, \
+                        `32`, `64`, `8`, and `ptr`"
+                        .into(),
+                };
+            }
+            if !config.has_atomic(size) {
+                return IgnoreDecision::Ignore {
+                    reason: if size == "ptr" {
+                        "ignored on targets without ptr-size atomic operations".into()
+                    } else {
+                        format!("ignored on targets without {size}-bit atomic operations")
+                    },
+                };
+            }
+        }
+        return IgnoreDecision::Continue;
+    }
+
     let mut found_valid = false;
     for need in needs {
         if need.name == name {