dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #114666 - bjorn3:sync_cg_clif-2023-08-09, r=bjorn3 

Sync rustc_codegen_cranelift

A couple of small bug fixes this time. In addition I fixed the test suite after the introduction of `#![deny(internal_feature)]` broke it.

r? `@ghost`

`@rustbot` label +A-codegen +A-cranelift +T-compiler
This commit is contained in:
bors 2023-08-09 20:51:34 +00:00
parent 27a43f0834 37751893cc
commit 08d00b40ae
20 changed files with 194 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
compiler/rustc_codegen_cranelift/.github/workflows/audit.yml vendored Normal file
View File

@ -0,0 +1,19 @@
name: Security audit
on:
workflow_dispatch:
schedule:
- cron: '0 10 * * 1' # every monday at 10:00 UTC
permissions:
issues: write
checks: write
jobs:
audit:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- run: |
sed -i 's/components.*/components = []/' rust-toolchain
echo 'profile = "minimal"' >> rust-toolchain
- uses: rustsec/audit-check@v1.4.1
with:
token: ${{ secrets.GITHUB_TOKEN }}

10
compiler/rustc_codegen_cranelift/build_system/abi_cafe.rs
View File

@ -1,8 +1,8 @@
use super::build_sysroot;
use super::path::Dirs;
use super::prepare::GitRepo;
use super::utils::{spawn_and_wait, CargoProject, Compiler};
use super::{CodegenBackend, SysrootKind};
use crate::build_sysroot;
use crate::path::Dirs;
use crate::prepare::GitRepo;
use crate::utils::{spawn_and_wait, CargoProject, Compiler};
use crate::{CodegenBackend, SysrootKind};
static ABI_CAFE_REPO: GitRepo = GitRepo::github(
"Gankra",

8
compiler/rustc_codegen_cranelift/build_system/bench.rs
View File

@ -2,10 +2,10 @@ use std::env;
use std::io::Write;
use std::path::Path;
use super::path::{Dirs, RelPath};
use super::prepare::GitRepo;
use super::rustc_info::get_file_name;
use super::utils::{hyperfine_command, spawn_and_wait, Compiler};
use crate::path::{Dirs, RelPath};
use crate::prepare::GitRepo;
use crate::rustc_info::get_file_name;
use crate::utils::{hyperfine_command, spawn_and_wait, Compiler};
static SIMPLE_RAYTRACER_REPO: GitRepo = GitRepo::github(
"ebobby",

16
compiler/rustc_codegen_cranelift/build_system/build_backend.rs
View File

@ -1,9 +1,9 @@
use std::env;
use std::path::PathBuf;
use super::path::{Dirs, RelPath};
use super::rustc_info::get_file_name;
use super::utils::{is_ci, is_ci_opt, maybe_incremental, CargoProject, Compiler, LogGroup};
use crate::path::{Dirs, RelPath};
use crate::rustc_info::get_file_name;
use crate::shared_utils::{rustflags_from_env, rustflags_to_cmd_env};
use crate::utils::{is_ci, is_ci_opt, maybe_incremental, CargoProject, Compiler, LogGroup};
pub(crate) static CG_CLIF: CargoProject = CargoProject::new(&RelPath::SOURCE, "cg_clif");
@ -18,11 +18,11 @@ pub(crate) fn build_backend(
let mut cmd = CG_CLIF.build(&bootstrap_host_compiler, dirs);
maybe_incremental(&mut cmd);
let mut rustflags = env::var("RUSTFLAGS").unwrap_or_default();
let mut rustflags = rustflags_from_env("RUSTFLAGS");
if is_ci() {
// Deny warnings on CI
rustflags += " -Dwarnings";
rustflags.push("-Dwarnings".to_owned());
if !is_ci_opt() {
cmd.env("CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS", "true");
@ -42,10 +42,10 @@ pub(crate) fn build_backend(
_ => unreachable!(),
}
cmd.env("RUSTFLAGS", rustflags);
rustflags_to_cmd_env(&mut cmd, "RUSTFLAGS", &rustflags);
eprintln!("[BUILD] rustc_codegen_cranelift");
super::utils::spawn_and_wait(cmd);
crate::utils::spawn_and_wait(cmd);
CG_CLIF
.target_dir(dirs)

35
compiler/rustc_codegen_cranelift/build_system/build_sysroot.rs
View File

@ -2,13 +2,13 @@ use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use super::path::{Dirs, RelPath};
use super::rustc_info::get_file_name;
use super::utils::{
use crate::path::{Dirs, RelPath};
use crate::rustc_info::get_file_name;
use crate::utils::{
maybe_incremental, remove_dir_if_exists, spawn_and_wait, try_hard_link, CargoProject, Compiler,
LogGroup,
};
use super::{CodegenBackend, SysrootKind};
use crate::{config, CodegenBackend, SysrootKind};
static DIST_DIR: RelPath = RelPath::DIST;
static BIN_DIR: RelPath = RelPath::DIST.join("bin");
@ -128,8 +128,8 @@ pub(crate) fn build_sysroot(
cargo: bootstrap_host_compiler.cargo.clone(),
rustc: rustc_clif.clone(),
rustdoc: rustdoc_clif.clone(),
rustflags: String::new(),
rustdocflags: String::new(),
rustflags: vec![],
rustdocflags: vec![],
triple: target_triple,
runner: vec![],
}
@ -185,7 +185,7 @@ fn build_sysroot_for_triple(
#[must_use]
fn build_llvm_sysroot_for_triple(compiler: Compiler) -> SysrootTarget {
let default_sysroot = super::rustc_info::get_default_sysroot(&compiler.rustc);
let default_sysroot = crate::rustc_info::get_default_sysroot(&compiler.rustc);
let mut target_libs = SysrootTarget { triple: compiler.triple, libs: vec![] };
@ -234,32 +234,32 @@ fn build_clif_sysroot_for_triple(
let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(&compiler.triple).join(channel);
if !super::config::get_bool("keep_sysroot") {
if !config::get_bool("keep_sysroot") {
// Cleanup the deps dir, but keep build scripts and the incremental cache for faster
// recompilation as they are not affected by changes in cg_clif.
remove_dir_if_exists(&build_dir.join("deps"));
}
// Build sysroot
let mut rustflags = " -Zforce-unstable-if-unmarked -Cpanic=abort".to_string();
let mut rustflags = vec!["-Zforce-unstable-if-unmarked".to_owned(), "-Cpanic=abort".to_owned()];
match cg_clif_dylib_path {
CodegenBackend::Local(path) => {
rustflags.push_str(&format!(" -Zcodegen-backend={}", path.to_str().unwrap()));
rustflags.push(format!("-Zcodegen-backend={}", path.to_str().unwrap()));
}
CodegenBackend::Builtin(name) => {
rustflags.push_str(&format!(" -Zcodegen-backend={name}"));
rustflags.push(format!("-Zcodegen-backend={name}"));
}
};
// Necessary for MinGW to find rsbegin.o and rsend.o
rustflags
.push_str(&format!(" --sysroot {}", RTSTARTUP_SYSROOT.to_path(dirs).to_str().unwrap()));
rustflags.push("--sysroot".to_owned());
rustflags.push(RTSTARTUP_SYSROOT.to_path(dirs).to_str().unwrap().to_owned());
if channel == "release" {
// Incremental compilation by default disables mir inlining. This leads to both a decent
// compile perf and a significant runtime perf regression. As such forcefully enable mir
// inlining.
rustflags.push_str(" -Zinline-mir");
rustflags.push("-Zinline-mir".to_owned());
}
compiler.rustflags += &rustflags;
compiler.rustflags.extend(rustflags);
let mut build_cmd = STANDARD_LIBRARY.build(&compiler, dirs);
maybe_incremental(&mut build_cmd);
if channel == "release" {
@ -289,8 +289,8 @@ fn build_clif_sysroot_for_triple(
}
fn build_rtstartup(dirs: &Dirs, compiler: &Compiler) -> Option<SysrootTarget> {
if !super::config::get_bool("keep_sysroot") {
super::prepare::prepare_stdlib(dirs, &compiler.rustc);
if !config::get_bool("keep_sysroot") {
crate::prepare::prepare_stdlib(dirs, &compiler.rustc);
}
if !compiler.triple.ends_with("windows-gnu") {
@ -306,6 +306,7 @@ fn build_rtstartup(dirs: &Dirs, compiler: &Compiler) -> Option<SysrootTarget> {
let obj = RTSTARTUP_SYSROOT.to_path(dirs).join(format!("{file}.o"));
let mut build_rtstartup_cmd = Command::new(&compiler.rustc);
build_rtstartup_cmd
.arg("-Ainternal_features") // Missing #[allow(internal_features)]
.arg("--target")
.arg(&compiler.triple)
.arg("--emit=obj")

5
compiler/rustc_codegen_cranelift/build_system/main.rs
View File

@ -16,6 +16,7 @@ mod config;
mod path;
mod prepare;
mod rustc_info;
mod shared_utils;
mod tests;
mod utils;
@ -169,8 +170,8 @@ fn main() {
cargo,
rustc,
rustdoc,
rustflags: String::new(),
rustdocflags: String::new(),
rustflags: vec![],
rustdocflags: vec![],
triple,
runner: vec![],
}

2
compiler/rustc_codegen_cranelift/build_system/path.rs
View File

@ -1,7 +1,7 @@
use std::fs;
use std::path::PathBuf;
use super::utils::remove_dir_if_exists;
use crate::utils::remove_dir_if_exists;
#[derive(Debug, Clone)]
pub(crate) struct Dirs {

14
compiler/rustc_codegen_cranelift/build_system/prepare.rs
View File

@ -3,18 +3,18 @@ use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use super::build_sysroot::STDLIB_SRC;
use super::path::{Dirs, RelPath};
use super::rustc_info::get_default_sysroot;
use super::utils::{
use crate::build_sysroot::STDLIB_SRC;
use crate::path::{Dirs, RelPath};
use crate::rustc_info::get_default_sysroot;
use crate::utils::{
copy_dir_recursively, git_command, remove_dir_if_exists, retry_spawn_and_wait, spawn_and_wait,
};
pub(crate) fn prepare(dirs: &Dirs) {
RelPath::DOWNLOAD.ensure_exists(dirs);
super::tests::RAND_REPO.fetch(dirs);
super::tests::REGEX_REPO.fetch(dirs);
super::tests::PORTABLE_SIMD_REPO.fetch(dirs);
crate::tests::RAND_REPO.fetch(dirs);
crate::tests::REGEX_REPO.fetch(dirs);
crate::tests::PORTABLE_SIMD_REPO.fetch(dirs);
}
pub(crate) fn prepare_stdlib(dirs: &Dirs, rustc: &Path) {

26
compiler/rustc_codegen_cranelift/build_system/shared_utils.rs Normal file
View File

@ -0,0 +1,26 @@
// This file is used by both the build system as well as cargo-clif.rs
// Adapted from https://github.com/rust-lang/cargo/blob/6dc1deaddf62c7748c9097c7ea88e9ec77ff1a1a/src/cargo/core/compiler/build_context/target_info.rs#L750-L77
pub(crate) fn rustflags_from_env(kind: &str) -> Vec<String> {
// First try CARGO_ENCODED_RUSTFLAGS from the environment.
// Prefer this over RUSTFLAGS since it's less prone to encoding errors.
if let Ok(a) = std::env::var(format!("CARGO_ENCODED_{}", kind)) {
if a.is_empty() {
return Vec::new();
}
return a.split('\x1f').map(str::to_string).collect();
}
// Then try RUSTFLAGS from the environment
if let Ok(a) = std::env::var(kind) {
let args = a.split(' ').map(str::trim).filter(|s| !s.is_empty()).map(str::to_string);
return args.collect();
}
// No rustflags to be collected from the environment
Vec::new()
}
pub(crate) fn rustflags_to_cmd_env(cmd: &mut std::process::Command, kind: &str, flags: &[String]) {
cmd.env(format!("CARGO_ENCODED_{}", kind), flags.join("\x1f"));
}

36
compiler/rustc_codegen_cranelift/build_system/tests.rs
View File

@ -1,16 +1,17 @@
use super::build_sysroot;
use super::config;
use super::path::{Dirs, RelPath};
use super::prepare::{apply_patches, GitRepo};
use super::rustc_info::get_default_sysroot;
use super::utils::{spawn_and_wait, spawn_and_wait_with_input, CargoProject, Compiler, LogGroup};
use super::{CodegenBackend, SysrootKind};
use std::env;
use std::ffi::OsStr;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
use crate::build_sysroot;
use crate::config;
use crate::path::{Dirs, RelPath};
use crate::prepare::{apply_patches, GitRepo};
use crate::rustc_info::get_default_sysroot;
use crate::shared_utils::rustflags_from_env;
use crate::utils::{spawn_and_wait, spawn_and_wait_with_input, CargoProject, Compiler, LogGroup};
use crate::{CodegenBackend, SysrootKind};
static BUILD_EXAMPLE_OUT_DIR: RelPath = RelPath::BUILD.join("example");
struct TestCase {
@ -306,7 +307,7 @@ pub(crate) fn run_tests(
);
// Rust's build system denies a couple of lints that trigger on several of the test
// projects. Changing the code to fix them is not worth it, so just silence all lints.
target_compiler.rustflags += " --cap-lints=allow";
target_compiler.rustflags.push("--cap-lints=allow".to_owned());
let runner = TestRunner::new(
dirs.clone(),
@ -350,18 +351,15 @@ impl<'a> TestRunner<'a> {
is_native: bool,
stdlib_source: PathBuf,
) -> Self {
if let Ok(rustflags) = env::var("RUSTFLAGS") {
target_compiler.rustflags.push(' ');
target_compiler.rustflags.push_str(&rustflags);
}
if let Ok(rustdocflags) = env::var("RUSTDOCFLAGS") {
target_compiler.rustdocflags.push(' ');
target_compiler.rustdocflags.push_str(&rustdocflags);
}
target_compiler.rustflags.extend(rustflags_from_env("RUSTFLAGS"));
target_compiler.rustdocflags.extend(rustflags_from_env("RUSTDOCFLAGS"));
// FIXME fix `#[linkage = "extern_weak"]` without this
if target_compiler.triple.contains("darwin") {
target_compiler.rustflags.push_str(" -Clink-arg=-undefined -Clink-arg=dynamic_lookup");
target_compiler.rustflags.extend([
"-Clink-arg=-undefined".to_owned(),
"-Clink-arg=dynamic_lookup".to_owned(),
]);
}
let jit_supported = use_unstable_features
@ -470,7 +468,7 @@ impl<'a> TestRunner<'a> {
S: AsRef<OsStr>,
{
let mut cmd = Command::new(&self.target_compiler.rustc);
cmd.args(self.target_compiler.rustflags.split_whitespace());
cmd.args(&self.target_compiler.rustflags);
cmd.arg("-L");
cmd.arg(format!("crate={}", BUILD_EXAMPLE_OUT_DIR.to_path(&self.dirs).display()));
cmd.arg("--out-dir");

2
compiler/rustc_codegen_cranelift/build_system/usage.txt
View File

@ -43,7 +43,7 @@ REQUIREMENTS:
* Rustup: By default rustup is used to install the right nightly version. If you don't want to
use rustup, you can manually install the nightly version indicated by rust-toolchain.toml and
point the CARGO, RUSTC and RUSTDOC env vars to the right executables.
* Git: `./y.sh prepare` uses git for applying patches and on Windows for downloading test repos.
* Git: Git is used for applying patches and on Windows for downloading test repos.
* Curl and tar (non-Windows only): Used by `./y.sh prepare` to download a single commit for
repos. Git will be used to clone the whole repo when using Windows.
* [Hyperfine](https://github.com/sharkdp/hyperfine/): Used for benchmarking with `./y.sh bench`.

19
compiler/rustc_codegen_cranelift/build_system/utils.rs
View File

@ -5,15 +5,16 @@ use std::path::{Path, PathBuf};
use std::process::{self, Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use super::path::{Dirs, RelPath};
use crate::path::{Dirs, RelPath};
use crate::shared_utils::rustflags_to_cmd_env;
#[derive(Clone, Debug)]
pub(crate) struct Compiler {
pub(crate) cargo: PathBuf,
pub(crate) rustc: PathBuf,
pub(crate) rustdoc: PathBuf,
pub(crate) rustflags: String,
pub(crate) rustdocflags: String,
pub(crate) rustflags: Vec<String>,
pub(crate) rustdocflags: Vec<String>,
pub(crate) triple: String,
pub(crate) runner: Vec<String>,
}
@ -23,8 +24,8 @@ impl Compiler {
match self.triple.as_str() {
"aarch64-unknown-linux-gnu" => {
// We are cross-compiling for aarch64. Use the correct linker and run tests in qemu.
self.rustflags += " -Clinker=aarch64-linux-gnu-gcc";
self.rustdocflags += " -Clinker=aarch64-linux-gnu-gcc";
self.rustflags.push("-Clinker=aarch64-linux-gnu-gcc".to_owned());
self.rustdocflags.push("-Clinker=aarch64-linux-gnu-gcc".to_owned());
self.runner = vec![
"qemu-aarch64".to_owned(),
"-L".to_owned(),
@ -33,8 +34,8 @@ impl Compiler {
}
"s390x-unknown-linux-gnu" => {
// We are cross-compiling for s390x. Use the correct linker and run tests in qemu.
self.rustflags += " -Clinker=s390x-linux-gnu-gcc";
self.rustdocflags += " -Clinker=s390x-linux-gnu-gcc";
self.rustflags.push("-Clinker=s390x-linux-gnu-gcc".to_owned());
self.rustdocflags.push("-Clinker=s390x-linux-gnu-gcc".to_owned());
self.runner = vec![
"qemu-s390x".to_owned(),
"-L".to_owned(),
@ -100,8 +101,8 @@ impl CargoProject {
cmd.env("RUSTC", &compiler.rustc);
cmd.env("RUSTDOC", &compiler.rustdoc);
cmd.env("RUSTFLAGS", &compiler.rustflags);
cmd.env("RUSTDOCFLAGS", &compiler.rustdocflags);
rustflags_to_cmd_env(&mut cmd, "RUSTFLAGS", &compiler.rustflags);
rustflags_to_cmd_env(&mut cmd, "RUSTDOCFLAGS", &compiler.rustdocflags);
if !compiler.runner.is_empty() {
cmd.env(
format!("CARGO_TARGET_{}_RUNNER", compiler.triple.to_uppercase().replace('-', "_")),

2
compiler/rustc_codegen_cranelift/example/mini_core.rs
View File

@ -11,7 +11,7 @@
thread_local
)]
#![no_core]
#![allow(dead_code)]
#![allow(dead_code, internal_features)]
#[lang = "sized"]
pub trait Sized {}

2
compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
View File

@ -1,6 +1,6 @@
#![feature(no_core, lang_items, never_type, linkage, extern_types, thread_local, repr_simd)]
#![no_core]
#![allow(dead_code, non_camel_case_types)]
#![allow(dead_code, non_camel_case_types, internal_features)]
extern crate mini_core;

24
compiler/rustc_codegen_cranelift/patches/0001-portable-simd-Allow-internal-features.patch Normal file
View File

@ -0,0 +1,24 @@
From fcf75306d88e533b83eaff3f8d0ab9f307e8a84d Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 9 Aug 2023 10:01:17 +0000
Subject: [PATCH] Allow internal features
---
crates/core_simd/src/lib.rs | 1 +
1 file changed, 1 insertion(+)
diff --git a/crates/core_simd/src/lib.rs b/crates/core_simd/src/lib.rs
index fde406b..b386116 100644
--- a/crates/core_simd/src/lib.rs
+++ b/crates/core_simd/src/lib.rs
@@ -19,6 +19,7 @@
#![warn(missing_docs, clippy::missing_inline_in_public_items)] // basically all items, really
#![deny(unsafe_op_in_unsafe_fn, clippy::undocumented_unsafe_blocks)]
#![unstable(feature = "portable_simd", issue = "86656")]
+#![allow(internal_features)]
//! Portable SIMD module.
#[path = "mod.rs"]
--
2.34.1

4
compiler/rustc_codegen_cranelift/patches/stdlib-lock.toml
View File

@ -74,9 +74,9 @@ dependencies = [
[[package]]
name = "compiler_builtins"
version = "0.1.95"
version = "0.1.100"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6866e0f3638013234db3c89ead7a14d278354338e7237257407500009012b23f"
checksum = "d6c0f24437059853f0fa64afc51f338f93647a3de4cf3358ba1bb4171a199775"
dependencies = [
"cc",
"rustc-std-workspace-core",

2
compiler/rustc_codegen_cranelift/rust-toolchain
View File

@ -1,3 +1,3 @@
[toolchain]
channel = "nightly-2023-07-22"
channel = "nightly-2023-08-08"
components = ["rust-src", "rustc-dev", "llvm-tools"]

63
compiler/rustc_codegen_cranelift/scripts/cargo-clif.rs
View File

@ -3,6 +3,8 @@ use std::env;
use std::os::unix::process::CommandExt;
use std::process::Command;
include!("../build_system/shared_utils.rs");
fn main() {
let current_exe = env::current_exe().unwrap();
let mut sysroot = current_exe.parent().unwrap();
@ -10,27 +12,19 @@ fn main() {
sysroot = sysroot.parent().unwrap();
}
let mut rustflags = String::new();
rustflags.push_str(" -Cpanic=abort -Zpanic-abort-tests -Zcodegen-backend=");
let mut rustflags = vec!["-Cpanic=abort".to_owned(), "-Zpanic-abort-tests".to_owned()];
if let Some(name) = option_env!("BUILTIN_BACKEND") {
rustflags.push_str(name);
rustflags.push(format!("-Zcodegen-backend={name}"));
} else {
rustflags.push_str(
sysroot
.join(if cfg!(windows) { "bin" } else { "lib" })
.join(
env::consts::DLL_PREFIX.to_string()
+ "rustc_codegen_cranelift"
+ env::consts::DLL_SUFFIX,
)
.to_str()
.unwrap(),
let dylib = sysroot.join(if cfg!(windows) { "bin" } else { "lib" }).join(
env::consts::DLL_PREFIX.to_string()
+ "rustc_codegen_cranelift"
+ env::consts::DLL_SUFFIX,
);
rustflags.push(format!("-Zcodegen-backend={}", dylib.to_str().unwrap()));
}
rustflags.push_str(" --sysroot ");
rustflags.push_str(sysroot.to_str().unwrap());
env::set_var("RUSTFLAGS", env::var("RUSTFLAGS").unwrap_or(String::new()) + &rustflags);
env::set_var("RUSTDOCFLAGS", env::var("RUSTDOCFLAGS").unwrap_or(String::new()) + &rustflags);
rustflags.push("--sysroot".to_owned());
rustflags.push(sysroot.to_str().unwrap().to_owned());
let cargo = if let Some(cargo) = option_env!("CARGO") {
cargo
@ -49,10 +43,7 @@ fn main() {
let args: Vec<_> = match args.get(0).map(|arg| &**arg) {
Some("jit") => {
env::set_var(
"RUSTFLAGS",
env::var("RUSTFLAGS").unwrap_or(String::new()) + " -Cprefer-dynamic",
);
rustflags.push("-Cprefer-dynamic".to_owned());
args.remove(0);
IntoIterator::into_iter(["rustc".to_string()])
.chain(args)
@ -64,10 +55,7 @@ fn main() {
.collect()
}
Some("lazy-jit") => {
env::set_var(
"RUSTFLAGS",
env::var("RUSTFLAGS").unwrap_or(String::new()) + " -Cprefer-dynamic",
);
rustflags.push("-Cprefer-dynamic".to_owned());
args.remove(0);
IntoIterator::into_iter(["rustc".to_string()])
.chain(args)
@ -81,11 +69,28 @@ fn main() {
_ => args,
};
let mut cmd = Command::new(cargo);
cmd.args(args);
rustflags_to_cmd_env(
&mut cmd,
"RUSTFLAGS",
&rustflags_from_env("RUSTFLAGS")
.into_iter()
.chain(rustflags.iter().map(|flag| flag.clone()))
.collect::<Vec<_>>(),
);
rustflags_to_cmd_env(
&mut cmd,
"RUSTDOCFLAGS",
&rustflags_from_env("RUSTDOCFLAGS")
.into_iter()
.chain(rustflags.iter().map(|flag| flag.clone()))
.collect::<Vec<_>>(),
);
#[cfg(unix)]
panic!("Failed to spawn cargo: {}", Command::new(cargo).args(args).exec());
panic!("Failed to spawn cargo: {}", cmd.exec());
#[cfg(not(unix))]
std::process::exit(
Command::new(cargo).args(args).spawn().unwrap().wait().unwrap().code().unwrap_or(1),
);
std::process::exit(cmd.spawn().unwrap().wait().unwrap().code().unwrap_or(1));
}

8
compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh
View File

@ -49,6 +49,8 @@ rm tests/ui/proc-macro/allowed-signatures.rs
# vendor intrinsics
rm tests/ui/sse2.rs # cpuid not supported, so sse2 not detected
rm tests/ui/simd/array-type.rs # "Index argument for `simd_insert` is not a constant"
rm tests/ui/simd/intrinsic/generic-bswap-byte.rs # simd_bswap not yet implemented
rm tests/ui/simd/intrinsic/generic-arithmetic-pass.rs # many missing simd intrinsics
# exotic linkages
rm tests/ui/issues/issue-33992.rs # unsupported linkages
@ -124,6 +126,8 @@ rm tests/ui/typeck/issue-46112.rs # same
rm tests/ui/consts/const_cmp_type_id.rs # same
rm tests/ui/consts/issue-73976-monomorphic.rs # same
rm tests/ui/rfcs/rfc-3348-c-string-literals/non-ascii.rs # same
rm tests/ui/consts/const-eval/nonnull_as_ref_ub.rs # same
rm tests/ui/consts/issue-94675.rs # same
# rustdoc-clif passes extra args, suppressing the help message when no args are passed
rm -r tests/run-make/issue-88756-default-output
@ -158,8 +162,6 @@ rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
rm tests/ui/stdio-is-blocking.rs # really slow with unoptimized libstd
rm tests/ui/panic-handler/weak-lang-item-2.rs # Will be fixed by #113568
cp ../dist/bin/rustdoc-clif ../dist/bin/rustdoc # some tests expect bin/rustdoc to exist
# prevent $(RUSTDOC) from picking up the sysroot built by x.py. It conflicts with the one used by
@ -172,7 +174,7 @@ index ea06b620c4c..b969d0009c6 100644
@@ -9,7 +9,7 @@ RUSTC_ORIGINAL := \$(RUSTC)
BARE_RUSTC := \$(HOST_RPATH_ENV) '\$(RUSTC)'
BARE_RUSTDOC := \$(HOST_RPATH_ENV) '\$(RUSTDOC)'
RUSTC := \$(BARE_RUSTC) --out-dir \$(TMPDIR) -L \$(TMPDIR) \$(RUSTFLAGS)
RUSTC := \$(BARE_RUSTC) --out-dir \$(TMPDIR) -L \$(TMPDIR) \$(RUSTFLAGS) -Ainternal_features
-RUSTDOC := \$(BARE_RUSTDOC) -L \$(TARGET_RPATH_DIR)
+RUSTDOC := \$(BARE_RUSTDOC)
ifdef RUSTC_LINKER

7
compiler/rustc_codegen_cranelift/src/lib.rs
View File

@ -260,6 +260,13 @@ fn build_isa(sess: &Session, backend_config: &BackendConfig) -> Arc<dyn isa::Tar
flags_builder.set("enable_verifier", enable_verifier).unwrap();
flags_builder.set("regalloc_checker", enable_verifier).unwrap();
let preserve_frame_pointer = sess.target.options.frame_pointer
!= rustc_target::spec::FramePointer::MayOmit
|| matches!(sess.opts.cg.force_frame_pointers, Some(true));
if preserve_frame_pointer {
flags_builder.set("preserve_frame_pointers", "true").unwrap();
}
let tls_model = match target_triple.binary_format {
BinaryFormat::Elf => "elf_gd",
BinaryFormat::Macho => "macho",