Merge commit '6d35b4c9a04580366fd800692a5b5db79d766530' into sync_cg_clif-2024-09-22

compiler/rustc_codegen_cranelift/.cirrus.yml

@@ -3,7 +3,7 @@ task:
   freebsd_instance:
     image: freebsd-13-2-release-amd64
   setup_rust_script:
-    - pkg install -y git bash binutils
+    - pkg install -y git-tiny binutils
     - curl https://sh.rustup.rs -sSf --output rustup.sh
     - sh rustup.sh --default-toolchain none -y --profile=minimal
   target_cache:

compiler/rustc_codegen_cranelift/.github/workflows/main.yml

@@ -279,8 +279,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 10
     if: ${{ github.ref == 'refs/heads/master' }}
-    # FIXME add the bench job back to the dependency list once rust-lang/rust#125493 gets merged
+    needs: [rustfmt, test, bench, dist]
-    needs: [rustfmt, test, dist]
 
     permissions:
       contents: write # for creating the dev tag and release

compiler/rustc_codegen_cranelift/Cargo.lock

@@ -46,24 +46,24 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "effa84ab2023f7138045ece6b326588c17447ca22e66db71ec15cb0a6c0c4ad2"
+checksum = "b80c3a50b9c4c7e5b5f73c0ed746687774fc9e36ef652b110da8daebf0c6e0e6"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38a1dfc50dca188a15d938867c4400589530bcb0138f7022aae6d059d1d8c309"
+checksum = "38778758c2ca918b05acb2199134e0c561fb577c50574259b26190b6c2d95ded"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "821c20c639350158ecca928dc2a244d0d1c9cef2377a378fc62a445a286eb1ca"
+checksum = "58258667ad10e468bfc13a8d620f50dfcd4bb35d668123e97defa2549b9ad397"
 dependencies = [
  "bumpalo",
  "cranelift-bforest",
@@ -84,42 +84,42 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "064473f2fd59b44fa2c9aaa60de1f9c44db5e13521e28bc85d2b92ee535ef625"
+checksum = "043f0b702e529dcb07ff92bd7d40e7d5317b5493595172c5eb0983343751ee06"
 dependencies = [
  "cranelift-codegen-shared",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f39b9ebfd2febdc2acfb9a0fca110665bcd5a6839502576307735ed07b2177"
+checksum = "7763578888ab53eca5ce7da141953f828e82c2bfadcffc106d10d1866094ffbb"
 
 [[package]]
 name = "cranelift-control"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94e125c189c3a1ca8dfe209fc6f46edba058a6d24e0b92aff69459a15f4711e7"
+checksum = "32db15f08c05df570f11e8ab33cb1ec449a64b37c8a3498377b77650bef33d8b"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea62eb109baec2247e1a6fa7b74c0f584b1e76e289cfd7017385b4b031fc8450"
+checksum = "5289cdb399381a27e7bbfa1b42185916007c3d49aeef70b1d01cb4caa8010130"
 dependencies = [
  "cranelift-bitset",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "722b089357aacb6c7528b2e59a5fe00917d61ce63448b25a3e477a5b7819fac8"
+checksum = "31ba8ab24eb9470477e98ddfa3c799a649ac5a0d9a2042868c4c952133c234e8"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -129,15 +129,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4b5005a48288e7fc2a2991a377831c534e26929b063c379c018060727785a9b"
+checksum = "2b72a3c5c166a70426dcb209bdd0bb71a787c1ea76023dc0974fbabca770e8f9"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f843932baf8d1025c5f114b929eda172d74b7163d058e0de2597c308b567c7e9"
+checksum = "df32578a47582e49b4fc1f9a5786839d9be1fedaa9f00bea7612c54425663c6b"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -155,9 +155,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "449819ef1c4af139cf1b9717916fcaea0e23248853d3e95135139773a842d3eb"
+checksum = "96094a758cdb543c9143f70817cd31069fecd49f50981a0fac06820ac011dc2f"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -166,9 +166,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae2d48f38081a9e679ad795bd36bb29bedeb5552fc1c195185bf9885fa1b16e"
+checksum = "46a42424c956bbc31fc5c2706073df896156c5420ae8fa2a5d48dbc7b295d71b"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -177,9 +177,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-object"
-version = "0.110.1"
+version = "0.111.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a39ee2cfd0ec485eca76f6b4dc17701a280fa406bc05137bb43f1635ed12c9f"
+checksum = "1cf5e2484ab47fe38a3150747cdd2016535f13542a925acca152b63383a6591b"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -213,9 +213,9 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "gimli"
-version = "0.28.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 dependencies = [
  "fallible-iterator",
  "indexmap",
@@ -403,9 +403,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "unicode-ident"
@@ -421,9 +421,9 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "wasmtime-jit-icache-coherence"
-version = "23.0.1"
+version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fddf3e2980fb1d123d1fcac55189e417fdd3dba4f62139b5a0a1f9efe5669d5"
+checksum = "d15de8429db996f0d17a4163a35eccc3f874cbfb50f29c379951ea1bbb39452e"
 dependencies = [
  "anyhow",
  "cfg-if",

compiler/rustc_codegen_cranelift/Cargo.toml

@@ -8,14 +8,14 @@ crate-type = ["dylib"]
 
 [dependencies]
 # These have to be in sync with each other
-cranelift-codegen = { version = "0.110.1", default-features = false, features = ["std", "unwind", "all-arch"] }
+cranelift-codegen = { version = "0.111.0", default-features = false, features = ["std", "unwind", "all-arch"] }
-cranelift-frontend = { version = "0.110.1" }
+cranelift-frontend = { version = "0.111.0" }
-cranelift-module = { version = "0.110.1" }
+cranelift-module = { version = "0.111.0" }
-cranelift-native = { version = "0.110.1" }
+cranelift-native = { version = "0.111.0" }
-cranelift-jit = { version = "0.110.1", optional = true }
+cranelift-jit = { version = "0.111.0", optional = true }
-cranelift-object = { version = "0.110.1" }
+cranelift-object = { version = "0.111.0" }
 target-lexicon = "0.12.0"
-gimli = { version = "0.28", default-features = false, features = ["write"]}
+gimli = { version = "0.29", default-features = false, features = ["write"] }
 object = { version = "0.36", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
 
 indexmap = "2.0.0"

compiler/rustc_codegen_cranelift/build_system/abi_cafe.rs

@@ -14,7 +14,6 @@
 static ABI_CAFE: CargoProject = CargoProject::new(&ABI_CAFE_REPO.source_dir(), "abi_cafe_target");
 
 pub(crate) fn run(
-    channel: &str,
     sysroot_kind: SysrootKind,
     dirs: &Dirs,
     cg_clif_dylib: &CodegenBackend,
@@ -28,7 +27,6 @@ pub(crate) fn run(
     eprintln!("Building sysroot for abi-cafe");
     build_sysroot::build_sysroot(
         dirs,
-        channel,
         sysroot_kind,
         cg_clif_dylib,
         bootstrap_host_compiler,
@@ -38,12 +36,11 @@ pub(crate) fn run(
 
     eprintln!("Running abi-cafe");
 
-    let pairs = ["rustc_calls_cgclif", "cgclif_calls_rustc", "cgclif_calls_cc", "cc_calls_cgclif"];
+    let pairs: &[_] =
-    let pairs =
         if cfg!(not(any(target_os = "macos", all(target_os = "windows", target_env = "msvc")))) {
-            &pairs[..]
+            &["rustc_calls_cgclif", "cgclif_calls_rustc", "cgclif_calls_cc", "cc_calls_cgclif"]
         } else {
-            &pairs[..2]
+            &["rustc_calls_cgclif", "cgclif_calls_rustc"]
         };
 
     let mut cmd = ABI_CAFE.run(bootstrap_host_compiler, dirs);

compiler/rustc_codegen_cranelift/build_system/bench.rs

@@ -1,11 +1,12 @@
 use std::env;
 use std::io::Write;
 use std::path::Path;
+use std::process::Command;
 
 use crate::path::{Dirs, RelPath};
 use crate::prepare::GitRepo;
 use crate::rustc_info::get_file_name;
-use crate::utils::{Compiler, hyperfine_command, spawn_and_wait};
+use crate::utils::{Compiler, spawn_and_wait};
 
 static SIMPLE_RAYTRACER_REPO: GitRepo = GitRepo::github(
     "ebobby",
@@ -128,3 +129,37 @@ fn benchmark_simple_raytracer(dirs: &Dirs, bootstrap_host_compiler: &Compiler) {
         gha_step_summary.write_all(b"\n").unwrap();
     }
 }
+
+#[must_use]
+fn hyperfine_command(
+    warmup: u64,
+    runs: u64,
+    prepare: Option<&str>,
+    cmds: &[(&str, &str)],
+    markdown_export: &Path,
+) -> Command {
+    let mut bench = Command::new("hyperfine");
+
+    bench.arg("--export-markdown").arg(markdown_export);
+
+    if warmup != 0 {
+        bench.arg("--warmup").arg(warmup.to_string());
+    }
+
+    if runs != 0 {
+        bench.arg("--runs").arg(runs.to_string());
+    }
+
+    if let Some(prepare) = prepare {
+        bench.arg("--prepare").arg(prepare);
+    }
+
+    for &(name, cmd) in cmds {
+        if name != "" {
+            bench.arg("-n").arg(name);
+        }
+        bench.arg(cmd);
+    }
+
+    bench
+}

compiler/rustc_codegen_cranelift/build_system/build_backend.rs

@@ -6,11 +6,10 @@
 use crate::shared_utils::{rustflags_from_env, rustflags_to_cmd_env};
 use crate::utils::{CargoProject, Compiler, LogGroup};
 
-pub(crate) static CG_CLIF: CargoProject = CargoProject::new(&RelPath::SOURCE, "cg_clif");
+static CG_CLIF: CargoProject = CargoProject::new(&RelPath::SOURCE, "cg_clif");
 
 pub(crate) fn build_backend(
     dirs: &Dirs,
-    channel: &str,
     bootstrap_host_compiler: &Compiler,
     use_unstable_features: bool,
 ) -> PathBuf {
@@ -19,8 +18,8 @@ pub(crate) fn build_backend(
     let mut cmd = CG_CLIF.build(&bootstrap_host_compiler, dirs);
 
     let mut rustflags = rustflags_from_env("RUSTFLAGS");
-
     rustflags.push("-Zallow-features=rustc_private".to_owned());
+    rustflags_to_cmd_env(&mut cmd, "RUSTFLAGS", &rustflags);
 
     if env::var("CG_CLIF_EXPENSIVE_CHECKS").is_ok() {
         // Enabling debug assertions implicitly enables the clif ir verifier
@@ -32,15 +31,7 @@ pub(crate) fn build_backend(
         cmd.arg("--features").arg("unstable-features");
     }
 
-    match channel {
+    cmd.arg("--release");
-        "debug" => {}
-        "release" => {
-            cmd.arg("--release");
-        }
-        _ => unreachable!(),
-    }
-
-    rustflags_to_cmd_env(&mut cmd, "RUSTFLAGS", &rustflags);
 
     eprintln!("[BUILD] rustc_codegen_cranelift");
     crate::utils::spawn_and_wait(cmd);
@@ -48,6 +39,6 @@ pub(crate) fn build_backend(
     CG_CLIF
         .target_dir(dirs)
         .join(&bootstrap_host_compiler.triple)
-        .join(channel)
+        .join("release")
         .join(get_file_name(&bootstrap_host_compiler.rustc, "rustc_codegen_cranelift", "dylib"))
 }

compiler/rustc_codegen_cranelift/build_system/build_sysroot.rs

@@ -3,19 +3,15 @@
 use std::{env, fs};
 
 use crate::path::{Dirs, RelPath};
-use crate::rustc_info::get_file_name;
+use crate::prepare::apply_patches;
+use crate::rustc_info::{get_default_sysroot, get_file_name};
 use crate::utils::{
-    CargoProject, Compiler, LogGroup, remove_dir_if_exists, spawn_and_wait, try_hard_link,
+    ensure_empty_dir, spawn_and_wait, try_hard_link, CargoProject, Compiler, LogGroup,
 };
-use crate::{CodegenBackend, SysrootKind, config};
+use crate::{config, CodegenBackend, SysrootKind};
-
-static DIST_DIR: RelPath = RelPath::DIST;
-static BIN_DIR: RelPath = RelPath::DIST.join("bin");
-static LIB_DIR: RelPath = RelPath::DIST.join("lib");
 
 pub(crate) fn build_sysroot(
     dirs: &Dirs,
-    channel: &str,
     sysroot_kind: SysrootKind,
     cg_clif_dylib_src: &CodegenBackend,
     bootstrap_host_compiler: &Compiler,
@@ -26,9 +22,11 @@ pub(crate) fn build_sysroot(
 
     eprintln!("[BUILD] sysroot {:?}", sysroot_kind);
 
-    DIST_DIR.ensure_fresh(dirs);
+    let dist_dir = RelPath::DIST.to_path(dirs);
-    BIN_DIR.ensure_exists(dirs);
+
-    LIB_DIR.ensure_exists(dirs);
+    ensure_empty_dir(&dist_dir);
+    fs::create_dir_all(dist_dir.join("bin")).unwrap();
+    fs::create_dir_all(dist_dir.join("lib")).unwrap();
 
     let is_native = bootstrap_host_compiler.triple == target_triple;
 
@@ -38,11 +36,10 @@ pub(crate) fn build_sysroot(
             let cg_clif_dylib_path = if cfg!(windows) {
                 // Windows doesn't have rpath support, so the cg_clif dylib needs to be next to the
                 // binaries.
-                BIN_DIR
+                dist_dir.join("bin")
             } else {
-                LIB_DIR
+                dist_dir.join("lib")
             }
-            .to_path(dirs)
             .join(src_path.file_name().unwrap());
             try_hard_link(src_path, &cg_clif_dylib_path);
             CodegenBackend::Local(cg_clif_dylib_path)
@@ -56,7 +53,7 @@ pub(crate) fn build_sysroot(
         let wrapper_name = wrapper_base_name.replace("____", wrapper);
 
         let mut build_cargo_wrapper_cmd = Command::new(&bootstrap_host_compiler.rustc);
-        let wrapper_path = DIST_DIR.to_path(dirs).join(&wrapper_name);
+        let wrapper_path = dist_dir.join(&wrapper_name);
         build_cargo_wrapper_cmd
             .arg(RelPath::SCRIPTS.to_path(dirs).join(&format!("{wrapper}.rs")))
             .arg("-o")
@@ -79,22 +76,20 @@ pub(crate) fn build_sysroot(
             build_cargo_wrapper_cmd.env("BUILTIN_BACKEND", name);
         }
         spawn_and_wait(build_cargo_wrapper_cmd);
-        try_hard_link(wrapper_path, BIN_DIR.to_path(dirs).join(wrapper_name));
+        try_hard_link(wrapper_path, dist_dir.join("bin").join(wrapper_name));
     }
 
     let host = build_sysroot_for_triple(
         dirs,
-        channel,
         bootstrap_host_compiler.clone(),
         &cg_clif_dylib_path,
         sysroot_kind,
     );
-    host.install_into_sysroot(&DIST_DIR.to_path(dirs));
+    host.install_into_sysroot(&dist_dir);
 
     if !is_native {
         build_sysroot_for_triple(
             dirs,
-            channel,
             {
                 let mut bootstrap_target_compiler = bootstrap_host_compiler.clone();
                 bootstrap_target_compiler.triple = target_triple.clone();
@@ -104,7 +99,7 @@ pub(crate) fn build_sysroot(
             &cg_clif_dylib_path,
             sysroot_kind,
         )
-        .install_into_sysroot(&DIST_DIR.to_path(dirs));
+        .install_into_sysroot(&dist_dir);
     }
 
     // Copy std for the host to the lib dir. This is necessary for the jit mode to find
@@ -112,16 +107,13 @@ pub(crate) fn build_sysroot(
     for lib in host.libs {
         let filename = lib.file_name().unwrap().to_str().unwrap();
         if filename.contains("std-") && !filename.contains(".rlib") {
-            try_hard_link(&lib, LIB_DIR.to_path(dirs).join(lib.file_name().unwrap()));
+            try_hard_link(&lib, dist_dir.join("lib").join(lib.file_name().unwrap()));
         }
     }
 
     let mut target_compiler = {
-        let dirs: &Dirs = &dirs;
+        let rustc_clif = dist_dir.join(wrapper_base_name.replace("____", "rustc-clif"));
-        let rustc_clif =
+        let rustdoc_clif = dist_dir.join(wrapper_base_name.replace("____", "rustdoc-clif"));
-            RelPath::DIST.to_path(&dirs).join(wrapper_base_name.replace("____", "rustc-clif"));
-        let rustdoc_clif =
-            RelPath::DIST.to_path(&dirs).join(wrapper_base_name.replace("____", "rustdoc-clif"));
 
         Compiler {
             cargo: bootstrap_host_compiler.cargo.clone(),
@@ -139,6 +131,7 @@ pub(crate) fn build_sysroot(
     target_compiler
 }
 
+#[must_use]
 struct SysrootTarget {
     triple: String,
     libs: Vec<PathBuf>,
@@ -159,15 +152,13 @@ fn install_into_sysroot(&self, sysroot: &Path) {
     }
 }
 
-pub(crate) static STDLIB_SRC: RelPath = RelPath::BUILD.join("stdlib");
+static STDLIB_SRC: RelPath = RelPath::BUILD.join("stdlib");
-pub(crate) static STANDARD_LIBRARY: CargoProject =
+static STANDARD_LIBRARY: CargoProject =
     CargoProject::new(&STDLIB_SRC.join("library/sysroot"), "stdlib_target");
-pub(crate) static RTSTARTUP_SYSROOT: RelPath = RelPath::BUILD.join("rtstartup");
+static RTSTARTUP_SYSROOT: RelPath = RelPath::BUILD.join("rtstartup");
 
-#[must_use]
 fn build_sysroot_for_triple(
     dirs: &Dirs,
-    channel: &str,
     compiler: Compiler,
     cg_clif_dylib_path: &CodegenBackend,
     sysroot_kind: SysrootKind,
@@ -176,13 +167,10 @@ fn build_sysroot_for_triple(
         SysrootKind::None => build_rtstartup(dirs, &compiler)
             .unwrap_or(SysrootTarget { triple: compiler.triple, libs: vec![] }),
         SysrootKind::Llvm => build_llvm_sysroot_for_triple(compiler),
-        SysrootKind::Clif => {
+        SysrootKind::Clif => build_clif_sysroot_for_triple(dirs, compiler, cg_clif_dylib_path),
-            build_clif_sysroot_for_triple(dirs, channel, compiler, cg_clif_dylib_path)
-        }
     }
 }
 
-#[must_use]
 fn build_llvm_sysroot_for_triple(compiler: Compiler) -> SysrootTarget {
     let default_sysroot = crate::rustc_info::get_default_sysroot(&compiler.rustc);
 
@@ -216,10 +204,8 @@ fn build_llvm_sysroot_for_triple(compiler: Compiler) -> SysrootTarget {
     target_libs
 }
 
-#[must_use]
 fn build_clif_sysroot_for_triple(
     dirs: &Dirs,
-    channel: &str,
     mut compiler: Compiler,
     cg_clif_dylib_path: &CodegenBackend,
 ) -> SysrootTarget {
@@ -231,12 +217,12 @@ fn build_clif_sysroot_for_triple(
         target_libs.libs.extend(rtstartup_target_libs.libs);
     }
 
-    let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(&compiler.triple).join(channel);
+    let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(&compiler.triple).join("release");
 
     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"));
+        ensure_empty_dir(&build_dir.join("deps"));
     }
 
     // Build sysroot
@@ -252,12 +238,12 @@ fn build_clif_sysroot_for_triple(
     // Necessary for MinGW to find rsbegin.o and rsend.o
     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
+    // 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
+    // compile perf and a significant runtime perf regression. As such forcefully enable mir
-        // inlining.
+    // inlining.
-        rustflags.push("-Zinline-mir".to_owned());
+    rustflags.push("-Zinline-mir".to_owned());
-    }
+
     if let Some(prefix) = env::var_os("CG_CLIF_STDLIB_REMAP_PATH_PREFIX") {
         rustflags.push("--remap-path-prefix".to_owned());
         rustflags.push(format!(
@@ -268,9 +254,7 @@ fn build_clif_sysroot_for_triple(
     }
     compiler.rustflags.extend(rustflags);
     let mut build_cmd = STANDARD_LIBRARY.build(&compiler, dirs);
-    if channel == "release" {
+    build_cmd.arg("--release");
-        build_cmd.arg("--release");
-    }
     build_cmd.arg("--features").arg("backtrace panic-unwind compiler-builtins-no-f16-f128");
     build_cmd.env("CARGO_PROFILE_RELEASE_DEBUG", "true");
     build_cmd.env("__CARGO_DEFAULT_LIB_METADATA", "cg_clif");
@@ -296,7 +280,10 @@ fn build_clif_sysroot_for_triple(
 
 fn build_rtstartup(dirs: &Dirs, compiler: &Compiler) -> Option<SysrootTarget> {
     if !config::get_bool("keep_sysroot") {
-        crate::prepare::prepare_stdlib(dirs, &compiler.rustc);
+        let sysroot_src_orig = get_default_sysroot(&compiler.rustc).join("lib/rustlib/src/rust");
+        assert!(sysroot_src_orig.exists());
+
+        apply_patches(dirs, "stdlib", &sysroot_src_orig, &STDLIB_SRC.to_path(dirs));
     }
 
     if !compiler.triple.ends_with("windows-gnu") {

compiler/rustc_codegen_cranelift/build_system/main.rs

@@ -81,7 +81,6 @@ fn main() {
 
     let mut out_dir = PathBuf::from(".");
     let mut download_dir = None;
-    let mut channel = "release";
     let mut sysroot_kind = SysrootKind::Clif;
     let mut use_unstable_features = true;
     let mut frozen = false;
@@ -99,7 +98,6 @@ fn main() {
                     arg_error!("--download-dir requires argument");
                 })));
             }
-            "--debug" => channel = "debug",
             "--sysroot" => {
                 sysroot_kind = match args.next().as_deref() {
                     Some("none") => SysrootKind::None,
@@ -206,7 +204,6 @@ fn main() {
     } else {
         CodegenBackend::Local(build_backend::build_backend(
             &dirs,
-            channel,
             &bootstrap_host_compiler,
             use_unstable_features,
         ))
@@ -218,7 +215,6 @@ fn main() {
         Command::Test => {
             tests::run_tests(
                 &dirs,
-                channel,
                 sysroot_kind,
                 use_unstable_features,
                 &skip_tests.iter().map(|test| &**test).collect::<Vec<_>>(),
@@ -234,7 +230,6 @@ fn main() {
                 process::exit(1);
             }
             abi_cafe::run(
-                channel,
                 sysroot_kind,
                 &dirs,
                 &cg_clif_dylib,
@@ -245,7 +240,6 @@ fn main() {
         Command::Build => {
             build_sysroot::build_sysroot(
                 &dirs,
-                channel,
                 sysroot_kind,
                 &cg_clif_dylib,
                 &bootstrap_host_compiler,
@@ -256,7 +250,6 @@ fn main() {
         Command::Bench => {
             build_sysroot::build_sysroot(
                 &dirs,
-                channel,
                 sysroot_kind,
                 &cg_clif_dylib,
                 &bootstrap_host_compiler,

compiler/rustc_codegen_cranelift/build_system/path.rs

@@ -1,7 +1,7 @@
 use std::fs;
 use std::path::PathBuf;
 
-use crate::utils::remove_dir_if_exists;
+use crate::utils::ensure_empty_dir;
 
 #[derive(Debug, Clone)]
 pub(crate) struct Dirs {
@@ -64,7 +64,6 @@ pub(crate) fn ensure_exists(&self, dirs: &Dirs) {
 
     pub(crate) fn ensure_fresh(&self, dirs: &Dirs) {
         let path = self.to_path(dirs);
-        remove_dir_if_exists(&path);
+        ensure_empty_dir(&path);
-        fs::create_dir_all(path).unwrap();
     }
 }

compiler/rustc_codegen_cranelift/build_system/prepare.rs

@@ -4,12 +4,8 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use crate::build_sysroot::STDLIB_SRC;
 use crate::path::{Dirs, RelPath};
-use crate::rustc_info::get_default_sysroot;
+use crate::utils::{copy_dir_recursively, ensure_empty_dir, spawn_and_wait};
-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);
@@ -17,13 +13,6 @@ pub(crate) fn prepare(dirs: &Dirs) {
     crate::tests::REGEX_REPO.fetch(dirs);
 }
 
-pub(crate) fn prepare_stdlib(dirs: &Dirs, rustc: &Path) {
-    let sysroot_src_orig = get_default_sysroot(rustc).join("lib/rustlib/src/rust");
-    assert!(sysroot_src_orig.exists());
-
-    apply_patches(dirs, "stdlib", &sysroot_src_orig, &STDLIB_SRC.to_path(dirs));
-}
-
 pub(crate) struct GitRepo {
     url: GitRepoUrl,
     rev: &'static str,
@@ -119,7 +108,11 @@ pub(crate) fn fetch(&self, dirs: &Dirs) {
 
         match self.url {
             GitRepoUrl::Github { user, repo } => {
-                clone_repo_shallow_github(dirs, &download_dir, user, repo, self.rev);
+                clone_repo(
+                    &download_dir,
+                    &format!("https://github.com/{}/{}.git", user, repo),
+                    self.rev,
+                );
             }
         }
 
@@ -154,7 +147,6 @@ pub(crate) fn patch(&self, dirs: &Dirs) {
     }
 }
 
-#[allow(dead_code)]
 fn clone_repo(download_dir: &Path, repo: &str, rev: &str) {
     eprintln!("[CLONE] {}", repo);
     // Ignore exit code as the repo may already have been checked out
@@ -171,55 +163,6 @@ fn clone_repo(download_dir: &Path, repo: &str, rev: &str) {
     std::fs::remove_dir_all(download_dir.join(".git")).unwrap();
 }
 
-fn clone_repo_shallow_github(dirs: &Dirs, download_dir: &Path, user: &str, repo: &str, rev: &str) {
-    if cfg!(windows) {
-        // Older windows doesn't have tar or curl by default. Fall back to using git.
-        clone_repo(download_dir, &format!("https://github.com/{}/{}.git", user, repo), rev);
-        return;
-    }
-
-    let archive_url = format!("https://github.com/{}/{}/archive/{}.tar.gz", user, repo, rev);
-    let archive_file = RelPath::DOWNLOAD.to_path(dirs).join(format!("{}.tar.gz", rev));
-    let archive_dir = RelPath::DOWNLOAD.to_path(dirs).join(format!("{}-{}", repo, rev));
-
-    eprintln!("[DOWNLOAD] {}/{} from {}", user, repo, archive_url);
-
-    // Remove previous results if they exists
-    let _ = std::fs::remove_file(&archive_file);
-    let _ = std::fs::remove_dir_all(&archive_dir);
-    let _ = std::fs::remove_dir_all(&download_dir);
-
-    // Download zip archive
-    let mut download_cmd = Command::new("curl");
-    download_cmd
-        .arg("--max-time")
-        .arg("600")
-        .arg("-y")
-        .arg("30")
-        .arg("-Y")
-        .arg("10")
-        .arg("--connect-timeout")
-        .arg("30")
-        .arg("--continue-at")
-        .arg("-")
-        .arg("--location")
-        .arg("--output")
-        .arg(&archive_file)
-        .arg(archive_url);
-    retry_spawn_and_wait(5, download_cmd);
-
-    // Unpack tar archive
-    let mut unpack_cmd = Command::new("tar");
-    unpack_cmd.arg("xf").arg(&archive_file).current_dir(RelPath::DOWNLOAD.to_path(dirs));
-    spawn_and_wait(unpack_cmd);
-
-    // Rename unpacked dir to the expected name
-    std::fs::rename(archive_dir, &download_dir).unwrap();
-
-    // Cleanup
-    std::fs::remove_file(archive_file).unwrap();
-}
-
 fn init_git_repo(repo_dir: &Path) {
     let mut git_init_cmd = git_command(repo_dir, "init");
     git_init_cmd.arg("-q");
@@ -259,14 +202,8 @@ pub(crate) fn apply_patches(dirs: &Dirs, crate_name: &str, source_dir: &Path, ta
 
     eprintln!("[COPY] {crate_name} source");
 
-    remove_dir_if_exists(target_dir);
+    ensure_empty_dir(target_dir);
-    fs::create_dir_all(target_dir).unwrap();
+    copy_dir_recursively(source_dir, target_dir);
-    if crate_name == "stdlib" {
-        fs::create_dir(target_dir.join("library")).unwrap();
-        copy_dir_recursively(&source_dir.join("library"), &target_dir.join("library"));
-    } else {
-        copy_dir_recursively(source_dir, target_dir);
-    }
 
     init_git_repo(target_dir);
 
@@ -285,3 +222,22 @@ pub(crate) fn apply_patches(dirs: &Dirs, crate_name: &str, source_dir: &Path, ta
         spawn_and_wait(apply_patch_cmd);
     }
 }
+
+#[must_use]
+fn git_command<'a>(repo_dir: impl Into<Option<&'a Path>>, cmd: &str) -> Command {
+    let mut git_cmd = Command::new("git");
+    git_cmd
+        .arg("-c")
+        .arg("user.name=Dummy")
+        .arg("-c")
+        .arg("user.email=dummy@example.com")
+        .arg("-c")
+        .arg("core.autocrlf=false")
+        .arg("-c")
+        .arg("commit.gpgSign=false")
+        .arg(cmd);
+    if let Some(repo_dir) = repo_dir.into() {
+        git_cmd.current_dir(repo_dir);
+    }
+    git_cmd
+}

compiler/rustc_codegen_cranelift/build_system/tests.rs

@@ -117,7 +117,7 @@ const fn jit_bin(config: &'static str, source: &'static str, args: &'static str)
     "rand",
 );
 
-pub(crate) static RAND: CargoProject = CargoProject::new(&RAND_REPO.source_dir(), "rand_target");
+static RAND: CargoProject = CargoProject::new(&RAND_REPO.source_dir(), "rand_target");
 
 pub(crate) static REGEX_REPO: GitRepo = GitRepo::github(
     "rust-lang",
@@ -127,12 +127,11 @@ const fn jit_bin(config: &'static str, source: &'static str, args: &'static str)
     "regex",
 );
 
-pub(crate) static REGEX: CargoProject = CargoProject::new(&REGEX_REPO.source_dir(), "regex_target");
+static REGEX: CargoProject = CargoProject::new(&REGEX_REPO.source_dir(), "regex_target");
 
-pub(crate) static PORTABLE_SIMD_SRC: RelPath = RelPath::BUILD.join("coretests");
+static PORTABLE_SIMD_SRC: RelPath = RelPath::BUILD.join("portable-simd");
 
-pub(crate) static PORTABLE_SIMD: CargoProject =
+static PORTABLE_SIMD: CargoProject = CargoProject::new(&PORTABLE_SIMD_SRC, "portable-simd_target");
-    CargoProject::new(&PORTABLE_SIMD_SRC, "portable-simd_target");
 
 static LIBCORE_TESTS_SRC: RelPath = RelPath::BUILD.join("coretests");
 
@@ -230,13 +229,6 @@ const fn jit_bin(config: &'static str, source: &'static str, args: &'static str)
         if runner.is_native {
             let mut test_cmd = PORTABLE_SIMD.test(&runner.target_compiler, &runner.dirs);
             test_cmd.arg("-q");
-            // FIXME remove after portable-simd update
-            test_cmd
-                .arg("--")
-                .arg("--skip")
-                .arg("core_simd::swizzle::simd_swizzle")
-                .arg("--skip")
-                .arg("core_simd::vector::Simd<T,N>::lanes");
             spawn_and_wait(test_cmd);
         }
     }),
@@ -244,7 +236,6 @@ const fn jit_bin(config: &'static str, source: &'static str, args: &'static str)
 
 pub(crate) fn run_tests(
     dirs: &Dirs,
-    channel: &str,
     sysroot_kind: SysrootKind,
     use_unstable_features: bool,
     skip_tests: &[&str],
@@ -260,7 +251,6 @@ pub(crate) fn run_tests(
     if config::get_bool("testsuite.no_sysroot") && !skip_tests.contains(&"testsuite.no_sysroot") {
         let target_compiler = build_sysroot::build_sysroot(
             dirs,
-            channel,
             SysrootKind::None,
             cg_clif_dylib,
             bootstrap_host_compiler,
@@ -291,7 +281,6 @@ pub(crate) fn run_tests(
     if run_base_sysroot || run_extended_sysroot {
         let target_compiler = build_sysroot::build_sysroot(
             dirs,
-            channel,
             sysroot_kind,
             cg_clif_dylib,
             bootstrap_host_compiler,
@@ -443,7 +432,6 @@ fn rustc_command<I, S>(&self, args: I) -> Command
         cmd.arg("--target");
         cmd.arg(&self.target_compiler.triple);
         cmd.arg("-Cpanic=abort");
-        cmd.arg("-Zunstable-options");
         cmd.arg("--check-cfg=cfg(jit)");
         cmd.args(args);
         cmd
@@ -458,26 +446,11 @@ fn run_rustc<I, S>(&self, args: I)
     }
 
     fn run_out_command(&self, name: &str, args: &[&str]) {
-        let mut full_cmd = vec![];
+        let mut cmd = self
+            .target_compiler
+            .run_with_runner(BUILD_EXAMPLE_OUT_DIR.to_path(&self.dirs).join(name));
 
-        // Prepend the RUN_WRAPPER's
+        cmd.args(args);
-        if !self.target_compiler.runner.is_empty() {
-            full_cmd.extend(self.target_compiler.runner.iter().cloned());
-        }
-
-        full_cmd.push(
-            BUILD_EXAMPLE_OUT_DIR.to_path(&self.dirs).join(name).to_str().unwrap().to_string(),
-        );
-
-        for arg in args {
-            full_cmd.push(arg.to_string());
-        }
-
-        let mut cmd_iter = full_cmd.into_iter();
-        let first = cmd_iter.next().unwrap();
-
-        let mut cmd = Command::new(first);
-        cmd.args(cmd_iter);
 
         spawn_and_wait(cmd);
     }

compiler/rustc_codegen_cranelift/build_system/usage.txt

@@ -2,16 +2,12 @@ The build system of cg_clif.
 
 USAGE:
     ./y.sh prepare [--out-dir DIR] [--download-dir DIR]
-    ./y.sh build [--debug] [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
+    ./y.sh build [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
-    ./y.sh test [--debug] [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen] [--skip-test TESTNAME]
+    ./y.sh test [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen] [--skip-test TESTNAME]
-    ./y.sh abi-cafe [--debug] [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
+    ./y.sh abi-cafe [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
-    ./y.sh bench [--debug] [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
+    ./y.sh bench [--sysroot none|clif|llvm] [--out-dir DIR] [--download-dir DIR] [--no-unstable-features] [--frozen]
 
 OPTIONS:
-    --debug
-            Build cg_clif and the standard library in debug mode rather than release mode.
-            Warning: An unoptimized cg_clif is very slow.
-
     --sysroot none|clif|llvm
             Which sysroot libraries to use:
             `none` will not include any standard library in the sysroot.
@@ -43,7 +39,5 @@ 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: Git is used for applying patches and on Windows for downloading test repos.
+    * Git: Git is used for downloading test repos and applying patches.
-    * 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`.

compiler/rustc_codegen_cranelift/build_system/utils.rs

@@ -1,3 +1,4 @@
+use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::process::{self, Command};
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -59,6 +60,18 @@ pub(crate) fn set_cross_linker_and_runner(&mut self) {
             }
         }
     }
+
+    pub(crate) fn run_with_runner(&self, program: impl AsRef<OsStr>) -> Command {
+        if self.runner.is_empty() {
+            Command::new(program)
+        } else {
+            let mut runner_iter = self.runner.iter();
+            let mut cmd = Command::new(runner_iter.next().unwrap());
+            cmd.args(runner_iter);
+            cmd.arg(program);
+            cmd
+        }
+    }
 }
 
 pub(crate) struct CargoProject {
@@ -141,59 +154,6 @@ pub(crate) fn run(&self, compiler: &Compiler, dirs: &Dirs) -> Command {
     }
 }
 
-#[must_use]
-pub(crate) fn hyperfine_command(
-    warmup: u64,
-    runs: u64,
-    prepare: Option<&str>,
-    cmds: &[(&str, &str)],
-    markdown_export: &Path,
-) -> Command {
-    let mut bench = Command::new("hyperfine");
-
-    bench.arg("--export-markdown").arg(markdown_export);
-
-    if warmup != 0 {
-        bench.arg("--warmup").arg(warmup.to_string());
-    }
-
-    if runs != 0 {
-        bench.arg("--runs").arg(runs.to_string());
-    }
-
-    if let Some(prepare) = prepare {
-        bench.arg("--prepare").arg(prepare);
-    }
-
-    for &(name, cmd) in cmds {
-        if name != "" {
-            bench.arg("-n").arg(name);
-        }
-        bench.arg(cmd);
-    }
-
-    bench
-}
-
-#[must_use]
-pub(crate) fn git_command<'a>(repo_dir: impl Into<Option<&'a Path>>, cmd: &str) -> Command {
-    let mut git_cmd = Command::new("git");
-    git_cmd
-        .arg("-c")
-        .arg("user.name=Dummy")
-        .arg("-c")
-        .arg("user.email=dummy@example.com")
-        .arg("-c")
-        .arg("core.autocrlf=false")
-        .arg("-c")
-        .arg("commit.gpgSign=false")
-        .arg(cmd);
-    if let Some(repo_dir) = repo_dir.into() {
-        git_cmd.current_dir(repo_dir);
-    }
-    git_cmd
-}
-
 #[track_caller]
 pub(crate) fn try_hard_link(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
     let src = src.as_ref();
@@ -212,27 +172,33 @@ pub(crate) fn spawn_and_wait(mut cmd: Command) {
     }
 }
 
-// Based on the retry function in rust's src/ci/shared.sh
+/// Create the specified directory if it doesn't exist yet and delete all contents.
-#[track_caller]
+pub(crate) fn ensure_empty_dir(path: &Path) {
-pub(crate) fn retry_spawn_and_wait(tries: u64, mut cmd: Command) {
+    fs::create_dir_all(path).unwrap();
-    for i in 1..tries + 1 {
+    let read_dir = match fs::read_dir(&path) {
-        if i != 1 {
+        Ok(read_dir) => read_dir,
-            eprintln!("Command failed. Attempt {i}/{tries}:");
+        Err(err) if err.kind() == io::ErrorKind::NotFound => {
-        }
-        if cmd.spawn().unwrap().wait().unwrap().success() {
             return;
         }
-        std::thread::sleep(std::time::Duration::from_secs(i * 5));
+        Err(err) => {
-    }
+            panic!("Failed to read contents of {path}: {err}", path = path.display())
-    eprintln!("The command has failed after {tries} attempts.");
+        }
-    process::exit(1);
+    };
-}
+    for entry in read_dir {
-
+        let entry = entry.unwrap();
-pub(crate) fn remove_dir_if_exists(path: &Path) {
+        if entry.file_type().unwrap().is_dir() {
-    match fs::remove_dir_all(&path) {
+            match fs::remove_dir_all(entry.path()) {
-        Ok(()) => {}
+                Ok(()) => {}
-        Err(err) if err.kind() == io::ErrorKind::NotFound => {}
+                Err(err) if err.kind() == io::ErrorKind::NotFound => {}
-        Err(err) => panic!("Failed to remove {path}: {err}", path = path.display()),
+                Err(err) => panic!("Failed to remove {path}: {err}", path = entry.path().display()),
+            }
+        } else {
+            match fs::remove_file(entry.path()) {
+                Ok(()) => {}
+                Err(err) if err.kind() == io::ErrorKind::NotFound => {}
+                Err(err) => panic!("Failed to remove {path}: {err}", path = entry.path().display()),
+            }
+        }
     }
 }
 

compiler/rustc_codegen_cranelift/clean_all.sh

@@ -1,9 +1,10 @@
-#!/usr/bin/env bash
+#!/bin/sh
 set -e
 
-rm -rf target/ build_system/target download/ build/ dist/ y.bin y.bin.dSYM y.exe y.pdb
+rm -rf target/ build_system/target download/ build/ dist/
 
 # Kept for now in case someone updates their checkout of cg_clif before running clean_all.sh
 # FIXME remove at some point in the future
+rm y.bin y.bin.dSYM y.exe y.pdb 2>/dev/null || true
 rm -rf rand/ regex/ simple-raytracer/ portable-simd/ abi-checker/ abi-cafe/
 rm -rf build_sysroot/{sysroot_src/,target/,compiler-builtins/,rustc_version}

compiler/rustc_codegen_cranelift/example/neon.rs

@@ -202,6 +202,44 @@ unsafe fn test_vqadd_u8() {
     assert_eq!(r, e);
 }
 
+#[cfg(target_arch = "aarch64")]
+unsafe fn test_vmaxq_f32() {
+    // AArch64 llvm intrinsic: llvm.aarch64.neon.fmax.v4f32
+    let a = f32x4::from([0., -1., 2., -3.]);
+    let b = f32x4::from([-4., 5., -6., 7.]);
+    let e = f32x4::from([0., 5., 2., 7.]);
+    let r: f32x4 = transmute(vmaxq_f32(transmute(a), transmute(b)));
+    assert_eq!(r, e);
+}
+
+#[cfg(target_arch = "aarch64")]
+unsafe fn test_vminq_f32() {
+    // AArch64 llvm intrinsic: llvm.aarch64.neon.fmin.v4f32
+    let a = f32x4::from([0., -1., 2., -3.]);
+    let b = f32x4::from([-4., 5., -6., 7.]);
+    let e = f32x4::from([-4., -1., -6., -3.]);
+    let r: f32x4 = transmute(vminq_f32(transmute(a), transmute(b)));
+    assert_eq!(r, e);
+}
+
+#[cfg(target_arch = "aarch64")]
+unsafe fn test_vaddvq_f32() {
+    // AArch64 llvm intrinsic: llvm.aarch64.neon.faddv.f32.v4f32
+    let a = f32x4::from([0., 1., 2., 3.]);
+    let e = 6f32;
+    let r = vaddvq_f32(transmute(a));
+    assert_eq!(r, e);
+}
+
+#[cfg(target_arch = "aarch64")]
+unsafe fn test_vrndnq_f32() {
+    // AArch64 llvm intrinsic: llvm.aarch64.neon.frintn.v4f32
+    let a = f32x4::from([0.1, -1.9, 4.5, 5.5]);
+    let e = f32x4::from([0., -2., 4., 6.]);
+    let r: f32x4 = transmute(vrndnq_f32(transmute(a)));
+    assert_eq!(r, e);
+}
+
 #[cfg(target_arch = "aarch64")]
 fn main() {
     unsafe {
@@ -229,6 +267,11 @@ fn main() {
 
         test_vqsub_u8();
         test_vqadd_u8();
+
+        test_vmaxq_f32();
+        test_vminq_f32();
+        test_vaddvq_f32();
+        test_vrndnq_f32();
     }
 }
 

compiler/rustc_codegen_cranelift/example/std_example.rs

@@ -258,6 +258,9 @@ unsafe fn test_simd() {
     test_mm_insert_epi16();
     test_mm_shuffle_epi8();
 
+    #[cfg(not(jit))]
+    test_mm_cmpestri();
+
     test_mm256_shuffle_epi8();
     test_mm256_permute2x128_si256();
     test_mm256_permutevar8x32_epi32();
@@ -429,6 +432,31 @@ unsafe fn test_mm_shuffle_epi8() {
     assert_eq_m128i(r, expected);
 }
 
+// Currently one cannot `load` a &[u8] that is less than 16
+// in length. This makes loading strings less than 16 in length
+// a bit difficult. Rather than `load` and mutate the __m128i,
+// it is easier to memcpy the given string to a local slice with
+// length 16 and `load` the local slice.
+#[cfg(not(jit))]
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "sse4.2")]
+unsafe fn str_to_m128i(s: &[u8]) -> __m128i {
+    assert!(s.len() <= 16);
+    let slice = &mut [0u8; 16];
+    std::ptr::copy_nonoverlapping(s.as_ptr(), slice.as_mut_ptr(), s.len());
+    _mm_loadu_si128(slice.as_ptr() as *const _)
+}
+
+#[cfg(not(jit))]
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "sse4.2")]
+unsafe fn test_mm_cmpestri() {
+    let a = str_to_m128i(b"bar - garbage");
+    let b = str_to_m128i(b"foobar");
+    let i = _mm_cmpestri::<_SIDD_CMP_EQUAL_ORDERED>(a, 3, b, 6);
+    assert_eq!(3, i);
+}
+
 #[cfg(target_arch = "x86_64")]
 #[target_feature(enable = "avx2")]
 unsafe fn test_mm256_shuffle_epi8() {

compiler/rustc_codegen_cranelift/patches/0001-portable-simd-Disable-broken-reduce_sum-test.patch

@@ -0,0 +1,26 @@
+From 5489384bc265e9e6fc2efaa63d93a4d51ebec2f5 Mon Sep 17 00:00:00 2001
+From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
+Date: Thu, 22 Aug 2024 19:22:58 +0000
+Subject: [PATCH] Disable broken reduce_sum test
+
+It was broken by an upstream change to the .sum() implementation on
+float iterators.
+---
+ crates/core_simd/tests/ops_macros.rs | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/crates/core_simd/tests/ops_macros.rs b/crates/core_simd/tests/ops_macros.rs
+index aa565a1..5e6ac41 100644
+--- a/crates/core_simd/tests/ops_macros.rs
++++ b/crates/core_simd/tests/ops_macros.rs
+@@ -646,6 +646,7 @@ macro_rules! impl_float_tests {
+                 }
+ 
+                 fn reduce_sum<const LANES: usize>() {
++                    return;
+                     test_helpers::test_1(&|x| {
+                         test_helpers::prop_assert_biteq! (
+                             Vector::<LANES>::from_array(x).reduce_sum(),
+-- 
+2.34.1
+

compiler/rustc_codegen_cranelift/patches/0022-coretests-Disable-not-compiling-tests.patch

@@ -38,7 +38,7 @@ index 42a26ae..5ac1042 100644
 @@ -1,3 +1,4 @@
 +#![cfg(test)]
  // tidy-alphabetical-start
- #![cfg_attr(bootstrap, feature(offset_of_nested))]
+ #![cfg_attr(bootstrap, feature(const_mut_refs))]
  #![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
 --
 2.21.0 (Apple Git-122)

compiler/rustc_codegen_cranelift/patches/0027-coretests-128bit-atomic-operations.patch

@@ -14,14 +14,13 @@ diff --git a/lib.rs b/lib.rs
 index 1e336bf..35e6f54 100644
 --- a/lib.rs
 +++ b/lib.rs
-@@ -1,7 +1,6 @@
+@@ -1,6 +1,5 @@
  #![cfg(test)]
  // tidy-alphabetical-start
- #![cfg_attr(bootstrap, feature(offset_of_nested))]
+ #![cfg_attr(bootstrap, feature(const_mut_refs))]
 -#![cfg_attr(target_has_atomic = "128", feature(integer_atomics))]
  #![cfg_attr(test, feature(cfg_match))]
  #![feature(alloc_layout_extra)]
- #![feature(array_chunks)]
 diff --git a/atomic.rs b/atomic.rs
 index b735957..ea728b6 100644
 --- a/atomic.rs

compiler/rustc_codegen_cranelift/patches/0028-coretests-Disable-long-running-tests.patch

@@ -43,6 +43,26 @@ index 8402833..84592e0 100644
  
  #[test]
  fn test_slice_from_ptr_range() {
+diff --git a/lazy.rs b/lazy.rs
+index 711511e..49c8d78 100644
+--- a/lazy.rs
++++ b/lazy.rs
+@@ -113,6 +113,7 @@ fn lazy_type_inference() {
+     let _ = LazyCell::new(|| ());
+ }
+ 
++/*
+ #[test]
+ #[should_panic = "LazyCell instance has previously been poisoned"]
+ fn lazy_force_mut_panic() {
+@@ -123,6 +124,7 @@ fn lazy_force_mut_panic() {
+     .unwrap_err();
+     let _ = &*lazy;
+ }
++*/
+ 
+ #[test]
+ fn lazy_force_mut() {
 -- 
 2.26.2.7.g19db9cfb68
 

compiler/rustc_codegen_cranelift/rust-toolchain

@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2024-08-09"
+channel = "nightly-2024-09-23"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
 profile = "minimal"

compiler/rustc_codegen_cranelift/scripts/setup_rust_fork.sh

@@ -25,6 +25,9 @@ git -c user.name=Dummy -c user.email=dummy@example.com -c commit.gpgSign=false \
 cat > config.toml <<EOF
 change-id = 999999
 
+[llvm]
+download-ci-llvm = true
+
 [build]
 rustc = "$(pwd)/../dist/bin/rustc-clif"
 cargo = "$(rustup which cargo)"

compiler/rustc_codegen_cranelift/scripts/test_rustc_tests.sh

@@ -59,6 +59,7 @@ rm -r tests/run-make/mismatching-target-triples # same
 rm tests/ui/asm/x86_64/issue-96797.rs # const and sym inline asm operands don't work entirely correctly
 rm tests/ui/asm/x86_64/goto.rs # inline asm labels not supported
 rm tests/ui/simd/simd-bitmask-notpow2.rs # non-pow-of-2 simd vector sizes
+rm -r tests/run-make/embed-source-dwarf # embedding sources in debuginfo
 
 # requires LTO
 rm -r tests/run-make/cdylib
@@ -75,6 +76,8 @@ rm -r tests/ui/instrument-coverage/
 
 # missing f16/f128 support
 rm tests/ui/half-open-range-patterns/half-open-range-pats-semantics.rs
+rm tests/ui/asm/aarch64/type-f16.rs
+rm tests/ui/float/conv-bits-runtime-const.rs
 
 # optimization tests
 # ==================
@@ -137,14 +140,19 @@ rm tests/ui/deprecation/deprecated_inline_threshold.rs # missing deprecation war
 # ======================
 rm tests/ui/process/nofile-limit.rs # TODO some AArch64 linking issue
 rm tests/ui/backtrace/synchronized-panic-handler.rs # missing needs-unwind annotation
+rm tests/ui/lint/non-snake-case/lint-non-snake-case-crate.rs # same
 rm -r tests/ui/codegen/equal-pointers-unequal # make incorrect assumptions about the location of stack variables
 
 rm tests/ui/stdio-is-blocking.rs # really slow with unoptimized libstd
+rm tests/ui/intrinsics/panic-uninitialized-zeroed.rs # same
+rm tests/ui/process/process-panic-after-fork.rs # same
 
 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
 # rustdoc-clif
+# FIXME remove the bootstrap changes once it is no longer necessary to revert rust-lang/rust#130642
+# to avoid building rustc when testing stage0 run-make.
 cat <<EOF | git apply -
 diff --git a/tests/run-make/tools.mk b/tests/run-make/tools.mk
 index ea06b620c4c..b969d0009c6 100644
@@ -172,6 +180,90 @@ index 9607ff02f96..b7d97caf9a2 100644
          Self { cmd }
      }
 
+diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
+index 2047345d78a..a7e9352bb1c 100644
+--- a/src/bootstrap/src/core/build_steps/test.rs
++++ b/src/bootstrap/src/core/build_steps/test.rs
+@@ -1733,11 +1733,6 @@ fn run(self, builder: &Builder<'_>) {
+
+         let is_rustdoc = suite.ends_with("rustdoc-ui") || suite.ends_with("rustdoc-js");
+
+-        if mode == "run-make" {
+-            let cargo = builder.ensure(tool::Cargo { compiler, target: compiler.host });
+-            cmd.arg("--cargo-path").arg(cargo);
+-        }
+-
+         // Avoid depending on rustdoc when we don't need it.
+         if mode == "rustdoc"
+             || mode == "run-make"
+diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
+index 414f9f3a7f1..5c18179b6fe 100644
+--- a/src/tools/compiletest/src/common.rs
++++ b/src/tools/compiletest/src/common.rs
+@@ -183,9 +183,6 @@ pub struct Config {
+     /// The rustc executable.
+     pub rustc_path: PathBuf,
+
+-    /// The cargo executable.
+-    pub cargo_path: Option<PathBuf>,
+-
+     /// The rustdoc executable.
+     pub rustdoc_path: Option<PathBuf>,
+
+diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
+index 3339116d542..250b5084d13 100644
+--- a/src/tools/compiletest/src/lib.rs
++++ b/src/tools/compiletest/src/lib.rs
+@@ -47,7 +47,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
+     opts.reqopt("", "compile-lib-path", "path to host shared libraries", "PATH")
+         .reqopt("", "run-lib-path", "path to target shared libraries", "PATH")
+         .reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH")
+-        .optopt("", "cargo-path", "path to cargo to use for compiling", "PATH")
+         .optopt("", "rustdoc-path", "path to rustdoc to use for compiling", "PATH")
+         .optopt("", "coverage-dump-path", "path to coverage-dump to use in tests", "PATH")
+         .reqopt("", "python", "path to python to use for doc tests", "PATH")
+@@ -261,7 +260,6 @@ fn make_absolute(path: PathBuf) -> PathBuf {
+         compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
+         run_lib_path: make_absolute(opt_path(matches, "run-lib-path")),
+         rustc_path: opt_path(matches, "rustc-path"),
+-        cargo_path: matches.opt_str("cargo-path").map(PathBuf::from),
+         rustdoc_path: matches.opt_str("rustdoc-path").map(PathBuf::from),
+         coverage_dump_path: matches.opt_str("coverage-dump-path").map(PathBuf::from),
+         python: matches.opt_str("python").unwrap(),
+@@ -366,7 +364,6 @@ pub fn log_config(config: &Config) {
+     logv(c, format!("compile_lib_path: {:?}", config.compile_lib_path));
+     logv(c, format!("run_lib_path: {:?}", config.run_lib_path));
+     logv(c, format!("rustc_path: {:?}", config.rustc_path.display()));
+-    logv(c, format!("cargo_path: {:?}", config.cargo_path));
+     logv(c, format!("rustdoc_path: {:?}", config.rustdoc_path));
+     logv(c, format!("src_base: {:?}", config.src_base.display()));
+     logv(c, format!("build_base: {:?}", config.build_base.display()));
+diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
+index 75fe6a6baaf..852568ae925 100644
+--- a/src/tools/compiletest/src/runtest/run_make.rs
++++ b/src/tools/compiletest/src/runtest/run_make.rs
+@@ -61,10 +61,6 @@ fn run_rmake_legacy_test(&self) {
+             .env_remove("MFLAGS")
+             .env_remove("CARGO_MAKEFLAGS");
+
+-        if let Some(ref cargo) = self.config.cargo_path {
+-            cmd.env("CARGO", cwd.join(cargo));
+-        }
+-
+         if let Some(ref rustdoc) = self.config.rustdoc_path {
+             cmd.env("RUSTDOC", cwd.join(rustdoc));
+         }
+@@ -413,10 +409,6 @@ fn run_rmake_v2_test(&self) {
+             // through a specific CI runner).
+             .env("LLVM_COMPONENTS", &self.config.llvm_components);
+
+-        if let Some(ref cargo) = self.config.cargo_path {
+-            cmd.env("CARGO", source_root.join(cargo));
+-        }
+-
+         if let Some(ref rustdoc) = self.config.rustdoc_path {
+             cmd.env("RUSTDOC", source_root.join(rustdoc));
+         }
 EOF
 
 echo "[TEST] rustc test suite"

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -508,7 +508,10 @@ enum CallTarget {
                 let nop_inst = fx.bcx.ins().nop();
                 fx.add_comment(
                     nop_inst,
-                    format!("virtual call; self arg pass mode: {:?}", fn_abi.args[0]),
+                    with_no_trimmed_paths!(format!(
+                        "virtual call; self arg pass mode: {:?}",
+                        fn_abi.args[0]
+                    )),
                 );
             }
 

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -490,6 +490,11 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
 }
 
 /// Used only for intrinsic implementations that need a compile-time constant
+///
+/// All uses of this function are a bug inside stdarch. [`eval_mir_constant`]
+/// should be used everywhere, but for some vendor intrinsics stdarch forgets
+/// to wrap the immediate argument in `const {}`, necesitating this hack to get
+/// the correct value at compile time instead.
 pub(crate) fn mir_operand_get_const_val<'tcx>(
     fx: &FunctionCx<'_, '_, 'tcx>,
     operand: &Operand<'tcx>,

compiler/rustc_codegen_cranelift/src/intrinsics/llvm_aarch64.rs

@@ -91,6 +91,44 @@ pub(crate) fn codegen_aarch64_llvm_intrinsic_call<'tcx>(
             );
         }
 
+        _ if intrinsic.starts_with("llvm.aarch64.neon.fmax.v") => {
+            intrinsic_args!(fx, args => (x, y); intrinsic);
+
+            simd_pair_for_each_lane(
+                fx,
+                x,
+                y,
+                ret,
+                &|fx, _lane_ty, _res_lane_ty, x_lane, y_lane| fx.bcx.ins().fmax(x_lane, y_lane),
+            );
+        }
+
+        _ if intrinsic.starts_with("llvm.aarch64.neon.fmin.v") => {
+            intrinsic_args!(fx, args => (x, y); intrinsic);
+
+            simd_pair_for_each_lane(
+                fx,
+                x,
+                y,
+                ret,
+                &|fx, _lane_ty, _res_lane_ty, x_lane, y_lane| fx.bcx.ins().fmin(x_lane, y_lane),
+            );
+        }
+
+        _ if intrinsic.starts_with("llvm.aarch64.neon.faddv.f32.v") => {
+            intrinsic_args!(fx, args => (v); intrinsic);
+
+            simd_reduce(fx, v, None, ret, &|fx, _ty, a, b| fx.bcx.ins().fadd(a, b));
+        }
+
+        _ if intrinsic.starts_with("llvm.aarch64.neon.frintn.v") => {
+            intrinsic_args!(fx, args => (v); intrinsic);
+
+            simd_for_each_lane(fx, v, ret, &|fx, _lane_ty, _res_lane_ty, lane| {
+                fx.bcx.ins().nearest(lane)
+            });
+        }
+
         _ if intrinsic.starts_with("llvm.aarch64.neon.smaxv.i") => {
             intrinsic_args!(fx, args => (v); intrinsic);
 

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -600,9 +600,11 @@ fn codegen_regular_intrinsic_call<'tcx>(
 
         sym::ptr_mask => {
             intrinsic_args!(fx, args => (ptr, mask); intrinsic);
+            let ptr_layout = ptr.layout();
             let ptr = ptr.load_scalar(fx);
             let mask = mask.load_scalar(fx);
-            fx.bcx.ins().band(ptr, mask);
+            let res = fx.bcx.ins().band(ptr, mask);
+            ret.write_cvalue(fx, CValue::by_val(res, ptr_layout));
         }
 
         sym::write_bytes | sym::volatile_set_memory => {

compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs

@@ -181,11 +181,9 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
 
             // Make sure this is actually a SIMD vector.
             let idx_ty = fx.monomorphize(idx.node.ty(fx.mir, fx.tcx));
-            let n: u16 = if idx_ty.is_simd()
+            if !idx_ty.is_simd()
-                && matches!(idx_ty.simd_size_and_type(fx.tcx).1.kind(), ty::Uint(ty::UintTy::U32))
+                || !matches!(idx_ty.simd_size_and_type(fx.tcx).1.kind(), ty::Uint(ty::UintTy::U32))
             {
-                idx_ty.simd_size_and_type(fx.tcx).0.try_into().unwrap()
-            } else {
                 fx.tcx.dcx().span_err(
                     span,
                     format!("simd_shuffle index must be a SIMD vector of `u32`, got `{}`", idx_ty),
@@ -194,6 +192,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                 fx.bcx.ins().trap(TrapCode::UnreachableCodeReached);
                 return;
             };
+            let n: u16 = idx_ty.simd_size_and_type(fx.tcx).0.try_into().unwrap();
 
             assert_eq!(x.layout(), y.layout());
             let layout = x.layout();
@@ -268,10 +267,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             let val = codegen_operand(fx, &val.node);
 
             // FIXME validate
-            let idx_const = if let Some(idx_const) =
+            let idx_const = if let Some(idx_const) = idx.node.constant() {
-                crate::constant::mir_operand_get_const_val(fx, &idx.node)
+                crate::constant::eval_mir_constant(fx, idx_const).0.try_to_scalar_int().unwrap()
-            {
-                idx_const
             } else {
                 fx.tcx.dcx().span_fatal(span, "Index argument for `simd_insert` is not a constant");
             };
@@ -304,22 +301,12 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                 return;
             }
 
-            let idx_const = if let Some(idx_const) =
+            let idx_const = if let Some(idx_const) = idx.node.constant() {
-                crate::constant::mir_operand_get_const_val(fx, &idx.node)
+                crate::constant::eval_mir_constant(fx, idx_const).0.try_to_scalar_int().unwrap()
-            {
-                idx_const
             } else {
-                fx.tcx.dcx().span_warn(span, "Index argument for `simd_extract` is not a constant");
+                fx.tcx
-                let trap_block = fx.bcx.create_block();
+                    .dcx()
-                let true_ = fx.bcx.ins().iconst(types::I8, 1);
+                    .span_fatal(span, "Index argument for `simd_extract` is not a constant");
-                let ret_block = fx.get_block(target);
-                fx.bcx.ins().brif(true_, trap_block, &[], ret_block, &[]);
-                fx.bcx.switch_to_block(trap_block);
-                crate::trap::trap_unimplemented(
-                    fx,
-                    "Index argument for `simd_extract` is not a constant",
-                );
-                return;
             };
 
             let idx = idx_const.to_u32();
@@ -574,9 +561,12 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                     (sym::simd_round, types::F64) => "round",
                     _ => unreachable!("{:?}", intrinsic),
                 };
-                fx.lib_call(name, vec![AbiParam::new(lane_ty)], vec![AbiParam::new(lane_ty)], &[
+                fx.lib_call(
-                    lane,
+                    name,
-                ])[0]
+                    vec![AbiParam::new(lane_ty)],
+                    vec![AbiParam::new(lane_ty)],
+                    &[lane],
+                )[0]
             });
         }
 

compiler/rustc_codegen_cranelift/test.sh

@@ -1,2 +1,2 @@
-#!/usr/bin/env bash
+#!/bin/sh
 exec ./y.sh test "$@"

compiler/rustc_codegen_cranelift/y.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/sh
 
 set -e
 echo "[BUILD] build system" 1>&2