Teach compiletest to parse arbitrary cfg options

Author: inquisitivecrystal

src/tools/compiletest/src/common.rs

@@ -1,5 +1,6 @@
 pub use self::Mode::*;
 
+use std::collections::HashMap;
 use std::ffi::OsString;
 use std::fmt;
 use std::path::{Path, PathBuf};
@@ -275,6 +276,10 @@ pub struct Config {
     /// not vice versa.
     pub target_panic: PanicStrategy,
 
+    /// A map from target cfg keys to their values. If the key is present with no value,
+    /// the vector will contain the empty string.
+    pub target_cfg: HashMap<String, Vec<String>>,
+
     /// Target system to be tested
     pub target: String,
 

src/tools/compiletest/src/header.rs

@@ -5,6 +5,8 @@ use std::io::prelude::*;
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
 
+use lazy_static::lazy_static;
+use regex::Regex;
 use tracing::*;
 
 use crate::common::{CompareMode, Config, Debugger, FailMode, Mode, PanicStrategy, PassMode};
@@ -669,14 +671,42 @@ impl Config {
     /// Parses a name-value directive which contains config-specific information, e.g., `ignore-x86`
     /// or `normalize-stderr-32bit`.
     fn parse_cfg_name_directive(&self, line: &str, prefix: &str) -> ParsedNameDirective {
+        // This matches optional whitespace, followed by a group containing a series of word
+        // characters (including '_' and '-'), followed optionally by a sequence consisting
+        // of a colon, optional whitespace, and another group containing word characters.
+        //
+        // Matches in full:
+        //   cfg-target-has-atomic: 128
+        //   cfg-target-has-atomic:128
+        //   cfg-target-has-atomic
+        //
+        // Matches up to the first space (exclusive):
+        //   ignore-test - This test really shouldn't ever be run
+        //
+        // Matches up to the second space (exclusive):
+        //   cfg-target-has-atomic: 128 - this requires fancy newfangled atomics
+        //
+        // Matches up to the second colon (exclusive)
+        //   cfg-target-has-atomic:128: I put an extra colon here to confuse other programmers!
+        //
+        // Does not match:
+        //   (a line consisting solely of whitespace)
+        //   &*#$ cfg-target-has-atomic
+        //
+        lazy_static! {
+            static ref CFG_REGEX: Regex = Regex::new(r"^\s*([\w-]+)(?::\s*([\w-]+))?").unwrap();
+        }
+
         if !line.as_bytes().starts_with(prefix.as_bytes()) {
             return ParsedNameDirective::NoMatch;
         }
         if line.as_bytes().get(prefix.len()) != Some(&b'-') {
             return ParsedNameDirective::NoMatch;
         }
 
-        let name = line[prefix.len() + 1..].split(&[':', ' '][..]).next().unwrap();
+        let captures = CFG_REGEX.captures(&line[&prefix.len() + 1..]).unwrap();
+        let name = captures.get(1).unwrap().as_str();
+        let maybe_value = captures.get(2).map(|v| v.as_str().trim());
 
         let is_match = name == "test" ||
             self.target == name ||                              // triple
@@ -704,6 +734,10 @@ impl Config {
                 Some(Debugger::Gdb) => name == "gdb",
                 Some(Debugger::Lldb) => name == "lldb",
                 None => false,
+            } ||
+            match name.strip_prefix("cfg-") {
+                Some(rustc_cfg_name) => util::cfg_has(&self.target_cfg, rustc_cfg_name, maybe_value),
+                None => false
             };
 
         if is_match { ParsedNameDirective::Match } else { ParsedNameDirective::NoMatch }

src/tools/compiletest/src/main.rs

@@ -11,6 +11,7 @@ use crate::common::{
 use crate::common::{CompareMode, Config, Debugger, Mode, PassMode, TestPaths};
 use crate::util::logv;
 use getopts::Options;
+use std::collections::HashMap;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
@@ -201,6 +202,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
     let llvm_version =
         matches.opt_str("llvm-version").as_deref().and_then(header::extract_llvm_version);
 
+    let rustc_path = opt_path(matches, "rustc-path");
     let src_base = opt_path(matches, "src-base");
     let run_ignored = matches.opt_present("ignored");
     let mode = matches.opt_str("mode").unwrap().parse().expect("invalid mode");
@@ -214,11 +216,24 @@ pub fn parse_config(args: Vec<String>) -> Config {
         // Avoid spawning an external command when we know tidy won't be used.
         false
     };
+
+    let target_cfg = if cfg!(test) {
+        HashMap::new()
+    } else {
+        let rustc_cfg_data = Command::new(&rustc_path)
+            .args(&["--target", &target])
+            .args(&["--print", "cfg"])
+            .output()
+            .unwrap()
+            .stdout;
+        util::parse_rustc_cfg(String::from_utf8(rustc_cfg_data).unwrap())
+    };
+
     Config {
         bless: matches.opt_present("bless"),
         compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
         run_lib_path: make_absolute(opt_path(matches, "run-lib-path")),
-        rustc_path: opt_path(matches, "rustc-path"),
+        rustc_path: rustc_path,
         rustdoc_path: matches.opt_str("rustdoc-path").map(PathBuf::from),
         rust_demangler_path: matches.opt_str("rust-demangler-path").map(PathBuf::from),
         lldb_python: matches.opt_str("lldb-python").unwrap(),
@@ -257,6 +272,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
             Some("abort") => PanicStrategy::Abort,
             _ => panic!("unknown `--target-panic` option `{}` given", mode),
         },
+        target_cfg,
         target,
         host: opt_str2(matches.opt_str("host")),
         cdb,

src/tools/compiletest/src/util.rs

@@ -1,4 +1,6 @@
 use crate::common::Config;
+
+use std::collections::HashMap;
 use std::env;
 use std::ffi::OsStr;
 use std::path::PathBuf;
@@ -215,6 +217,55 @@ pub fn logv(config: &Config, s: String) {
     }
 }
 
+/// Parses the output of `rustc --print cfg` into a [`HashMap`] containing
+/// the cfg values for each name. If the name is present with no value,
+/// it is treated as having a value of "".
+pub fn parse_rustc_cfg(rustc_output: String) -> HashMap<String, Vec<String>> {
+    let mut map = HashMap::new();
+
+    for line in rustc_output.lines() {
+        if let Some((name, value)) = line.split_once('=') {
+            let normalized_value = value.trim_matches('"');
+            cfg_add(&mut map, name, normalized_value);
+        } else {
+            cfg_add(&mut map, line, "");
+        }
+    }
+
+    return map;
+}
+
+/// Adds the given name and value to the provided cfg [`HashMap`]. If the `name` already
+/// points to a vector, this adds `value` to the vector. If `name` does not point
+/// to a vector, this adds a new vector containing only `value` to the [`HashMap`].
+fn cfg_add(map: &mut HashMap<String, Vec<String>>, name: &str, value: &str) {
+    let name = name.to_string();
+    let value = value.to_string();
+
+    if let Some(values) = map.get_mut(&name) {
+        values.push(value.to_string());
+    } else {
+        map.insert(name, vec![value.to_string()]);
+    }
+}
+
+/// Checks if the cfg HashMap has the given `name`. If the `required_value` is
+/// `Some(value)`, this will only return `true` if `name` is associated with `value`.
+pub fn cfg_has(
+    map: &HashMap<String, Vec<String>>,
+    name: &str,
+    required_value: Option<&str>,
+) -> bool {
+    let name = name.replace("-", "_");
+    let required_value = required_value.map(str::trim).map(str::to_string);
+
+    match (map.get(&name), required_value) {
+        (None, _) => false,
+        (Some(_), None) => true,
+        (Some(values), Some(required_value)) => values.contains(&required_value),
+    }
+}
+
 pub trait PathBufExt {
     /// Append an extension to the path, even if it already has one.
     fn with_extra_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf;