Auto merge of #100260 - ehuss:compiletest-target-cfg, r=Mark-Simulacrum

compiletest: use target cfg instead of hard-coded tables

This changes compiletest to use `rustc --print=cfg` to dynamically determine the properties of a target when matching `ignore` and `only` rules instead of using hard-coded tables or target-triple parsing (which don't always follow the `<arch><sub>-<vendor>-<sys>-<abi>` pattern). The benefit here is that it will more accurately match the target properties, and not require maintaining these extra tables.

This also adds matching the `target_family` in ignore rules. The primary benefit here is so that `ignore-wasm` works as expected (matching all wasm-like targets). There were already several tests that had `ignore-wasm` in them (which previously had no effect), so it is evident that some people expected that to work. This also adds `ignore-unix/only-unix`.

There is some risk that this changes the behavior from before since the tables aren't quite the same as the target properties. However, I did fairly extensive comparisons to see what would be different. https://gist.github.com/ehuss/5bf7ab347605160cefb6f84ba5ea5f6b contains a full list of differences for all targets for all tests. I do not think any of the affected target/test combinations are things that are actually tested in CI. I tested several of the more unusual test images (test-various, dist-various-1, wasm32), and they seem fine.

A summary of most of the reasons behind the differences:

- wasm64-unknown-unknown wasm32-wasi now match "wasm"
- Targets now match "gnu" because they have target_env=gnu
    - aarch64-wrs-vxworks
    - armv7-wrs-vxworks-eabihf
    - i686-wrs-vxworks
    - powerpc-wrs-vxworks
    - powerpc64-wrs-vxworks
    - x86_64-wrs-vxworks
- wasm64-unknown-unknown now matches wasm64
- x86_64-unknown-none-linuxkernel no longer matches "linux", but will match "gnu" and "none"
- Various arm targets now match "aarch64" or "arm":
    - arm64_32-apple-watchos
    - armebv7r-none-eabi
    - armv6-unknown-freebsd
    - armv6-unknown-netbsd-eabihf
    - armv6k-nintendo-3ds
    - armv7-wrs-vxworks-eabihf
    - armv7a-kmc-solid_asp3-eabi
    - armv7a-kmc-solid_asp3-eabihf
    - armv7a-none-eabi
    - armv7a-none-eabihf
    - armv7k-apple-watchos
    - armv7r-none-eabi
    - armv7r-none-eabihf
- Now matches "thumb" and "arm"
    - thumbv4t-none-eabi
    - thumbv6m-none-eabi
    - thumbv7a-pc-windows-msvc
    - thumbv7a-uwp-windows-msvc
    - thumbv7em-none-eabi
    - thumbv7em-none-eabihf
    - thumbv7m-none-eabi
    - thumbv7neon-linux-androideabi
    - thumbv7neon-unknown-linux-gnueabihf
    - thumbv7neon-unknown-linux-musleabihf
    - thumbv8m.base-none-eabi
    - thumbv8m.main-none-eabi
- asmjs-unknown-emscripten now matches "wasm32" because that it is its defined arch
- avr-unknown-gnu-atmega328 now matches "none" (because target_os="none")
- now matches 64bit:
    - bpfeb-unknown-none
    - bpfel-unknown-none
    - sparcv9-sun-solaris
- now matches endian-big:
    - m68k-unknown-linux-gnu
- now matches 16bit:
    - msp430-none-elf
- now matches 32bit:
    - arm64_32-apple-watchos
- now matches riscv32 (and needs-asm-support):
    - riscv32gc-unknown-linux-gnu
    - riscv32gc-unknown-linux-musl
    - riscv32i-unknown-none-elf
    - riscv32im-unknown-none-elf
    - riscv32imac-unknown-none-elf
    - riscv32imac-unknown-xous-elf
    - riscv32imc-esp-espidf
    - riscv32imc-unknown-none-elf
    - riscv64imac-unknown-none-elf

Cargo.lock

@@ -817,6 +817,7 @@ dependencies = [
  "getopts",
  "glob",
  "lazy_static",
+ "lazycell",
  "libc",
  "miow",
  "regex",

src/tools/compiletest/Cargo.toml

@@ -17,6 +17,7 @@ rustfix = "0.6.0"
 lazy_static = "1.0"
 walkdir = "2"
 glob = "0.3.0"
+lazycell = "1.3.0"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

src/tools/compiletest/src/common.rs

@@ -3,9 +3,11 @@ pub use self::Mode::*;
 use std::ffi::OsString;
 use std::fmt;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use std::str::FromStr;
 
 use crate::util::PathBufExt;
+use lazycell::LazyCell;
 use test::ColorConfig;
 
 #[derive(Clone, Copy, PartialEq, Debug)]
@@ -371,6 +373,8 @@ pub struct Config {
 
     /// Whether to rerun tests even if the inputs are unchanged.
     pub force_rerun: bool,
+
+    pub target_cfg: LazyCell<TargetCfg>,
 }
 
 impl Config {
@@ -380,6 +384,131 @@ impl Config {
             !self.target.ends_with("-fuchsia")
         })
     }
+
+    fn target_cfg(&self) -> &TargetCfg {
+        self.target_cfg.borrow_with(|| TargetCfg::new(&self.rustc_path, &self.target))
+    }
+
+    pub fn matches_arch(&self, arch: &str) -> bool {
+        self.target_cfg().arch == arch ||
+        // Shorthand for convenience. The arch for
+        // asmjs-unknown-emscripten is actually wasm32.
+        (arch == "asmjs" && self.target.starts_with("asmjs")) ||
+        // Matching all the thumb variants as one can be convenient.
+        // (thumbv6m, thumbv7em, thumbv7m, etc.)
+        (arch == "thumb" && self.target.starts_with("thumb"))
+    }
+
+    pub fn matches_os(&self, os: &str) -> bool {
+        self.target_cfg().os == os
+    }
+
+    pub fn matches_env(&self, env: &str) -> bool {
+        self.target_cfg().env == env
+    }
+
+    pub fn matches_abi(&self, abi: &str) -> bool {
+        self.target_cfg().abi == abi
+    }
+
+    pub fn matches_family(&self, family: &str) -> bool {
+        self.target_cfg().families.iter().any(|f| f == family)
+    }
+
+    pub fn is_big_endian(&self) -> bool {
+        self.target_cfg().endian == Endian::Big
+    }
+
+    pub fn get_pointer_width(&self) -> u32 {
+        *&self.target_cfg().pointer_width
+    }
+
+    pub fn has_asm_support(&self) -> bool {
+        static ASM_SUPPORTED_ARCHS: &[&str] = &[
+            "x86", "x86_64", "arm", "aarch64", "riscv32",
+            "riscv64",
+            // These targets require an additional asm_experimental_arch feature.
+            // "nvptx64", "hexagon", "mips", "mips64", "spirv", "wasm32",
+        ];
+        ASM_SUPPORTED_ARCHS.contains(&self.target_cfg().arch.as_str())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TargetCfg {
+    arch: String,
+    os: String,
+    env: String,
+    abi: String,
+    families: Vec<String>,
+    pointer_width: u32,
+    endian: Endian,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub enum Endian {
+    Little,
+    Big,
+}
+
+impl TargetCfg {
+    fn new(rustc_path: &Path, target: &str) -> TargetCfg {
+        let output = match Command::new(rustc_path)
+            .arg("--print=cfg")
+            .arg("--target")
+            .arg(target)
+            .output()
+        {
+            Ok(output) => output,
+            Err(e) => panic!("error: failed to get cfg info from {:?}: {e}", rustc_path),
+        };
+        if !output.status.success() {
+            panic!(
+                "error: failed to get cfg info from {:?}\n--- stdout\n{}\n--- stderr\n{}",
+                rustc_path,
+                String::from_utf8(output.stdout).unwrap(),
+                String::from_utf8(output.stderr).unwrap(),
+            );
+        }
+        let print_cfg = String::from_utf8(output.stdout).unwrap();
+        let mut arch = None;
+        let mut os = None;
+        let mut env = None;
+        let mut abi = None;
+        let mut families = Vec::new();
+        let mut pointer_width = None;
+        let mut endian = None;
+        for line in print_cfg.lines() {
+            if let Some((name, value)) = line.split_once('=') {
+                let value = value.trim_matches('"');
+                match name {
+                    "target_arch" => arch = Some(value),
+                    "target_os" => os = Some(value),
+                    "target_env" => env = Some(value),
+                    "target_abi" => abi = Some(value),
+                    "target_family" => families.push(value.to_string()),
+                    "target_pointer_width" => pointer_width = Some(value.parse().unwrap()),
+                    "target_endian" => {
+                        endian = Some(match value {
+                            "little" => Endian::Little,
+                            "big" => Endian::Big,
+                            s => panic!("unexpected {s}"),
+                        })
+                    }
+                    _ => {}
+                }
+            }
+        }
+        TargetCfg {
+            arch: arch.unwrap().to_string(),
+            os: os.unwrap().to_string(),
+            env: env.unwrap().to_string(),
+            abi: abi.unwrap().to_string(),
+            families,
+            pointer_width: pointer_width.unwrap(),
+            endian: endian.unwrap(),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]

src/tools/compiletest/src/header.rs

@@ -661,17 +661,36 @@ impl Config {
 
         let name = line[prefix.len() + 1..].split(&[':', ' '][..]).next().unwrap();
 
+        let matches_pointer_width = || {
+            name.strip_suffix("bit")
+                .and_then(|width| width.parse::<u32>().ok())
+                .map(|width| self.get_pointer_width() == width)
+                .unwrap_or(false)
+        };
+
+        // If something is ignored for emscripten, it likely also needs to be
+        // ignored for wasm32-unknown-unknown.
+        // `wasm32-bare` is an alias to refer to just wasm32-unknown-unknown
+        // (in contrast to `wasm32` which also matches non-bare targets like
+        // asmjs-unknown-emscripten).
+        let matches_wasm32_alias = || {
+            self.target == "wasm32-unknown-unknown" && matches!(name, "emscripten" | "wasm32-bare")
+        };
+
         let is_match = name == "test" ||
             self.target == name ||                              // triple
-            util::matches_os(&self.target, name) ||             // target
+            self.matches_os(name) ||
-            util::matches_env(&self.target, name) ||            // env
+            self.matches_env(name) ||
+            self.matches_abi(name) ||
+            self.matches_family(name) ||
             self.target.ends_with(name) ||                      // target and env
-            name == util::get_arch(&self.target) ||             // architecture
+            self.matches_arch(name) ||
-            name == util::get_pointer_width(&self.target) ||    // pointer width
+            matches_wasm32_alias() ||
+            matches_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)) ||
+            (name == "endian-big" && self.is_big_endian()) ||
             (self.remote_test_client.is_some() && name == "remote") ||
             match self.compare_mode {
                 Some(CompareMode::Polonius) => name == "compare-mode-polonius",
@@ -869,7 +888,7 @@ pub fn make_test_description<R: Read>(
 
     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);
+    let has_asm_support = config.has_asm_support();
     let has_asan = util::ASAN_SUPPORTED_TARGETS.contains(&&*config.target);
     let has_cfi = util::CFI_SUPPORTED_TARGETS.contains(&&*config.target);
     let has_lsan = util::LSAN_SUPPORTED_TARGETS.contains(&&*config.target);

src/tools/compiletest/src/header/tests.rs

@@ -42,7 +42,6 @@ fn config() -> Config {
         "--suite=ui",
         "--compile-lib-path=",
         "--run-lib-path=",
-        "--rustc-path=",
         "--python=",
         "--jsondocck-path=",
         "--src-base=",
@@ -57,7 +56,24 @@ fn config() -> Config {
         "--target=x86_64-unknown-linux-gnu",
         "--channel=nightly",
     ];
-    let args = args.iter().map(ToString::to_string).collect();
+    let mut args: Vec<String> = args.iter().map(ToString::to_string).collect();
+    args.push("--rustc-path".to_string());
+    // This is a subtle/fragile thing. On rust-lang CI, there is no global
+    // `rustc`, and Cargo doesn't offer a convenient way to get the path to
+    // `rustc`. Fortunately bootstrap sets `RUSTC` for us, which is pointing
+    // to the stage0 compiler.
+    //
+    // Otherwise, if you are running compiletests's tests manually, you
+    // probably don't have `RUSTC` set, in which case this falls back to the
+    // global rustc. If your global rustc is too far out of sync with stage0,
+    // then this may cause confusing errors. Or if for some reason you don't
+    // have rustc in PATH, that would also fail.
+    args.push(std::env::var("RUSTC").unwrap_or_else(|_| {
+        eprintln!(
+            "warning: RUSTC not set, using global rustc (are you not running via bootstrap?)"
+        );
+        "rustc".to_string()
+    }));
     crate::parse_config(args)
 }
 
@@ -237,13 +253,20 @@ fn sanitizers() {
 
 #[test]
 fn asm_support() {
-    let mut config = config();
+    let asms = [
-
+        ("avr-unknown-gnu-atmega328", false),
-    config.target = "avr-unknown-gnu-atmega328".to_owned();
+        ("i686-unknown-netbsd", true),
-    assert!(check_ignore(&config, "// needs-asm-support"));
+        ("riscv32gc-unknown-linux-gnu", true),
-
+        ("riscv64imac-unknown-none-elf", true),
-    config.target = "i686-unknown-netbsd".to_owned();
+        ("x86_64-unknown-linux-gnu", true),
-    assert!(!check_ignore(&config, "// needs-asm-support"));
+        ("i686-unknown-netbsd", true),
+    ];
+    for (target, has_asm) in asms {
+        let mut config = config();
+        config.target = target.to_string();
+        assert_eq!(config.has_asm_support(), has_asm);
+        assert_eq!(check_ignore(&config, "// needs-asm-support"), !has_asm)
+    }
 }
 
 #[test]
@@ -281,3 +304,155 @@ fn test_duplicate_revisions() {
     let config = config();
     parse_rs(&config, "// revisions: rpass1 rpass1");
 }
+
+#[test]
+fn ignore_arch() {
+    let archs = [
+        ("x86_64-unknown-linux-gnu", "x86_64"),
+        ("i686-unknown-linux-gnu", "x86"),
+        ("nvptx64-nvidia-cuda", "nvptx64"),
+        ("asmjs-unknown-emscripten", "wasm32"),
+        ("asmjs-unknown-emscripten", "asmjs"),
+        ("thumbv7m-none-eabi", "thumb"),
+    ];
+    for (target, arch) in archs {
+        let mut config = config();
+        config.target = target.to_string();
+        assert!(config.matches_arch(arch), "{target} {arch}");
+        assert!(check_ignore(&config, &format!("// ignore-{arch}")));
+    }
+}
+
+#[test]
+fn matches_os() {
+    let oss = [
+        ("x86_64-unknown-linux-gnu", "linux"),
+        ("x86_64-fortanix-unknown-sgx", "unknown"),
+        ("wasm32-unknown-unknown", "unknown"),
+        ("x86_64-unknown-none", "none"),
+    ];
+    for (target, os) in oss {
+        let mut config = config();
+        config.target = target.to_string();
+        assert!(config.matches_os(os), "{target} {os}");
+        assert!(check_ignore(&config, &format!("// ignore-{os}")));
+    }
+}
+
+#[test]
+fn matches_env() {
+    let envs = [
+        ("x86_64-unknown-linux-gnu", "gnu"),
+        ("x86_64-fortanix-unknown-sgx", "sgx"),
+        ("arm-unknown-linux-musleabi", "musl"),
+    ];
+    for (target, env) in envs {
+        let mut config = config();
+        config.target = target.to_string();
+        assert!(config.matches_env(env), "{target} {env}");
+        assert!(check_ignore(&config, &format!("// ignore-{env}")));
+    }
+}
+
+#[test]
+fn matches_abi() {
+    let abis = [
+        ("aarch64-apple-ios-macabi", "macabi"),
+        ("x86_64-unknown-linux-gnux32", "x32"),
+        ("arm-unknown-linux-gnueabi", "eabi"),
+    ];
+    for (target, abi) in abis {
+        let mut config = config();
+        config.target = target.to_string();
+        assert!(config.matches_abi(abi), "{target} {abi}");
+        assert!(check_ignore(&config, &format!("// ignore-{abi}")));
+    }
+}
+
+#[test]
+fn is_big_endian() {
+    let endians = [
+        ("x86_64-unknown-linux-gnu", false),
+        ("bpfeb-unknown-none", true),
+        ("m68k-unknown-linux-gnu", true),
+        ("aarch64_be-unknown-linux-gnu", true),
+        ("powerpc64-unknown-linux-gnu", true),
+    ];
+    for (target, is_big) in endians {
+        let mut config = config();
+        config.target = target.to_string();
+        assert_eq!(config.is_big_endian(), is_big, "{target} {is_big}");
+        assert_eq!(check_ignore(&config, "// ignore-endian-big"), is_big);
+    }
+}
+
+#[test]
+fn pointer_width() {
+    let widths = [
+        ("x86_64-unknown-linux-gnu", 64),
+        ("i686-unknown-linux-gnu", 32),
+        ("arm64_32-apple-watchos", 32),
+        ("msp430-none-elf", 16),
+    ];
+    for (target, width) in widths {
+        let mut config = config();
+        config.target = target.to_string();
+        assert_eq!(config.get_pointer_width(), width, "{target} {width}");
+        assert_eq!(check_ignore(&config, "// ignore-16bit"), width == 16);
+        assert_eq!(check_ignore(&config, "// ignore-32bit"), width == 32);
+        assert_eq!(check_ignore(&config, "// ignore-64bit"), width == 64);
+    }
+}
+
+#[test]
+fn wasm_special() {
+    let ignores = [
+        ("wasm32-unknown-unknown", "emscripten", true),
+        ("wasm32-unknown-unknown", "wasm32", true),
+        ("wasm32-unknown-unknown", "wasm32-bare", true),
+        ("wasm32-unknown-unknown", "wasm64", false),
+        ("asmjs-unknown-emscripten", "emscripten", true),
+        ("asmjs-unknown-emscripten", "wasm32", true),
+        ("asmjs-unknown-emscripten", "wasm32-bare", false),
+        ("wasm32-unknown-emscripten", "emscripten", true),
+        ("wasm32-unknown-emscripten", "wasm32", true),
+        ("wasm32-unknown-emscripten", "wasm32-bare", false),
+        ("wasm32-wasi", "emscripten", false),
+        ("wasm32-wasi", "wasm32", true),
+        ("wasm32-wasi", "wasm32-bare", false),
+        ("wasm32-wasi", "wasi", true),
+        ("wasm64-unknown-unknown", "emscripten", false),
+        ("wasm64-unknown-unknown", "wasm32", false),
+        ("wasm64-unknown-unknown", "wasm32-bare", false),
+        ("wasm64-unknown-unknown", "wasm64", true),
+    ];
+    for (target, pattern, ignore) in ignores {
+        let mut config = config();
+        config.target = target.to_string();
+        assert_eq!(
+            check_ignore(&config, &format!("// ignore-{pattern}")),
+            ignore,
+            "{target} {pattern}"
+        );
+    }
+}
+
+#[test]
+fn families() {
+    let families = [
+        ("x86_64-unknown-linux-gnu", "unix"),
+        ("x86_64-pc-windows-gnu", "windows"),
+        ("wasm32-unknown-unknown", "wasm"),
+        ("wasm32-unknown-emscripten", "wasm"),
+        ("wasm32-unknown-emscripten", "unix"),
+    ];
+    for (target, family) in families {
+        let mut config = config();
+        config.target = target.to_string();
+        assert!(config.matches_family(family));
+        let other = if family == "windows" { "unix" } else { "windows" };
+        assert!(!config.matches_family(other));
+        assert!(check_ignore(&config, &format!("// ignore-{family}")));
+        assert!(!check_ignore(&config, &format!("// ignore-{other}")));
+    }
+}

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 lazycell::LazyCell;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
@@ -299,6 +300,8 @@ pub fn parse_config(args: Vec<String>) -> Config {
         npm: matches.opt_str("npm"),
 
         force_rerun: matches.opt_present("force-rerun"),
+
+        target_cfg: LazyCell::new(),
     }
 }
 
@@ -441,7 +444,7 @@ fn configure_cdb(config: &Config) -> Option<Config> {
 fn configure_gdb(config: &Config) -> Option<Config> {
     config.gdb_version?;
 
-    if util::matches_env(&config.target, "msvc") {
+    if config.matches_env("msvc") {
         return None;
     }
 

src/tools/compiletest/src/runtest.rs

@@ -13,7 +13,6 @@ use crate::errors::{self, Error, ErrorKind};
 use crate::header::TestProps;
 use crate::json;
 use crate::read2::read2_abbreviated;
-use crate::util::get_pointer_width;
 use crate::util::{logv, PathBufExt};
 use crate::ColorConfig;
 use regex::{Captures, Regex};
@@ -3127,7 +3126,7 @@ impl<'test> TestCx<'test> {
         output_kind: TestOutput,
         explicit_format: bool,
     ) -> usize {
-        let stderr_bits = format!("{}.stderr", get_pointer_width(&self.config.target));
+        let stderr_bits = format!("{}bit.stderr", self.config.get_pointer_width());
         let (stderr_kind, stdout_kind) = match output_kind {
             TestOutput::Compile => (
                 {
@@ -3402,7 +3401,7 @@ impl<'test> TestCx<'test> {
 
         let mut bit_width = String::new();
         if test_file_contents.lines().any(|l| l == "// EMIT_MIR_FOR_EACH_BIT_WIDTH") {
-            bit_width = format!(".{}", get_pointer_width(&self.config.target));
+            bit_width = format!(".{}bit", self.config.get_pointer_width());
         }
 
         if self.config.bless {

src/tools/compiletest/src/util.rs

@@ -8,84 +8,6 @@ use tracing::*;
 #[cfg(test)]
 mod tests;
 
-/// Conversion table from triple OS name to Rust SYSNAME
-const OS_TABLE: &[(&str, &str)] = &[
-    ("android", "android"),
-    ("androideabi", "android"),
-    ("cuda", "cuda"),
-    ("darwin", "macos"),
-    ("dragonfly", "dragonfly"),
-    ("emscripten", "emscripten"),
-    ("freebsd", "freebsd"),
-    ("fuchsia", "fuchsia"),
-    ("haiku", "haiku"),
-    ("hermit", "hermit"),
-    ("illumos", "illumos"),
-    ("ios", "ios"),
-    ("l4re", "l4re"),
-    ("linux", "linux"),
-    ("mingw32", "windows"),
-    ("none", "none"),
-    ("netbsd", "netbsd"),
-    ("openbsd", "openbsd"),
-    ("redox", "redox"),
-    ("sgx", "sgx"),
-    ("solaris", "solaris"),
-    ("watchos", "watchos"),
-    ("win32", "windows"),
-    ("windows", "windows"),
-    ("vxworks", "vxworks"),
-];
-
-const ARCH_TABLE: &[(&str, &str)] = &[
-    ("aarch64", "aarch64"),
-    ("aarch64_be", "aarch64"),
-    ("amd64", "x86_64"),
-    ("arm", "arm"),
-    ("arm64", "aarch64"),
-    ("armv4t", "arm"),
-    ("armv5te", "arm"),
-    ("armv7", "arm"),
-    ("armv7s", "arm"),
-    ("asmjs", "asmjs"),
-    ("avr", "avr"),
-    ("bpfeb", "bpf"),
-    ("bpfel", "bpf"),
-    ("hexagon", "hexagon"),
-    ("i386", "x86"),
-    ("i586", "x86"),
-    ("i686", "x86"),
-    ("m68k", "m68k"),
-    ("mips", "mips"),
-    ("mips64", "mips64"),
-    ("mips64el", "mips64"),
-    ("mipsisa32r6", "mips"),
-    ("mipsisa32r6el", "mips"),
-    ("mipsisa64r6", "mips64"),
-    ("mipsisa64r6el", "mips64"),
-    ("mipsel", "mips"),
-    ("mipsisa32r6", "mips"),
-    ("mipsisa32r6el", "mips"),
-    ("mipsisa64r6", "mips64"),
-    ("mipsisa64r6el", "mips64"),
-    ("msp430", "msp430"),
-    ("nvptx64", "nvptx64"),
-    ("powerpc", "powerpc"),
-    ("powerpc64", "powerpc64"),
-    ("powerpc64le", "powerpc64"),
-    ("riscv64gc", "riscv64"),
-    ("s390x", "s390x"),
-    ("sparc", "sparc"),
-    ("sparc64", "sparc64"),
-    ("sparcv9", "sparc64"),
-    ("thumbv6m", "thumb"),
-    ("thumbv7em", "thumb"),
-    ("thumbv7m", "thumb"),
-    ("wasm32", "wasm32"),
-    ("x86_64", "x86_64"),
-    ("xcore", "xcore"),
-];
-
 pub const ASAN_SUPPORTED_TARGETS: &[&str] = &[
     "aarch64-apple-darwin",
     "aarch64-fuchsia",
@@ -140,80 +62,6 @@ pub const MEMTAG_SUPPORTED_TARGETS: &[&str] =
 
 pub const SHADOWCALLSTACK_SUPPORTED_TARGETS: &[&str] = &["aarch64-linux-android"];
 
-const BIG_ENDIAN: &[&str] = &[
-    "aarch64_be",
-    "armebv7r",
-    "mips",
-    "mips64",
-    "mipsisa32r6",
-    "mipsisa64r6",
-    "powerpc",
-    "powerpc64",
-    "s390x",
-    "sparc",
-    "sparc64",
-    "sparcv9",
-];
-
-static ASM_SUPPORTED_ARCHS: &[&str] = &[
-    "x86", "x86_64", "arm", "aarch64", "riscv32",
-    "riscv64",
-    // These targets require an additional asm_experimental_arch feature.
-    // "nvptx64", "hexagon", "mips", "mips64", "spirv", "wasm32",
-];
-
-pub fn has_asm_support(triple: &str) -> bool {
-    ASM_SUPPORTED_ARCHS.contains(&get_arch(triple))
-}
-
-pub fn matches_os(triple: &str, name: &str) -> bool {
-    // For the wasm32 bare target we ignore anything also ignored on emscripten
-    // and then we also recognize `wasm32-bare` as the os for the target
-    if triple == "wasm32-unknown-unknown" {
-        return name == "emscripten" || name == "wasm32-bare";
-    }
-    let triple: Vec<_> = triple.split('-').collect();
-    for &(triple_os, os) in OS_TABLE {
-        if triple.contains(&triple_os) {
-            return os == name;
-        }
-    }
-    panic!("Cannot determine OS from triple");
-}
-
-/// Determine the architecture from `triple`
-pub fn get_arch(triple: &str) -> &'static str {
-    let triple: Vec<_> = triple.split('-').collect();
-    for &(triple_arch, arch) in ARCH_TABLE {
-        if triple.contains(&triple_arch) {
-            return arch;
-        }
-    }
-    panic!("Cannot determine Architecture from triple");
-}
-
-/// Determine the endianness from `triple`
-pub fn is_big_endian(triple: &str) -> bool {
-    let triple_arch = triple.split('-').next().unwrap();
-    BIG_ENDIAN.contains(&triple_arch)
-}
-
-pub fn matches_env(triple: &str, name: &str) -> bool {
-    if let Some(env) = triple.split('-').nth(3) { env.starts_with(name) } else { false }
-}
-
-pub fn get_pointer_width(triple: &str) -> &'static str {
-    if (triple.contains("64") && !triple.ends_with("gnux32") && !triple.ends_with("gnu_ilp32"))
-        || triple.starts_with("s390x")
-    {
-        "64bit"
-    } else if triple.starts_with("avr") {
-        "16bit"
-    } else {
-        "32bit"
-    }
-}
-
 pub fn make_new_path(path: &str) -> String {
     assert!(cfg!(windows));
     // Windows just uses PATH as the library search path, so we have to

src/tools/compiletest/src/util/tests.rs

@@ -1,42 +1,5 @@
 use super::*;
 
-#[test]
-#[should_panic(expected = "Cannot determine Architecture from triple")]
-fn test_get_arch_failure() {
-    get_arch("abc");
-}
-
-#[test]
-fn test_get_arch() {
-    assert_eq!("x86_64", get_arch("x86_64-unknown-linux-gnu"));
-    assert_eq!("x86_64", get_arch("amd64"));
-    assert_eq!("nvptx64", get_arch("nvptx64-nvidia-cuda"));
-}
-
-#[test]
-#[should_panic(expected = "Cannot determine OS from triple")]
-fn test_matches_os_failure() {
-    matches_os("abc", "abc");
-}
-
-#[test]
-fn test_matches_os() {
-    assert!(matches_os("x86_64-unknown-linux-gnu", "linux"));
-    assert!(matches_os("wasm32-unknown-unknown", "emscripten"));
-    assert!(matches_os("wasm32-unknown-unknown", "wasm32-bare"));
-    assert!(!matches_os("wasm32-unknown-unknown", "windows"));
-    assert!(matches_os("thumbv6m0-none-eabi", "none"));
-    assert!(matches_os("riscv32imc-unknown-none-elf", "none"));
-    assert!(matches_os("nvptx64-nvidia-cuda", "cuda"));
-    assert!(matches_os("x86_64-fortanix-unknown-sgx", "sgx"));
-}
-
-#[test]
-fn is_big_endian_test() {
-    assert!(!is_big_endian("no"));
-    assert!(is_big_endian("sparc-unknown-unknown"));
-}
-
 #[test]
 fn path_buf_with_extra_extension_test() {
     assert_eq!(