mirror of
https://github.com/rust-lang/rust.git
synced 2025-05-14 02:49:40 +00:00
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
This commit is contained in:
bors
commit
c7ff1e8b00
@ -817,6 +817,7 @@ dependencies = [
|
||||
"getopts",
|
||||
"glob",
|
||||
"lazy_static",
|
||||
"lazycell",
|
||||
"libc",
|
||||
"miow",
|
||||
"regex",
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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)]
|
||||
|
||||
@ -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
|
||||
util::matches_env(&self.target, name) || // env
|
||||
self.matches_os(name) ||
|
||||
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
|
||||
name == util::get_pointer_width(&self.target) || // pointer width
|
||||
self.matches_arch(name) ||
|
||||
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);
|
||||
|
||||
@ -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 asms = [
|
||||
("avr-unknown-gnu-atmega328", false),
|
||||
("i686-unknown-netbsd", true),
|
||||
("riscv32gc-unknown-linux-gnu", true),
|
||||
("riscv64imac-unknown-none-elf", true),
|
||||
("x86_64-unknown-linux-gnu", true),
|
||||
("i686-unknown-netbsd", true),
|
||||
];
|
||||
for (target, has_asm) in asms {
|
||||
let mut config = config();
|
||||
|
||||
config.target = "avr-unknown-gnu-atmega328".to_owned();
|
||||
assert!(check_ignore(&config, "// needs-asm-support"));
|
||||
|
||||
config.target = "i686-unknown-netbsd".to_owned();
|
||||
assert!(!check_ignore(&config, "// needs-asm-support"));
|
||||
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}")));
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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!(
|
||||
|
||||
Loading…
Reference in New Issue
Block a user