user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #143683 - jieyouxu:rms-cleanup, r=Kobzol

Browse source 
Assorted `run-make-support` maintenance

This PR should contain no functional changes.

- Commit 1: Removes the support library's CHANGELOG. In the very beginning, I thought maybe we would try to version this library. But this is a purely internal test support library, and it's just extra busywork trying to maintain changelog/versions. It's also hopelessly outdated.
- Commit 2: Resets version number to `0.0.0`. Ditto on busywork.
- Commit 3: Bump `run-make-support` to Edition 2024. The support library was already "compliant" with Edition 2024.
- Commit 4: Slightly organizes the support library dependencies.
- Commit 5: Previously, I tried hopelessly to maintain some manual formatting, but that was annoying because it required skipping rustfmt (so export ordering etc. could not be extra formatted). Give up, and do some rearrangements / module prefix tricks to get the `lib.rs` looking at least *reasonable*. IMO this is not a strict improvement, but I rather regain the ability to auto-format it with rustfmt.
- Commit {6,7}: Noticed in rust-lang/rust#143669 that we apparently had *both* {`is_msvc`, `is_windows_msvc`}. This PR removes `is_msvc` in favor of `is_windows_msvc` to make it unambiguous (and only retain one way of gating) as there are some UEFI targets which are MSVC but not Windows.

Best reviewed commit-by-commit.

r? `@Kobzol`
This commit is contained in:
Matthias Krüger 2025-07-10 15:19:35 +02:00 • committed by GitHub
commit b5b35f1aa4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
33 changed files with 146 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock
View file

@ -3214,7 +3214,7 @@ dependencies = [
[[package]]
name = "run_make_support"
version = "0.2.0"
version = "0.0.0"
dependencies = [
"bstr",
"build_helper",

83
src/tools/run-make-support/CHANGELOG.md
View file

@ -1,83 +0,0 @@
# Changelog
All notable changes to the `run_make_support` library should be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the support
library should adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) even if it's
not intended for public consumption (it's moreso to help internally, to help test writers track
changes to the support library).
This support library will probably never reach 1.0. Please bump the minor version in `Cargo.toml` if
you make any breaking changes or other significant changes, or bump the patch version for bug fixes.
## [0.2.0] - 2024-06-11
### Added
- Added `fs_wrapper` module which provides panic-on-fail helpers for their respective `std::fs`
counterparts, the motivation is to:
- Reduce littering `.unwrap()` or `.expect()` everywhere for fs operations
- Help the test writer avoid forgetting to check fs results (even though enforced by
`-Dunused_must_use`)
- Provide better panic messages by default
- Added `path()` helper which creates a `Path` relative to `cwd()` (but is less noisy).
### Changed
- Marked many functions with `#[must_use]`, and rmake.rs are now compiled with `-Dunused_must_use`.
## [0.1.0] - 2024-06-09
### Changed
- Use *drop bombs* to enforce that commands are executed; a command invocation will panic if it is
constructed but never executed. Execution methods `Command::{run, run_fail}` will defuse the drop
bomb.
- Added `Command` helpers that forward to `std::process::Command` counterparts.
### Removed
- The `env_var` method which was incorrectly named and is `env_clear` underneath and is a footgun
from `impl_common_helpers`. For example, removing `TMPDIR` on Unix and `TMP`/`TEMP` breaks
`std::env::temp_dir` and wrecks anything using that, such as rustc's codgen.
- Removed `Deref`/`DerefMut` for `run_make_support::Command` -> `std::process::Command` because it
causes a method chain like `htmldocck().arg().run()` to fail, because `arg()` resolves to
`std::process::Command` which also returns a `&mut std::process::Command`, causing the `run()` to
be not found.
## [0.0.0] - 2024-06-09
Consider this version to contain all changes made to the support library before we started to track
changes in this changelog.
### Added
- Custom command wrappers around `std::process::Command` (`run_make_support::Command`) and custom
wrapper around `std::process::Output` (`CompletedProcess`) to make it more convenient to work with
commands and their output, and help avoid forgetting to check for exit status.
- `Command`: `set_stdin`, `run`, `run_fail`.
- `CompletedProcess`: `std{err,out}_utf8`, `status`, `assert_std{err,out}_{equals, contains,
not_contains}`, `assert_exit_code`.
- `impl_common_helpers` macro to avoid repeating adding common convenience methods, including:
- Environment manipulation methods: `env`, `env_remove`
- Command argument providers: `arg`, `args`
- Common invocation inspection (of the command invocation up until `inspect` is called):
`inspect`
- Execution methods: `run` (for commands expected to succeed execution, exit status `0`) and
`run_fail` (for commands expected to fail execution, exit status non-zero).
- Command wrappers around: `rustc`, `clang`, `cc`, `rustc`, `rustdoc`, `llvm-readobj`.
- Thin helpers to construct `python` and `htmldocck` commands.
- `run` and `run_fail` (like `Command::{run, run_fail}`) for running binaries, which sets suitable
env vars (like `LD_LIB_PATH` or equivalent, `TARGET_RPATH_ENV`, `PATH` on Windows).
- Pseudo command `diff` which has similar functionality as the cli util but not the same API.
- Convenience panic-on-fail helpers `env_var`, `env_var_os`, `cwd` for their `std::env` conterparts.
- Convenience panic-on-fail helpers for reading respective env vars: `target`, `source_root`.
- Platform check helpers: `is_windows`, `is_msvc`, `cygpath_windows`, `uname`.
- fs helpers: `copy_dir_all`.
- `recursive_diff` helper.
- Generic `assert_not_contains` helper.
- Scoped run-with-teardown helper `run_in_tmpdir` which is designed to run commands in a temporary
directory that is cleared when closure returns.
- Helpers for constructing the name of binaries and libraries: `rust_lib_name`, `static_lib_name`,
`bin_name`, `dynamic_lib_name`.
- Re-export libraries: `gimli`, `object`, `regex`, `wasmparsmer`.

21
src/tools/run-make-support/Cargo.toml
View file

@ -1,18 +1,27 @@
[package]
name = "run_make_support"
version = "0.2.0"
edition = "2021"
version = "0.0.0"
edition = "2024"
[dependencies]
# These dependencies are either used to implement part of support library
# functionality, or re-exported to test recipe programs via the support library,
# or both.
# tidy-alphabetical-start
bstr = "1.12"
gimli = "0.32"
libc = "0.2"
object = "0.37"
regex = "1.11"
serde_json = "1.0"
similar = "2.7"
wasmparser = { version = "0.219", default-features = false, features = ["std"] }
regex = "1.11"
gimli = "0.32"
# tidy-alphabetical-end
# Shared with bootstrap and compiletest
build_helper = { path = "../../build_helper" }
serde_json = "1.0"
libc = "0.2"
[lib]
crate-type = ["lib", "dylib"]

6
src/tools/run-make-support/src/artifact_names.rs
View file

@ -2,7 +2,7 @@
//! libraries which are target-dependent.
use crate::target;
use crate::targets::is_msvc;
use crate::targets::is_windows_msvc;
/// Construct the static library name based on the target.
#[track_caller]
@ -10,7 +10,7 @@ use crate::targets::is_msvc;
pub fn static_lib_name(name: &str) -> String {
assert!(!name.contains(char::is_whitespace), "static library name cannot contain whitespace");
if is_msvc() { format!("{name}.lib") } else { format!("lib{name}.a") }
if is_windows_msvc() { format!("{name}.lib") } else { format!("lib{name}.a") }
}
/// Construct the dynamic library name based on the target.
@ -45,7 +45,7 @@ pub fn dynamic_lib_extension() -> &'static str {
#[track_caller]
#[must_use]
pub fn msvc_import_dynamic_lib_name(name: &str) -> String {
assert!(is_msvc(), "this function is exclusive to MSVC");
assert!(is_windows_msvc(), "this function is exclusive to MSVC");
assert!(!name.contains(char::is_whitespace), "import library name cannot contain whitespace");
format!("{name}.dll.lib")

23
src/tools/run-make-support/src/external_deps/c_build.rs
View file

@ -4,7 +4,7 @@ use crate::artifact_names::{dynamic_lib_name, static_lib_name};
use crate::external_deps::c_cxx_compiler::{cc, cxx};
use crate::external_deps::llvm::llvm_ar;
use crate::path_helpers::path;
use crate::targets::{is_darwin, is_msvc, is_windows};
use crate::targets::{is_darwin, is_windows, is_windows_msvc};
// FIXME(Oneirical): These native build functions should take a Path-based generic.
@ -24,12 +24,12 @@ pub fn build_native_static_lib_optimized(lib_name: &str) -> PathBuf {
#[track_caller]
fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let src = format!("{lib_name}.c");
let lib_path = static_lib_name(lib_name);
let mut cc = cc();
if !is_msvc() {
if !is_windows_msvc() {
cc.arg("-v");
}
if optimzed {
@ -37,7 +37,7 @@ fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
}
cc.arg("-c").out_exe(&obj_file).input(src).optimize().run();
let obj_file = if is_msvc() {
let obj_file = if is_windows_msvc() {
PathBuf::from(format!("{lib_name}.obj"))
} else {
PathBuf::from(format!("{lib_name}.o"))
@ -50,16 +50,17 @@ fn build_native_static_lib_internal(lib_name: &str, optimzed: bool) -> PathBuf {
/// [`std::env::consts::DLL_PREFIX`] and [`std::env::consts::DLL_EXTENSION`].
#[track_caller]
pub fn build_native_dynamic_lib(lib_name: &str) -> PathBuf {
let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let src = format!("{lib_name}.c");
let lib_path = dynamic_lib_name(lib_name);
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe(&obj_file).input(src).run();
} else {
cc().arg("-v").arg("-c").out_exe(&obj_file).input(src).run();
};
let obj_file = if is_msvc() { format!("{lib_name}.obj") } else { format!("{lib_name}.o") };
if is_msvc() {
let obj_file =
if is_windows_msvc() { format!("{lib_name}.obj") } else { format!("{lib_name}.o") };
if is_windows_msvc() {
let out_arg = format!("-out:{lib_path}");
cc().input(&obj_file).args(&["-link", "-dll", &out_arg]).run();
} else if is_darwin() {
@ -79,15 +80,15 @@ pub fn build_native_dynamic_lib(lib_name: &str) -> PathBuf {
/// Built from a C++ file.
#[track_caller]
pub fn build_native_static_lib_cxx(lib_name: &str) -> PathBuf {
let obj_file = if is_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let obj_file = if is_windows_msvc() { format!("{lib_name}") } else { format!("{lib_name}.o") };
let src = format!("{lib_name}.cpp");
let lib_path = static_lib_name(lib_name);
if is_msvc() {
if is_windows_msvc() {
cxx().arg("-EHs").arg("-c").out_exe(&obj_file).input(src).run();
} else {
cxx().arg("-c").out_exe(&obj_file).input(src).run();
};
let obj_file = if is_msvc() {
let obj_file = if is_windows_msvc() {
PathBuf::from(format!("{lib_name}.obj"))
} else {
PathBuf::from(format!("{lib_name}.o"))

6
src/tools/run-make-support/src/external_deps/c_cxx_compiler/cc.rs
View file

@ -1,7 +1,7 @@
use std::path::Path;
use crate::command::Command;
use crate::{env_var, is_msvc};
use crate::{env_var, is_windows_msvc};
/// Construct a new platform-specific C compiler invocation.
///
@ -82,7 +82,7 @@ impl Cc {
pub fn out_exe(&mut self, name: &str) -> &mut Self {
let mut path = std::path::PathBuf::from(name);
if is_msvc() {
if is_windows_msvc() {
path.set_extension("exe");
let fe_path = path.clone();
path.set_extension("");
@ -108,7 +108,7 @@ impl Cc {
/// Optimize the output.
/// Equivalent to `-O3` for GNU-compatible linkers or `-O2` for MSVC linkers.
pub fn optimize(&mut self) -> &mut Self {
if is_msvc() {
if is_windows_msvc() {
self.cmd.arg("-O2");
} else {
self.cmd.arg("-O3");

6
src/tools/run-make-support/src/external_deps/c_cxx_compiler/extras.rs
View file

@ -1,9 +1,9 @@
use crate::{is_msvc, is_win7, is_windows, uname};
use crate::{is_win7, is_windows, is_windows_msvc, uname};
/// `EXTRACFLAGS`
pub fn extra_c_flags() -> Vec<&'static str> {
if is_windows() {
if is_msvc() {
if is_windows_msvc() {
let mut libs =
vec!["ws2_32.lib", "userenv.lib", "bcrypt.lib", "ntdll.lib", "synchronization.lib"];
if is_win7() {
@ -29,7 +29,7 @@ pub fn extra_c_flags() -> Vec<&'static str> {
/// `EXTRACXXFLAGS`
pub fn extra_cxx_flags() -> Vec<&'static str> {
if is_windows() {
if is_msvc() { vec![] } else { vec!["-lstdc++"] }
if is_windows_msvc() { vec![] } else { vec!["-lstdc++"] }
} else {
match &uname()[..] {
"Darwin" => vec!["-lc++"],

4
src/tools/run-make-support/src/external_deps/rustc.rs
View file

@ -6,7 +6,7 @@ use crate::command::Command;
use crate::env::env_var;
use crate::path_helpers::cwd;
use crate::util::set_host_compiler_dylib_path;
use crate::{is_aix, is_darwin, is_msvc, is_windows, target, uname};
use crate::{is_aix, is_darwin, is_windows, is_windows_msvc, target, uname};
/// Construct a new `rustc` invocation. This will automatically set the library
/// search path as `-L cwd()`. Use [`bare_rustc`] to avoid this.
@ -377,7 +377,7 @@ impl Rustc {
// So we end up with the following hack: we link use static:-bundle to only
// link the parts of libstdc++ that we actually use, which doesn't include
// the dependency on the pthreads DLL.
if !is_msvc() {
if !is_windows_msvc() {
self.cmd.arg("-lstatic:-bundle=stdc++");
};
} else if is_darwin() {

114
src/tools/run-make-support/src/lib.rs
View file

@ -3,9 +3,6 @@
//! notably is built via cargo: this means that if your test wants some non-trivial utility, such
//! as `object` or `wasmparser`, they can be re-exported and be made available through this library.
// We want to control use declaration ordering and spacing (and preserve use group comments), so
// skip rustfmt on this file.
#![cfg_attr(rustfmt, rustfmt::skip)]
#![warn(unreachable_pub)]
mod command;
@ -22,8 +19,8 @@ pub mod path_helpers;
pub mod run;
pub mod scoped_run;
pub mod string;
pub mod targets;
pub mod symbols;
pub mod targets;
// Internally we call our fs-related support module as `fs`, but re-export its content as `rfs`
// to tests to avoid colliding with commonly used `use std::fs;`.
@ -36,77 +33,56 @@ pub mod rfs {
}
// Re-exports of third-party library crates.
// tidy-alphabetical-start
pub use bstr;
pub use gimli;
pub use libc;
pub use object;
pub use regex;
pub use serde_json;
pub use similar;
pub use wasmparser;
// tidy-alphabetical-end
pub use {bstr, gimli, libc, object, regex, serde_json, similar, wasmparser};
// Re-exports of external dependencies.
pub use external_deps::{
cargo, c_build, c_cxx_compiler, clang, htmldocck, llvm, python, rustc, rustdoc
};
// These rely on external dependencies.
pub use c_cxx_compiler::{Cc, Gcc, cc, cxx, extra_c_flags, extra_cxx_flags, gcc};
pub use c_build::{
build_native_dynamic_lib, build_native_static_lib, build_native_static_lib_cxx,
build_native_static_lib_optimized,
};
pub use cargo::cargo;
pub use clang::{clang, Clang};
pub use htmldocck::htmldocck;
pub use llvm::{
llvm_ar, llvm_bcanalyzer, llvm_dis, llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objcopy,
llvm_objdump, llvm_profdata, llvm_readobj, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump,
LlvmFilecheck, LlvmNm, LlvmObjcopy, LlvmObjdump, LlvmProfdata, LlvmReadobj,
};
pub use python::python_command;
pub use rustc::{bare_rustc, rustc, rustc_path, Rustc};
pub use rustdoc::{bare_rustdoc, rustdoc, Rustdoc};
/// [`diff`][mod@diff] is implemented in terms of the [similar] library.
///
/// [similar]: https://github.com/mitsuhiko/similar
pub use diff::{diff, Diff};
/// Panic-on-fail [`std::env::var`] and [`std::env::var_os`] wrappers.
pub use env::{env_var, env_var_os, set_current_dir};
/// Convenience helpers for running binaries and other commands.
pub use run::{cmd, run, run_fail, run_with_args};
/// Helpers for checking target information.
pub use targets::{
apple_os, is_aix, is_darwin, is_msvc, is_windows, is_windows_gnu, is_windows_msvc, is_win7, llvm_components_contain,
target, uname,
};
/// Helpers for building names of output artifacts that are potentially target-specific.
pub use artifact_names::{
// Helpers for building names of output artifacts that are potentially target-specific.
pub use crate::artifact_names::{
bin_name, dynamic_lib_extension, dynamic_lib_name, msvc_import_dynamic_lib_name, rust_lib_name,
static_lib_name,
};
/// Path-related helpers.
pub use path_helpers::{
build_root, cwd, filename_contains, filename_not_in_denylist, has_extension, has_prefix,
has_suffix, not_contains, path, shallow_find_directories, shallow_find_files, source_root,
};
/// Helpers for scoped test execution where certain properties are attempted to be maintained.
pub use scoped_run::{run_in_tmpdir, test_while_readonly};
pub use assertion_helpers::{
pub use crate::assertion_helpers::{
assert_contains, assert_contains_regex, assert_count_is, assert_dirs_are_equal, assert_equals,
assert_not_contains, assert_not_contains_regex,
};
pub use string::{
// `diff` is implemented in terms of the [similar] library.
//
// [similar]: https://github.com/mitsuhiko/similar
pub use crate::diff::{Diff, diff};
// Panic-on-fail [`std::env::var`] and [`std::env::var_os`] wrappers.
pub use crate::env::{env_var, env_var_os, set_current_dir};
pub use crate::external_deps::c_build::{
build_native_dynamic_lib, build_native_static_lib, build_native_static_lib_cxx,
build_native_static_lib_optimized,
};
// Re-exports of external dependencies.
pub use crate::external_deps::c_cxx_compiler::{
Cc, Gcc, cc, cxx, extra_c_flags, extra_cxx_flags, gcc,
};
pub use crate::external_deps::cargo::cargo;
pub use crate::external_deps::clang::{Clang, clang};
pub use crate::external_deps::htmldocck::htmldocck;
pub use crate::external_deps::llvm::{
self, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump, LlvmFilecheck, LlvmNm, LlvmObjcopy,
LlvmObjdump, LlvmProfdata, LlvmReadobj, llvm_ar, llvm_bcanalyzer, llvm_dis, llvm_dwarfdump,
llvm_filecheck, llvm_nm, llvm_objcopy, llvm_objdump, llvm_profdata, llvm_readobj,
};
pub use crate::external_deps::python::python_command;
pub use crate::external_deps::rustc::{self, Rustc, bare_rustc, rustc, rustc_path};
pub use crate::external_deps::rustdoc::{Rustdoc, bare_rustdoc, rustdoc};
// Path-related helpers.
pub use crate::path_helpers::{
build_root, cwd, filename_contains, filename_not_in_denylist, has_extension, has_prefix,
has_suffix, not_contains, path, shallow_find_directories, shallow_find_files, source_root,
};
// Convenience helpers for running binaries and other commands.
pub use crate::run::{cmd, run, run_fail, run_with_args};
// Helpers for scoped test execution where certain properties are attempted to be maintained.
pub use crate::scoped_run::{run_in_tmpdir, test_while_readonly};
pub use crate::string::{
count_regex_matches_in_files_with_extension, invalid_utf8_contains, invalid_utf8_not_contains,
};
// Helpers for checking target information.
pub use crate::targets::{
apple_os, is_aix, is_darwin, is_win7, is_windows, is_windows_gnu, is_windows_msvc,
llvm_components_contain, target, uname,
};

4
src/tools/run-make-support/src/linker.rs
View file

@ -1,6 +1,6 @@
use regex::Regex;
use crate::{Rustc, is_msvc};
use crate::{Rustc, is_windows_msvc};
/// Asserts that `rustc` uses LLD for linking when executed.
pub fn assert_rustc_uses_lld(rustc: &mut Rustc) {
@ -22,7 +22,7 @@ pub fn assert_rustc_doesnt_use_lld(rustc: &mut Rustc) {
fn get_stderr_with_linker_messages(rustc: &mut Rustc) -> String {
// lld-link is used if msvc, otherwise a gnu-compatible lld is used.
let linker_version_flag = if is_msvc() { "--version" } else { "-Wl,-v" };
let linker_version_flag = if is_windows_msvc() { "--version" } else { "-Wl,-v" };
let output = rustc.arg("-Wlinker-messages").link_arg(linker_version_flag).run();
output.stderr_utf8()

12
src/tools/run-make-support/src/targets.rs
View file

@ -16,10 +16,10 @@ pub fn is_windows() -> bool {
target().contains("windows")
}
/// Check if target uses msvc.
/// Check if target is windows-msvc.
#[must_use]
pub fn is_msvc() -> bool {
target().contains("msvc")
pub fn is_windows_msvc() -> bool {
target().ends_with("windows-msvc")
}
/// Check if target is windows-gnu.
@ -28,12 +28,6 @@ pub fn is_windows_gnu() -> bool {
target().ends_with("windows-gnu")
}
/// Check if target is windows-msvc.
#[must_use]
pub fn is_windows_msvc() -> bool {
target().ends_with("windows-msvc")
}
/// Check if target is win7.
#[must_use]
pub fn is_win7() -> bool {

8
tests/run-make/archive-duplicate-names/rmake.rs
View file

@ -6,7 +6,7 @@
//@ ignore-cross-compile
// Reason: the compiled binary is executed
use run_make_support::{cc, is_msvc, llvm_ar, rfs, run, rustc};
use run_make_support::{cc, is_windows_msvc, llvm_ar, rfs, run, rustc};
fn main() {
rfs::create_dir("a");
@ -15,7 +15,7 @@ fn main() {
compile_obj_force_foo("b", "bar");
let mut ar = llvm_ar();
ar.obj_to_ar().arg("libfoo.a");
if is_msvc() {
if is_windows_msvc() {
ar.arg("a/foo.obj").arg("b/foo.obj").run();
} else {
ar.arg("a/foo.o").arg("b/foo.o").run();
@ -27,9 +27,9 @@ fn main() {
#[track_caller]
pub fn compile_obj_force_foo(dir: &str, lib_name: &str) {
let obj_file = if is_msvc() { format!("{dir}/foo") } else { format!("{dir}/foo.o") };
let obj_file = if is_windows_msvc() { format!("{dir}/foo") } else { format!("{dir}/foo.o") };
let src = format!("{lib_name}.c");
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe(&obj_file).input(src).run();
} else {
cc().arg("-v").arg("-c").out_exe(&obj_file).input(src).run();

6
tests/run-make/c-link-to-rust-dylib/rmake.rs
View file

@ -3,12 +3,14 @@
//@ ignore-cross-compile
use run_make_support::{cc, cwd, dynamic_lib_extension, is_msvc, rfs, run, run_fail, rustc};
use run_make_support::{
cc, cwd, dynamic_lib_extension, is_windows_msvc, rfs, run, run_fail, rustc,
};
fn main() {
rustc().input("foo.rs").run();
if is_msvc() {
if is_windows_msvc() {
let lib = "foo.dll.lib";
cc().input("bar.c").arg(lib).out_exe("bar").run();

6
tests/run-make/c-unwind-abi-catch-lib-panic/rmake.rs
View file

@ -8,11 +8,11 @@
//@ needs-unwind
// Reason: this test exercises unwinding a panic
use run_make_support::{cc, is_msvc, llvm_ar, run, rustc, static_lib_name};
use run_make_support::{cc, is_windows_msvc, llvm_ar, run, rustc, static_lib_name};
fn main() {
// Compile `add.c` into an object file.
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe("add").input("add.c").run();
} else {
cc().arg("-v").arg("-c").out_exe("add.o").input("add.c").run();
@ -24,7 +24,7 @@ fn main() {
rustc().emit("obj").input("panic.rs").run();
// Now, create an archive using these two objects.
if is_msvc() {
if is_windows_msvc() {
llvm_ar().obj_to_ar().args(&[&static_lib_name("add"), "add.obj", "panic.o"]).run();
} else {
llvm_ar().obj_to_ar().args(&[&static_lib_name("add"), "add.o", "panic.o"]).run();

4
tests/run-make/cdylib-dylib-linkage/rmake.rs
View file

@ -9,7 +9,7 @@
use run_make_support::{
bin_name, cc, dynamic_lib_extension, dynamic_lib_name, filename_contains, has_extension,
has_prefix, has_suffix, is_msvc, msvc_import_dynamic_lib_name, path, run, rustc,
has_prefix, has_suffix, is_windows_msvc, msvc_import_dynamic_lib_name, path, run, rustc,
shallow_find_files, target,
};
@ -19,7 +19,7 @@ fn main() {
let sysroot = rustc().print("sysroot").run().stdout_utf8();
let sysroot = sysroot.trim();
let target_sysroot = path(sysroot).join("lib/rustlib").join(target()).join("lib");
if is_msvc() {
if is_windows_msvc() {
let mut libs = shallow_find_files(&target_sysroot, |path| {
has_prefix(path, "libstd-") && has_suffix(path, ".dll.lib")
});

4
tests/run-make/cdylib/rmake.rs
View file

@ -10,13 +10,13 @@
//@ ignore-cross-compile
use run_make_support::{cc, cwd, dynamic_lib_name, is_msvc, rfs, run, rustc};
use run_make_support::{cc, cwd, dynamic_lib_name, is_windows_msvc, rfs, run, rustc};
fn main() {
rustc().input("bar.rs").run();
rustc().input("foo.rs").run();
if is_msvc() {
if is_windows_msvc() {
cc().input("foo.c").arg("foo.dll.lib").out_exe("foo").run();
} else {
cc().input("foo.c").arg("-lfoo").library_search_path(cwd()).output("foo").run();

2
tests/run-make/compiler-rt-works-on-mingw/rmake.rs
View file

@ -5,7 +5,7 @@
//@ only-windows-gnu
use run_make_support::{cxx, is_msvc, llvm_ar, run, rustc, static_lib_name};
use run_make_support::{cxx, llvm_ar, run, rustc, static_lib_name};
fn main() {
cxx().input("foo.cpp").arg("-c").out_exe("foo.o").run();

4
tests/run-make/link-args-order/rmake.rs
View file

@ -6,10 +6,10 @@
// checks that linker arguments remain intact and in the order they were originally passed in.
// See https://github.com/rust-lang/rust/pull/70665
use run_make_support::{is_msvc, rustc};
use run_make_support::{is_windows_msvc, rustc};
fn main() {
let linker = if is_msvc() { "msvc" } else { "ld" };
let linker = if is_windows_msvc() { "msvc" } else { "ld" };
rustc()
.input("empty.rs")

4
tests/run-make/link-dedup/rmake.rs
View file

@ -9,7 +9,7 @@
use std::fmt::Write;
use run_make_support::{is_msvc, rustc, target};
use run_make_support::{is_windows_msvc, rustc, target};
fn main() {
rustc().input("depa.rs").run();
@ -32,7 +32,7 @@ fn main() {
fn needle_from_libs(libs: &[&str]) -> String {
let mut needle = String::new();
for lib in libs {
if is_msvc() {
if is_windows_msvc() {
needle.write_fmt(format_args!(r#""{lib}.lib" "#)).unwrap();
} else if target().contains("wasm") {
needle.write_fmt(format_args!(r#""-l" "{lib}" "#)).unwrap();

4
tests/run-make/native-link-modifier-bundle/rmake.rs
View file

@ -20,7 +20,7 @@
// Reason: cross-compilation fails to export native symbols
use run_make_support::{
build_native_static_lib, dynamic_lib_name, is_msvc, llvm_nm, rust_lib_name, rustc,
build_native_static_lib, dynamic_lib_name, is_windows_msvc, llvm_nm, rust_lib_name, rustc,
static_lib_name,
};
@ -60,7 +60,7 @@ fn main() {
.assert_stdout_contains_regex("U _*native_func");
// This part of the test does not function on Windows MSVC - no symbols are printed.
if !is_msvc() {
if !is_windows_msvc() {
// Build a cdylib, `native-staticlib` will not appear on the linker line because it was
// bundled previously. The cdylib will contain the `native_func` symbol in the end.
rustc()

6
tests/run-make/native-link-modifier-whole-archive/rmake.rs
View file

@ -10,11 +10,11 @@
// Reason: compiling C++ code does not work well when cross-compiling
// plus, the compiled binary is executed
use run_make_support::{cxx, is_msvc, llvm_ar, run, run_with_args, rustc, static_lib_name};
use run_make_support::{cxx, is_windows_msvc, llvm_ar, run, run_with_args, rustc, static_lib_name};
fn main() {
let mut cxx = cxx();
if is_msvc() {
if is_windows_msvc() {
cxx.arg("-EHs");
}
cxx.input("c_static_lib_with_constructor.cpp")
@ -24,7 +24,7 @@ fn main() {
let mut llvm_ar = llvm_ar();
llvm_ar.obj_to_ar();
if is_msvc() {
if is_windows_msvc() {
llvm_ar
.output_input(
static_lib_name("c_static_lib_with_constructor"),

6
tests/run-make/pointer-auth-link-with-c/rmake.rs
View file

@ -9,7 +9,7 @@
//@ ignore-cross-compile
// Reason: the compiled binary is executed
use run_make_support::{build_native_static_lib, cc, is_msvc, llvm_ar, run, rustc};
use run_make_support::{build_native_static_lib, cc, is_windows_msvc, llvm_ar, run, rustc};
fn main() {
build_native_static_lib("test");
@ -21,7 +21,7 @@ fn main() {
.input("test.c")
.arg("-mbranch-protection=bti+pac-ret+leaf")
.run();
let obj_file = if is_msvc() { "test.obj" } else { "test" };
let obj_file = if is_windows_msvc() { "test.obj" } else { "test" };
llvm_ar().obj_to_ar().output_input("libtest.a", &obj_file).run();
rustc().arg("-Zbranch-protection=bti,pac-ret,leaf").input("test.rs").run();
run("test");
@ -33,7 +33,7 @@ fn main() {
// .input("test.c")
// .arg("-mbranch-protection=bti+pac-ret+pc+leaf")
// .run();
// let obj_file = if is_msvc() { "test.obj" } else { "test" };
// let obj_file = if is_windows_msvc() { "test.obj" } else { "test" };
// llvm_ar().obj_to_ar().output_input("libtest.a", &obj_file).run();
// rustc().arg("-Zbranch-protection=bti,pac-ret,pc,leaf").input("test.rs").run();
// run("test");

6
tests/run-make/print-native-static-libs/rmake.rs
View file

@ -12,7 +12,7 @@
//@ ignore-cross-compile
//@ ignore-wasm
use run_make_support::{is_msvc, rustc};
use run_make_support::{is_windows_msvc, rustc};
fn main() {
// build supporting crate
@ -41,9 +41,9 @@ fn main() {
($lib:literal in $args:ident) => {{
let lib = format!(
"{}{}{}",
if !is_msvc() { "-l" } else { "" },
if !is_windows_msvc() { "-l" } else { "" },
$lib,
if !is_msvc() { "" } else { ".lib" },
if !is_windows_msvc() { "" } else { ".lib" },
);
let found = $args.contains(&&*lib);
assert!(found, "unable to find lib `{}` in those linker args: {:?}", lib, $args);

6
tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
View file

@ -9,7 +9,9 @@
//@ only-x86
//@ only-windows
use run_make_support::{build_native_dynamic_lib, diff, is_msvc, run, run_with_args, rustc};
use run_make_support::{
build_native_dynamic_lib, diff, is_windows_msvc, run, run_with_args, rustc,
};
fn main() {
rustc()
@ -21,7 +23,7 @@ fn main() {
build_native_dynamic_lib("extern");
let out = run("driver").stdout_utf8();
diff().expected_file("output.txt").actual_text("actual", out).normalize(r#"\r"#, "").run();
if is_msvc() {
if is_windows_msvc() {
let out_msvc = run_with_args("driver", &["true"]).stdout_utf8();
diff()
.expected_file("output.msvc.txt")

4
tests/run-make/raw-dylib-import-name-type/rmake.rs
View file

@ -11,14 +11,14 @@
//@ only-windows
// Reason: this test specifically exercises a 32bit Windows calling convention.
use run_make_support::{cc, diff, is_msvc, run, rustc};
use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
// NOTE: build_native_dynamic lib is not used, as the special `def` files
// must be passed to the CC compiler.
fn main() {
rustc().crate_type("bin").input("driver.rs").run();
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe("extern").input("extern.c").run();
cc().input("extern.obj")
.arg("extern.msvc.def")

4
tests/run-make/raw-dylib-inline-cross-dylib/rmake.rs
View file

@ -7,7 +7,7 @@
//@ only-windows
use run_make_support::{cc, diff, is_msvc, llvm_objdump, run, rustc};
use run_make_support::{cc, diff, is_windows_msvc, llvm_objdump, run, rustc};
fn main() {
rustc()
@ -31,7 +31,7 @@ fn main() {
.assert_stdout_not_contains("inline_library_function")
// Make sure we do find an import to the functions we expect to be imported.
.assert_stdout_contains("library_function");
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe("extern_1").input("extern_1.c").run();
cc().arg("-c").out_exe("extern_2").input("extern_2.c").run();
cc().input("extern_1.obj")

4
tests/run-make/raw-dylib-link-ordinal/rmake.rs
View file

@ -11,7 +11,7 @@
//@ only-windows
use run_make_support::{cc, diff, is_msvc, run, rustc};
use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
// NOTE: build_native_dynamic lib is not used, as the special `def` files
// must be passed to the CC compiler.
@ -19,7 +19,7 @@ use run_make_support::{cc, diff, is_msvc, run, rustc};
fn main() {
rustc().crate_type("lib").crate_name("raw_dylib_test").input("lib.rs").run();
rustc().crate_type("bin").input("driver.rs").run();
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe("exporter").input("exporter.c").run();
cc().input("exporter.obj")
.arg("exporter.def")

4
tests/run-make/raw-dylib-stdcall-ordinal/rmake.rs
View file

@ -10,7 +10,7 @@
//@ only-windows
// Reason: this test specifically exercises a 32bit Windows calling convention.
use run_make_support::{cc, diff, is_msvc, run, rustc};
use run_make_support::{cc, diff, is_windows_msvc, run, rustc};
// NOTE: build_native_dynamic lib is not used, as the special `def` files
// must be passed to the CC compiler.
@ -18,7 +18,7 @@ use run_make_support::{cc, diff, is_msvc, run, rustc};
fn main() {
rustc().crate_type("lib").crate_name("raw_dylib_test").input("lib.rs").run();
rustc().crate_type("bin").input("driver.rs").run();
if is_msvc() {
if is_windows_msvc() {
cc().arg("-c").out_exe("exporter").input("exporter.c").run();
cc().input("exporter.obj")
.arg("exporter-msvc.def")

6
tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
View file

@ -8,8 +8,8 @@
// Reason: cross-compilation fails to export native symbols
use run_make_support::{
bin_name, build_native_static_lib, cwd, filename_contains, is_msvc, llvm_ar, llvm_nm, rfs,
rust_lib_name, rustc, shallow_find_files,
bin_name, build_native_static_lib, cwd, filename_contains, is_windows_msvc, llvm_ar, llvm_nm,
rfs, rust_lib_name, rustc, shallow_find_files,
};
fn main() {
@ -74,7 +74,7 @@ fn main() {
.assert_stdout_contains_regex("native_dep_1.*native_dep_2.*native_dep_3");
// The binary "main" will not contain any symbols on MSVC.
if !is_msvc() {
if !is_windows_msvc() {
llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f1");
llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f2");
llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f3");

6
tests/run-make/split-debuginfo/rmake.rs
View file

@ -61,8 +61,8 @@ use std::collections::BTreeSet;
use run_make_support::rustc::Rustc;
use run_make_support::{
cwd, has_extension, is_darwin, is_msvc, is_windows, llvm_dwarfdump, run_in_tmpdir, rustc,
shallow_find_directories, shallow_find_files, uname,
cwd, has_extension, is_darwin, is_windows, is_windows_msvc, llvm_dwarfdump, run_in_tmpdir,
rustc, shallow_find_directories, shallow_find_files, uname,
};
/// `-C debuginfo`. See <https://doc.rust-lang.org/rustc/codegen-options/index.html#debuginfo>.
@ -1296,7 +1296,7 @@ fn main() {
// identify which combination isn't exercised with a 6-layers nested for loop iterating through
// each of the cli flag enum variants.
if is_msvc() {
if is_windows_msvc() {
// FIXME: the windows-msvc test coverage is sparse at best.
windows_msvc_tests::split_debuginfo(SplitDebuginfo::Off, DebuginfoLevel::Unspecified);

6
tests/run-make/static-dylib-by-default/rmake.rs
View file

@ -9,7 +9,7 @@
// Reason: the compiled binary is executed
use run_make_support::{
cc, cwd, dynamic_lib_name, extra_c_flags, has_extension, is_msvc, rfs, run, rustc,
cc, cwd, dynamic_lib_name, extra_c_flags, has_extension, is_windows_msvc, rfs, run, rustc,
shallow_find_files,
};
@ -22,13 +22,13 @@ fn main() {
// bar.dll.exp // export library for the dylib
// msvc's underlying link.exe requires the import library for the dynamic library as input.
// That is why the library is bar.dll.lib, not bar.dll.
let library = if is_msvc() { "bar.dll.lib" } else { &dynamic_lib_name("bar") };
let library = if is_windows_msvc() { "bar.dll.lib" } else { &dynamic_lib_name("bar") };
cc().input("main.c").out_exe("main").arg(library).args(extra_c_flags()).run();
for rlib in shallow_find_files(cwd(), |path| has_extension(path, "rlib")) {
rfs::remove_file(rlib);
}
rfs::remove_file(dynamic_lib_name("foo"));
if is_msvc() {
if is_windows_msvc() {
rfs::remove_file("foo.dll.lib");
}
run("main");

4
tests/run-make/staticlib-dylib-linkage/rmake.rs
View file

@ -9,7 +9,7 @@
//@ ignore-wasm
// Reason: WASM does not support dynamic libraries
use run_make_support::{cc, is_msvc, regex, run, rustc, static_lib_name};
use run_make_support::{cc, is_windows_msvc, regex, run, rustc, static_lib_name};
fn main() {
rustc().arg("-Cprefer-dynamic").input("bar.rs").run();
@ -27,7 +27,7 @@ fn main() {
let (_, native_link_args) = libs.split_once("note: native-static-libs: ").unwrap();
// divide the command-line arguments in a vec
let mut native_link_args = native_link_args.split(' ').collect::<Vec<&str>>();
if is_msvc() {
if is_windows_msvc() {
// For MSVC pass the arguments on to the linker.
native_link_args.insert(0, "-link");
}

6
tests/run-make/symbol-visibility/rmake.rs
View file

@ -9,7 +9,7 @@
// See https://github.com/rust-lang/rust/issues/37530
use run_make_support::object::read::Object;
use run_make_support::{bin_name, dynamic_lib_name, is_msvc, object, regex, rfs, rustc};
use run_make_support::{bin_name, dynamic_lib_name, is_windows_msvc, object, regex, rfs, rustc};
fn main() {
let cdylib_name = dynamic_lib_name("a_cdylib");
@ -64,7 +64,7 @@ fn main() {
);
// FIXME(nbdd0121): This is broken in MinGW, see https://github.com/rust-lang/rust/pull/95604#issuecomment-1101564032
if is_msvc() {
if is_windows_msvc() {
// Check that an executable does not export any dynamic symbols
symbols_check(&exe_name, SymbolCheckType::StrSymbol("public_c_function_from_rlib"), false);
symbols_check(
@ -130,7 +130,7 @@ fn main() {
);
// FIXME(nbdd0121): This is broken in MinGW, see https://github.com/rust-lang/rust/pull/95604#issuecomment-1101564032
if is_msvc() {
if is_windows_msvc() {
// Check that an executable does not export any dynamic symbols
symbols_check(&exe_name, SymbolCheckType::StrSymbol("public_c_function_from_rlib"), false);
symbols_check(