Evaulate cfg props for the real target in compiletest

inquisitivecrystal · inquisitivecrystal · commit bc315aabf455 · 2021-12-18T00:45:36.000-08:00
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
@@ -1,6 +1,5 @@
 pub use self::Mode::*;
 
-use std::collections::HashMap;
 use std::ffi::OsString;
 use std::fmt;
 use std::path::{Path, PathBuf};
@@ -276,10 +275,6 @@ 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,
 
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
@@ -16,9 +16,12 @@ use crate::{extract_cdb_version, extract_gdb_version};
 #[cfg(test)]
 mod tests;
 
-/// The result of parse_cfg_name_directive.
+/// Whether a given property holds true of this test instance. Usually,
+/// a property is something about the target (e.g. whether the target is Windows),
+/// but it could also be something more general (e.g. whether this test is being
+/// cross-compiled.)
 #[derive(Clone, Copy, PartialEq, Debug)]
-enum ParsedNameDirective {
+enum EvaluatedProp {
     /// No match.
     NoMatch,
     /// Match.
@@ -228,6 +231,10 @@ impl TestProps {
         if !testfile.is_dir() {
             let file = File::open(testfile).unwrap();
 
+            let mut target = config.target.clone();
+            let mut per_prop_normalize_stdout: Vec<(String, (String, String))> = Vec::new();
+            let mut per_prop_normalize_stderr: Vec<(String, (String, String))> = Vec::new();
+
             iter_header(testfile, file, &mut |revision, ln| {
                 if revision.is_some() && revision != cfg {
                     return;
@@ -340,11 +347,16 @@ impl TestProps {
                     self.ignore_pass = config.parse_ignore_pass(ln);
                 }
 
+                if let Some(target_override) = config.parse_target_override(ln) {
+                    target = target_override;
+                }
+
                 if let Some(rule) = config.parse_custom_normalization(ln, "normalize-stdout") {
-                    self.normalize_stdout.push(rule);
+                    per_prop_normalize_stdout.push(rule);
                 }
+
                 if let Some(rule) = config.parse_custom_normalization(ln, "normalize-stderr") {
-                    self.normalize_stderr.push(rule);
+                    per_prop_normalize_stderr.push(rule);
                 }
 
                 if let Some(code) = config.parse_failure_status(ln) {
@@ -372,6 +384,17 @@ impl TestProps {
                     self.incremental = config.parse_incremental(ln);
                 }
             });
+            for (prop, normalization) in per_prop_normalize_stdout {
+                if config.evaluate_prop_for_target(&prop, &target) == EvaluatedProp::Match {
+                    self.normalize_stdout.push(normalization);
+                }
+            }
+
+            for (prop, normalization) in per_prop_normalize_stderr {
+                if config.evaluate_prop_for_target(&prop, &target) == EvaluatedProp::Match {
+                    self.normalize_stderr.push(normalization);
+                }
+            }
         }
 
         if self.failure_status == -1 {
@@ -650,14 +673,15 @@ impl Config {
         }
     }
 
-    fn parse_custom_normalization(&self, mut line: &str, prefix: &str) -> Option<(String, String)> {
-        if self.parse_cfg_name_directive(line, prefix) == ParsedNameDirective::Match {
-            let from = parse_normalization_string(&mut line)?;
-            let to = parse_normalization_string(&mut line)?;
-            Some((from, to))
-        } else {
-            None
-        }
+    fn parse_custom_normalization(
+        &self,
+        mut line: &str,
+        prefix: &str,
+    ) -> Option<(String, (String, String))> {
+        let prop = self.parse_prop_directive(line, prefix)?;
+        let from = parse_normalization_string(&mut line)?;
+        let to = parse_normalization_string(&mut line)?;
+        Some((prop, (from, to)))
     }
 
     fn parse_needs_matching_clang(&self, line: &str) -> bool {
@@ -670,7 +694,19 @@ 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 {
+    fn parse_prop_directive(&self, line: &str, prefix: &str) -> Option<String> {
+        if !line.as_bytes().starts_with(prefix.as_bytes()) {
+            return None;
+        }
+        if line.as_bytes().get(prefix.len()) != Some(&b'-') {
+            return None;
+        }
+
+        let config = &line[&prefix.len() + 1..].to_string();
+        Some(config.to_string())
+    }
+
+    fn evaluate_prop_for_target(&self, prop: &str, target: &str) -> EvaluatedProp {
         // 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.
@@ -697,28 +733,21 @@ impl Config {
             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 captures = CFG_REGEX.captures(&line[&prefix.len() + 1..]).unwrap();
+        let captures = CFG_REGEX.captures(&prop).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
-            util::matches_os(&self.target, name) ||             // target
-            util::matches_env(&self.target, name) ||            // env
-            self.target.ends_with(name) ||                      // target and env
-            name == util::get_arch(&self.target) ||             // architecture
-            name == util::get_pointer_width(&self.target) ||    // pointer width
+            target == name ||                                   // triple
+            util::matches_os(target, name) ||                   // target
+            util::matches_env(target, name) ||                  // env
+            target.ends_with(name) ||                           // target and env
+            name == util::get_arch(target) ||                   // architecture
+            name == util::get_pointer_width(target) ||          // pointer width
             name == self.stage_id.split('-').next().unwrap() || // stage
             name == self.channel ||                             // channel
-            (self.target != self.host && name == "cross-compile") ||
-            (name == "endian-big" && util::is_big_endian(&self.target)) ||
+            (target != self.host && name == "cross-compile") ||
+            (name == "endian-big" && util::is_big_endian(target)) ||
             (self.remote_test_client.is_some() && name == "remote") ||
             match self.compare_mode {
                 Some(CompareMode::Nll) => name == "compare-mode-nll",
@@ -736,14 +765,17 @@ impl Config {
                 None => false,
             } ||
             match name.strip_prefix("cfg-") {
-                Some(rustc_cfg_name) => util::cfg_has(&self.target_cfg, rustc_cfg_name, maybe_value),
+                Some(rustc_cfg_name) => {
+                    let cfg_data = util::fetch_cfg_from_rustc_for_target(&self.rustc_path, target);
+                    util::cfg_has(&cfg_data, rustc_cfg_name, maybe_value)
+                },
                 None => false
             };
 
-        if is_match { ParsedNameDirective::Match } else { ParsedNameDirective::NoMatch }
+        if is_match { EvaluatedProp::Match } else { EvaluatedProp::NoMatch }
     }
 
-    fn has_cfg_prefix(&self, line: &str, prefix: &str) -> bool {
+    fn has_prop_prefix(&self, line: &str, prefix: &str) -> bool {
         // returns whether this line contains this prefix or not. For prefix
         // "ignore", returns true if line says "ignore-x86_64", "ignore-arch",
         // "ignore-android" etc.
@@ -768,6 +800,21 @@ impl Config {
         }
     }
 
+    pub fn parse_target_override(&self, line: &str) -> Option<String> {
+        let flags = self.parse_name_value_directive(line, "compile-flags")?;
+        let (_, tail) = flags.split_once("--target")?;
+        if tail.starts_with(|c: char| c.is_whitespace() || c == '=') {
+            let tail = &tail[1..];
+            let target = match tail.split_once(|c: char| c.is_whitespace()) {
+                Some((target, _)) => target,
+                None => &tail,
+            };
+            Some(target.to_string())
+        } else {
+            None
+        }
+    }
+
     pub fn find_rust_src_root(&self) -> Option<PathBuf> {
         let mut path = self.src_base.clone();
         let path_postfix = Path::new("src/etc/lldb_batchmode.py");
@@ -900,6 +947,10 @@ pub fn make_test_description<R: Read>(
     let mut ignore = false;
     let mut should_fail = false;
 
+    let mut target = config.target.clone();
+    let mut ignored_props: Vec<String> = Vec::new();
+    let mut only_test_on_props: Vec<String> = Vec::new();
+
     let rustc_has_profiler_support = env::var_os("RUSTC_PROFILER_SUPPORT").is_some();
     let rustc_has_sanitizer_support = env::var_os("RUSTC_SANITIZER_SUPPORT").is_some();
     let has_asm_support = util::has_asm_support(&config.target);
@@ -908,7 +959,6 @@ pub fn make_test_description<R: Read>(
     let has_msan = util::MSAN_SUPPORTED_TARGETS.contains(&&*config.target);
     let has_tsan = util::TSAN_SUPPORTED_TARGETS.contains(&&*config.target);
     let has_hwasan = util::HWASAN_SUPPORTED_TARGETS.contains(&&*config.target);
-    // for `-Z gcc-ld=lld`
     let has_rust_lld = config
         .compile_lib_path
         .join("rustlib")
@@ -921,15 +971,16 @@ pub fn make_test_description<R: Read>(
         if revision.is_some() && revision != cfg {
             return;
         }
-        ignore = match config.parse_cfg_name_directive(ln, "ignore") {
-            ParsedNameDirective::Match => true,
-            ParsedNameDirective::NoMatch => ignore,
-        };
-        if config.has_cfg_prefix(ln, "only") {
-            ignore = match config.parse_cfg_name_directive(ln, "only") {
-                ParsedNameDirective::Match => ignore,
-                ParsedNameDirective::NoMatch => true,
-            };
+        if let Some(target_override) = config.parse_target_override(ln) {
+            target = target_override;
+        }
+        if let Some(prop) = config.parse_prop_directive(ln, "ignore") {
+            ignored_props.push(prop);
+        }
+        if config.has_prop_prefix(ln, "only") {
+            if let Some(prop) = config.parse_prop_directive(ln, "only") {
+                only_test_on_props.push(prop);
+            }
         }
         ignore |= ignore_llvm(config, ln);
         ignore |=
@@ -954,6 +1005,19 @@ pub fn make_test_description<R: Read>(
         should_fail |= config.parse_name_directive(ln, "should-fail");
     });
 
+    for prop in ignored_props {
+        ignore = match config.evaluate_prop_for_target(&prop, &target) {
+            EvaluatedProp::Match => true,
+            EvaluatedProp::NoMatch => ignore,
+        };
+    }
+    for prop in only_test_on_props {
+        ignore = match config.evaluate_prop_for_target(&prop, &target) {
+            EvaluatedProp::Match => ignore,
+            EvaluatedProp::NoMatch => true,
+        };
+    }
+
     // The `should-fail` annotation doesn't apply to pretty tests,
     // since we run the pretty printer across all tests by default.
     // If desired, we could add a `should-fail-pretty` annotation.
diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs
@@ -11,7 +11,6 @@ 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;
@@ -217,18 +216,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         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")),
@@ -272,7 +259,6 @@ 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,
diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs
@@ -4,6 +4,7 @@ use std::collections::HashMap;
 use std::env;
 use std::ffi::OsStr;
 use std::path::PathBuf;
+use std::process::Command;
 
 use tracing::*;
 
@@ -217,22 +218,31 @@ 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();
+pub fn fetch_cfg_from_rustc_for_target<P: AsRef<OsStr>>(
+    rustc_path: &P,
+    target: &str,
+) -> HashMap<String, Vec<String>> {
+    let mut target_cfg = 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, "");
+    if !cfg!(test) {
+        let rustc_output = Command::new(&rustc_path)
+            .args(&["--target", &target])
+            .args(&["--print", "cfg"])
+            .output()
+            .unwrap()
+            .stdout;
+        let rustc_output = String::from_utf8(rustc_output).unwrap();
+
+        for line in rustc_output.lines() {
+            if let Some((name, value)) = line.split_once('=') {
+                let normalized_value = value.trim_matches('"');
+                cfg_add(&mut target_cfg, name, normalized_value);
+            } else {
+                cfg_add(&mut target_cfg, line, "");
+            }
         }
     }
-
-    return map;
+    target_cfg
 }
 
 /// Adds the given name and value to the provided cfg [`HashMap`]. If the `name` already
