diff --git a/0001-Fix-UI-tests-with-dist-vendored-dependencies.patch b/0001-Fix-UI-tests-with-dist-vendored-dependencies.patch new file mode 100644 index 0000000000000000000000000000000000000000..2d18d3088baae7e944a451eb0c37e59ae7c4982f --- /dev/null +++ b/0001-Fix-UI-tests-with-dist-vendored-dependencies.patch @@ -0,0 +1,51 @@ +From fb4d9ee194e4e6488dcbf9a7e4e16bb1e65ce5f2 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Mon, 8 Apr 2024 15:04:44 -0700 +Subject: [PATCH] Fix UI tests with dist-vendored dependencies + +There is already a workaround in `compiletest` to deal with custom +`CARGO_HOME` using `-Zignore-directory-in-diagnostics-source-blocks={}`. +A similar need exists when dependencies come from the local `vendor` +directory, which distro builds often use, so now we ignore that too. + +Also, `issue-21763.rs` was normalizing `hashbrown-` paths, presumably +expecting a version suffix, but the vendored path doesn't include the +version. Now that matches `[\\/]hashbrown` instead. + +(cherry picked from commit f7b2e37f7232540d9f2b2dc6e33597fbb74f4f63) +--- + src/tools/compiletest/src/runtest.rs | 5 +++++ + tests/ui/issues/issue-21763.rs | 2 +- + 2 files changed, 6 insertions(+), 1 deletion(-) + +diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs +index 8be4def15ded..644775c0385c 100644 +--- a/src/tools/compiletest/src/runtest.rs ++++ b/src/tools/compiletest/src/runtest.rs +@@ -2362,6 +2362,11 @@ fn make_compile_args( + "ignore-directory-in-diagnostics-source-blocks={}", + home::cargo_home().expect("failed to find cargo home").to_str().unwrap() + )); ++ // Similarly, vendored sources shouldn't be shown when running from a dist tarball. ++ rustc.arg("-Z").arg(format!( ++ "ignore-directory-in-diagnostics-source-blocks={}", ++ self.config.find_rust_src_root().unwrap().join("vendor").display(), ++ )); + + // Optionally prevent default --sysroot if specified in test compile-flags. + if !self.props.compile_flags.iter().any(|flag| flag.starts_with("--sysroot")) +diff --git a/tests/ui/issues/issue-21763.rs b/tests/ui/issues/issue-21763.rs +index 38103ff4f9c8..cc1a00687b30 100644 +--- a/tests/ui/issues/issue-21763.rs ++++ b/tests/ui/issues/issue-21763.rs +@@ -1,6 +1,6 @@ + // Regression test for HashMap only impl'ing Send/Sync if its contents do + +-// normalize-stderr-test: "\S+hashbrown-\S+" -> "$$HASHBROWN_SRC_LOCATION" ++// normalize-stderr-test: "\S+[\\/]hashbrown\S+" -> "$$HASHBROWN_SRC_LOCATION" + + use std::collections::HashMap; + use std::rc::Rc; +-- +2.44.0 + diff --git a/0001-Let-environment-variables-override-some-default-CPUs.patch b/0001-Let-environment-variables-override-some-default-CPUs.patch new file mode 100644 index 0000000000000000000000000000000000000000..dc8be55c7250f4da2dcd246ae5069cc79c8347af --- /dev/null +++ b/0001-Let-environment-variables-override-some-default-CPUs.patch @@ -0,0 +1,53 @@ +From 184d61d2c12aa2db01de9a14ccb2be0cfae5039b Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Fri, 9 Jun 2023 15:23:08 -0700 +Subject: [PATCH] Let environment variables override some default CPUs + +--- + .../src/spec/targets/powerpc64le_unknown_linux_gnu.rs | 2 +- + .../rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs | 2 +- + .../rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs | 2 +- + 3 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs +index 194c3170e683..9806ca78297c 100644 +--- a/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs ++++ b/compiler/rustc_target/src/spec/targets/powerpc64le_unknown_linux_gnu.rs +@@ -2,7 +2,7 @@ + + pub fn target() -> Target { + let mut base = base::linux_gnu::opts(); +- base.cpu = "ppc64le".into(); ++ base.cpu = option_env!("RUSTC_TARGET_CPU_PPC64LE").unwrap_or("ppc64le").into(); + base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); + base.max_atomic_width = Some(64); + base.stack_probes = StackProbeType::Inline; +diff --git a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs +index 6fc410eb2235..c8f84edb9715 100644 +--- a/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs ++++ b/compiler/rustc_target/src/spec/targets/s390x_unknown_linux_gnu.rs +@@ -5,7 +5,7 @@ pub fn target() -> Target { + let mut base = base::linux_gnu::opts(); + base.endian = Endian::Big; + // z10 is the oldest CPU supported by LLVM +- base.cpu = "z10".into(); ++ base.cpu = option_env!("RUSTC_TARGET_CPU_S390X").unwrap_or("z10").into(); + // FIXME: The ABI implementation in cabi_s390x.rs is for now hard-coded to assume the no-vector + // ABI. Pass the -vector feature string to LLVM to respect this assumption. On LLVM < 16, we + // also strip v128 from the data_layout below to match the older LLVM's expectation. +diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs +index 80e267c163fa..8436a00e66d5 100644 +--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs ++++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs +@@ -2,7 +2,7 @@ + + pub fn target() -> Target { + let mut base = base::linux_gnu::opts(); +- base.cpu = "x86-64".into(); ++ base.cpu = option_env!("RUSTC_TARGET_CPU_X86_64").unwrap_or("x86-64").into(); + base.plt_by_default = false; + base.max_atomic_width = Some(64); + base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]); +-- +2.41.0 + diff --git a/0001-Step-all-bootstrap-cfgs-forward.patch b/0001-Step-all-bootstrap-cfgs-forward.patch new file mode 100644 index 0000000000000000000000000000000000000000..bd0cd029028e5e736919dfb89cba5f44cfcedd37 --- /dev/null +++ b/0001-Step-all-bootstrap-cfgs-forward.patch @@ -0,0 +1,26 @@ +From 9a5034a20ed8b055dc615271f9d9cf27f9e494f0 Mon Sep 17 00:00:00 2001 +From: Mark Rousskov +Date: Mon, 5 Feb 2024 07:34:48 -0500 +Subject: [PATCH] Step all bootstrap cfgs forward + +This also takes care of other bootstrap-related changes. +--- + src/tools/coverage-dump/src/covfun.rs | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/tools/coverage-dump/src/covfun.rs b/src/tools/coverage-dump/src/covfun.rs +index 3a5866dea3e0..49e3a6ed5838 100644 +--- a/src/tools/coverage-dump/src/covfun.rs ++++ b/src/tools/coverage-dump/src/covfun.rs +@@ -219,7 +219,7 @@ pub(crate) fn decode(input: u32) -> Option { + enum MappingKind { + Code(CovTerm), + Gap(CovTerm), +- Expansion(u32), ++ Expansion(#[allow(dead_code)] u32), + Skip, + // Using raw identifiers here makes the dump output a little bit nicer + // (via the derived Debug), at the expense of making this tool's source +-- +2.44.0 + diff --git a/0001-The-multiple_unsafe_ops_per_block-test-needs-asm.patch b/0001-The-multiple_unsafe_ops_per_block-test-needs-asm.patch new file mode 100644 index 0000000000000000000000000000000000000000..71e6770461c3b62b98cfc42113c1443f1fc7637b --- /dev/null +++ b/0001-The-multiple_unsafe_ops_per_block-test-needs-asm.patch @@ -0,0 +1,233 @@ +From 29ed7749a3a0e4399b91b3d4198891a4d861f105 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Tue, 16 Apr 2024 16:45:59 -0700 +Subject: [PATCH] The `multiple_unsafe_ops_per_block` test needs `asm!` + +(cherry picked from commit 245fbeef49c2395471498d20e67f4edf4222c865) +--- + tests/ui/multiple_unsafe_ops_per_block.rs | 1 + + tests/ui/multiple_unsafe_ops_per_block.stderr | 58 +++++++++---------- + 2 files changed, 30 insertions(+), 29 deletions(-) + +diff --git a/tests/ui/multiple_unsafe_ops_per_block.rs b/tests/ui/multiple_unsafe_ops_per_block.rs +index 8afb4df20af4..6b8a103d4a94 100644 +--- a/tests/ui/multiple_unsafe_ops_per_block.rs ++++ b/tests/ui/multiple_unsafe_ops_per_block.rs +@@ -1,3 +1,4 @@ ++//@needs-asm-support + //@aux-build:proc_macros.rs + #![allow(unused)] + #![allow(deref_nullptr)] +diff --git a/tests/ui/multiple_unsafe_ops_per_block.stderr b/tests/ui/multiple_unsafe_ops_per_block.stderr +index 4803a5089ab2..f9b22c68ddb1 100644 +--- a/tests/ui/multiple_unsafe_ops_per_block.stderr ++++ b/tests/ui/multiple_unsafe_ops_per_block.stderr +@@ -1,5 +1,5 @@ + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:36:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:37:5 + | + LL | / unsafe { + LL | | STATIC += 1; +@@ -8,12 +8,12 @@ LL | | } + | |_____^ + | + note: modification of a mutable static occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:37:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:38:9 + | + LL | STATIC += 1; + | ^^^^^^^^^^^ + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:38:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:39:9 + | + LL | not_very_safe(); + | ^^^^^^^^^^^^^^^ +@@ -21,7 +21,7 @@ LL | not_very_safe(); + = help: to override `-D warnings` add `#[allow(clippy::multiple_unsafe_ops_per_block)]` + + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:45:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:46:5 + | + LL | / unsafe { + LL | | drop(u.u); +@@ -30,18 +30,18 @@ LL | | } + | |_____^ + | + note: union field access occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:46:14 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:47:14 + | + LL | drop(u.u); + | ^^^ + note: raw pointer dereference occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:47:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:48:9 + | + LL | *raw_ptr(); + | ^^^^^^^^^^ + + error: this `unsafe` block contains 3 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:52:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:53:5 + | + LL | / unsafe { + LL | | asm!("nop"); +@@ -51,23 +51,23 @@ LL | | } + | |_____^ + | + note: inline assembly used here +- --> $DIR/multiple_unsafe_ops_per_block.rs:53:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:54:9 + | + LL | asm!("nop"); + | ^^^^^^^^^^^ + note: unsafe method call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:54:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:55:9 + | + LL | sample.not_very_safe(); + | ^^^^^^^^^^^^^^^^^^^^^^ + note: modification of a mutable static occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:55:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:56:9 + | + LL | STATIC = 0; + | ^^^^^^^^^^ + + error: this `unsafe` block contains 6 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:61:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:62:5 + | + LL | / unsafe { + LL | | drop(u.u); +@@ -79,55 +79,55 @@ LL | | } + | |_____^ + | + note: union field access occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:62:14 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:63:14 + | + LL | drop(u.u); + | ^^^ + note: access of a mutable static occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:63:14 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:64:14 + | + LL | drop(STATIC); + | ^^^^^^ + note: unsafe method call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:64:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:65:9 + | + LL | sample.not_very_safe(); + | ^^^^^^^^^^^^^^^^^^^^^^ + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:65:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:66:9 + | + LL | not_very_safe(); + | ^^^^^^^^^^^^^^^ + note: raw pointer dereference occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:66:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:67:9 + | + LL | *raw_ptr(); + | ^^^^^^^^^^ + note: inline assembly used here +- --> $DIR/multiple_unsafe_ops_per_block.rs:67:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:68:9 + | + LL | asm!("nop"); + | ^^^^^^^^^^^ + + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:105:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:106:5 + | + LL | unsafe { char::from_u32_unchecked(*ptr.cast::()) } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:105:14 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:106:14 + | + LL | unsafe { char::from_u32_unchecked(*ptr.cast::()) } + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + note: raw pointer dereference occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:105:39 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:106:39 + | + LL | unsafe { char::from_u32_unchecked(*ptr.cast::()) } + | ^^^^^^^^^^^^^^^^^^ + + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:123:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:124:5 + | + LL | / unsafe { + LL | | x(); +@@ -136,18 +136,18 @@ LL | | } + | |_____^ + | + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:124:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:125:9 + | + LL | x(); + | ^^^ + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:125:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:126:9 + | + LL | x(); + | ^^^ + + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:134:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:135:9 + | + LL | / unsafe { + LL | | T::X(); +@@ -156,18 +156,18 @@ LL | | } + | |_________^ + | + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:135:13 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:136:13 + | + LL | T::X(); + | ^^^^^^ + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:136:13 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:137:13 + | + LL | T::X(); + | ^^^^^^ + + error: this `unsafe` block contains 2 unsafe operations, expected only one +- --> $DIR/multiple_unsafe_ops_per_block.rs:144:5 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:145:5 + | + LL | / unsafe { + LL | | x.0(); +@@ -176,12 +176,12 @@ LL | | } + | |_____^ + | + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:145:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:146:9 + | + LL | x.0(); + | ^^^^^ + note: unsafe function call occurs here +- --> $DIR/multiple_unsafe_ops_per_block.rs:146:9 ++ --> $DIR/multiple_unsafe_ops_per_block.rs:147:9 + | + LL | x.0(); + | ^^^^^ +-- +2.44.0 + diff --git a/0001-Use-lld-provided-by-system-for-wasm.patch b/0001-Use-lld-provided-by-system-for-wasm.patch deleted file mode 100644 index 5fcc2451d31a9254b061d692cc9e805d61b3c5aa..0000000000000000000000000000000000000000 --- a/0001-Use-lld-provided-by-system-for-wasm.patch +++ /dev/null @@ -1,26 +0,0 @@ -From 37cb177eb53145103ae72b67562884782dde01c3 Mon Sep 17 00:00:00 2001 -From: Ivan Mironov -Date: Sun, 8 Dec 2019 17:23:08 +0500 -Subject: [PATCH] Use lld provided by system for wasm - ---- - compiler/rustc_target/src/spec/wasm_base.rs | 3 +-- - 1 file changed, 1 insertion(+), 2 deletions(-) - -diff --git a/compiler/rustc_target/src/spec/wasm_base.rs b/compiler/rustc_target/src/spec/wasm_base.rs -index 528a84a8b37c..353d742161d1 100644 ---- a/compiler/rustc_target/src/spec/wasm_base.rs -+++ b/compiler/rustc_target/src/spec/wasm_base.rs -@@ -89,8 +89,7 @@ macro_rules! args { - // arguments just yet - limit_rdylib_exports: false, - -- // we use the LLD shipped with the Rust toolchain by default -- linker: Some("rust-lld".into()), -+ linker: Some("lld".into()), - linker_flavor: LinkerFlavor::WasmLld(Cc::No), - - pre_link_args, --- -2.38.1 - diff --git a/0001-Use-lld-provided-by-system.patch b/0001-Use-lld-provided-by-system.patch new file mode 100644 index 0000000000000000000000000000000000000000..bee8e16d3f9007c027f246b2cee659becd5d3240 --- /dev/null +++ b/0001-Use-lld-provided-by-system.patch @@ -0,0 +1,53 @@ +From 61b5cc96337da2121221dd1bcdb63fd36551d065 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Wed, 1 Nov 2023 15:21:15 -0700 +Subject: [PATCH] Use lld provided by system + +--- + compiler/rustc_target/src/spec/base/wasm.rs | 3 +-- + compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs | 2 +- + compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs | 1 + + 3 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/compiler/rustc_target/src/spec/base/wasm.rs b/compiler/rustc_target/src/spec/base/wasm.rs +index 87ade9e58cf4..2ddff95febab 100644 +--- a/compiler/rustc_target/src/spec/base/wasm.rs ++++ b/compiler/rustc_target/src/spec/base/wasm.rs +@@ -91,8 +91,7 @@ macro_rules! args { + // arguments just yet + limit_rdylib_exports: false, + +- // we use the LLD shipped with the Rust toolchain by default +- linker: Some("rust-lld".into()), ++ linker: Some("lld".into()), + linker_flavor: LinkerFlavor::WasmLld(Cc::No), + + pre_link_args, +diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs +index 9aa95a35f8e5..a9172f9441b7 100644 +--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs ++++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_none.rs +@@ -17,7 +17,7 @@ pub fn target() -> Target { + static_position_independent_executables: true, + relro_level: RelroLevel::Full, + linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes), +- linker: Some("rust-lld".into()), ++ linker: Some("lld".into()), + features: + "-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-3dnow,-3dnowa,-avx,-avx2,+soft-float" + .into(), +diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs +index 5abfb8162f70..13cb43bda1a4 100644 +--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs ++++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_uefi.rs +@@ -16,6 +16,7 @@ pub fn target() -> Target { + base.plt_by_default = false; + base.max_atomic_width = Some(64); + base.entry_abi = Conv::X86_64Win64; ++ base.linker = Some("lld".into()); + + // We disable MMX and SSE for now, even though UEFI allows using them. Problem is, you have to + // enable these CPU features explicitly before their first use, otherwise their instructions +-- +2.41.0 + diff --git a/0001-bootstrap-allow-disabling-target-self-contained.patch b/0001-bootstrap-allow-disabling-target-self-contained.patch new file mode 100644 index 0000000000000000000000000000000000000000..2a3cbd705e1278422ccf3a42cdb2c98560744e26 --- /dev/null +++ b/0001-bootstrap-allow-disabling-target-self-contained.patch @@ -0,0 +1,102 @@ +From df0d6f1d8b46db82d7599ca8eff6e8f844cf52f2 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Thu, 28 Sep 2023 18:14:28 -0700 +Subject: [PATCH 1/2] bootstrap: allow disabling target self-contained + +--- + config.example.toml | 5 +++++ + src/bootstrap/src/core/build_steps/compile.rs | 4 ++++ + src/bootstrap/src/core/config/config.rs | 8 ++++++++ + src/bootstrap/src/lib.rs | 5 +++++ + 4 files changed, 22 insertions(+) + +diff --git a/config.example.toml b/config.example.toml +index e5df28a49af6..2fcd8b8cb057 100644 +--- a/config.example.toml ++++ b/config.example.toml +@@ -807,6 +807,11 @@ change-id = 116881 + # target triples containing `-none`, `nvptx`, `switch`, or `-uefi`. + #no-std = (bool) + ++# Copy libc and CRT objects into the target lib/self-contained/ directory. ++# Enabled by default on `musl`, `wasi`, and `windows-gnu` targets. Other ++# targets may ignore this setting if they have nothing to be contained. ++#self-contained = (bool) ++ + # ============================================================================= + # Distribution options + # +diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs +index 7021a9543582..11555c65ca87 100644 +--- a/src/bootstrap/src/core/build_steps/compile.rs ++++ b/src/bootstrap/src/core/build_steps/compile.rs +@@ -302,6 +302,10 @@ fn copy_self_contained_objects( + compiler: &Compiler, + target: TargetSelection, + ) -> Vec<(PathBuf, DependencyType)> { ++ if builder.self_contained(target) != Some(true) { ++ return vec![]; ++ } ++ + let libdir_self_contained = builder.sysroot_libdir(*compiler, target).join("self-contained"); + t!(fs::create_dir_all(&libdir_self_contained)); + let mut target_deps = vec![]; +diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs +index 0a9175aa3ea5..a2e028b25036 100644 +--- a/src/bootstrap/src/core/config/config.rs ++++ b/src/bootstrap/src/core/config/config.rs +@@ -533,6 +533,7 @@ pub struct Target { + pub wasi_root: Option, + pub qemu_rootfs: Option, + pub no_std: bool, ++ pub self_contained: bool, + } + + impl Target { +@@ -541,6 +542,9 @@ pub fn from_triple(triple: &str) -> Self { + if triple.contains("-none") || triple.contains("nvptx") || triple.contains("switch") { + target.no_std = true; + } ++ if triple.contains("-musl") || triple.contains("-wasi") || triple.contains("-windows-gnu") { ++ target.self_contained = true; ++ } + target + } + } +@@ -1051,6 +1055,7 @@ struct TomlTarget { + wasi_root: Option = "wasi-root", + qemu_rootfs: Option = "qemu-rootfs", + no_std: Option = "no-std", ++ self_contained: Option = "self-contained", + } + } + +@@ -1600,6 +1605,9 @@ fn get_table(option: &str) -> Result { + if let Some(s) = cfg.no_std { + target.no_std = s; + } ++ if let Some(s) = cfg.self_contained { ++ target.self_contained = s; ++ } + target.cc = cfg.cc.map(PathBuf::from); + target.cxx = cfg.cxx.map(PathBuf::from); + target.ar = cfg.ar.map(PathBuf::from); +diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs +index 33b8f1a7ce72..f36e53187576 100644 +--- a/src/bootstrap/src/lib.rs ++++ b/src/bootstrap/src/lib.rs +@@ -1335,6 +1335,11 @@ fn no_std(&self, target: TargetSelection) -> Option { + self.config.target_config.get(&target).map(|t| t.no_std) + } + ++ /// Returns `true` if this is a self-contained `target`, if defined ++ fn self_contained(&self, target: TargetSelection) -> Option { ++ self.config.target_config.get(&target).map(|t| t.self_contained) ++ } ++ + /// Returns `true` if the target will be tested using the `remote-test-client` + /// and `remote-test-server` binaries. + fn remote_tested(&self, target: TargetSelection) -> bool { +-- +2.41.0 + diff --git a/0001-bootstrap-move-all-of-rustc-s-flags-to-rustc_cargo.patch b/0001-bootstrap-move-all-of-rustc-s-flags-to-rustc_cargo.patch new file mode 100644 index 0000000000000000000000000000000000000000..baceb2f6ff48cfb703798aaf4d278e64b64cb807 --- /dev/null +++ b/0001-bootstrap-move-all-of-rustc-s-flags-to-rustc_cargo.patch @@ -0,0 +1,200 @@ +From 56942ed6d13d330facddbd71470a3c115a3fe0d1 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Fri, 5 Apr 2024 15:07:58 -0700 +Subject: [PATCH] bootstrap: move all of rustc's flags to `rustc_cargo` + +This ensures that `RUSTFLAGS` will be consistent between all modes of +building the compiler, so they won't trigger a rebuild by cargo. This +kind of fix was started in #119414 just for LTO flags, but it's +applicable to all kinds of flags that might be configured. + +(cherry picked from commit e8fb8c36ca0de817b3d30f603d6d6b3c56e8b0be) +--- + src/bootstrap/src/core/build_steps/check.rs | 2 +- + src/bootstrap/src/core/build_steps/compile.rs | 107 +++++++++--------- + src/bootstrap/src/core/build_steps/doc.rs | 2 +- + src/bootstrap/src/core/build_steps/test.rs | 2 +- + 4 files changed, 59 insertions(+), 54 deletions(-) + +diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs +index 5f0afdb1b36c..dd866c2eb0f3 100644 +--- a/src/bootstrap/src/core/build_steps/check.rs ++++ b/src/bootstrap/src/core/build_steps/check.rs +@@ -263,7 +263,7 @@ fn run(self, builder: &Builder<'_>) { + target, + cargo_subcommand(builder.kind), + ); +- rustc_cargo(builder, &mut cargo, target, compiler.stage); ++ rustc_cargo(builder, &mut cargo, target, &compiler); + + // For ./x.py clippy, don't run with --all-targets because + // linting tests and benchmarks can produce very noisy results +diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs +index ddbe18ab8388..607a658617b5 100644 +--- a/src/bootstrap/src/core/build_steps/compile.rs ++++ b/src/bootstrap/src/core/build_steps/compile.rs +@@ -898,55 +898,10 @@ fn run(self, builder: &Builder<'_>) -> u32 { + )); + + let mut cargo = builder.cargo(compiler, Mode::Rustc, SourceType::InTree, target, "build"); +- rustc_cargo(builder, &mut cargo, target, compiler.stage); ++ rustc_cargo(builder, &mut cargo, target, &compiler); + +- if builder.config.rust_profile_use.is_some() +- && builder.config.rust_profile_generate.is_some() +- { +- panic!("Cannot use and generate PGO profiles at the same time"); +- } +- +- // With LLD, we can use ICF (identical code folding) to reduce the executable size +- // of librustc_driver/rustc and to improve i-cache utilization. +- // +- // -Wl,[link options] doesn't work on MSVC. However, /OPT:ICF (technically /OPT:REF,ICF) +- // is already on by default in MSVC optimized builds, which is interpreted as --icf=all: +- // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746 +- // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827 +- if builder.config.lld_mode.is_used() && !compiler.host.is_msvc() { +- cargo.rustflag("-Clink-args=-Wl,--icf=all"); +- } +- +- let is_collecting = if let Some(path) = &builder.config.rust_profile_generate { +- if compiler.stage == 1 { +- cargo.rustflag(&format!("-Cprofile-generate={path}")); +- // Apparently necessary to avoid overflowing the counters during +- // a Cargo build profile +- cargo.rustflag("-Cllvm-args=-vp-counters-per-site=4"); +- true +- } else { +- false +- } +- } else if let Some(path) = &builder.config.rust_profile_use { +- if compiler.stage == 1 { +- cargo.rustflag(&format!("-Cprofile-use={path}")); +- if builder.is_verbose() { +- cargo.rustflag("-Cllvm-args=-pgo-warn-missing-function"); +- } +- true +- } else { +- false +- } +- } else { +- false +- }; +- if is_collecting { +- // Ensure paths to Rust sources are relative, not absolute. +- cargo.rustflag(&format!( +- "-Cllvm-args=-static-func-strip-dirname-prefix={}", +- builder.config.src.components().count() +- )); +- } ++ // NB: all RUSTFLAGS should be added to `rustc_cargo()` so they will be ++ // consistently applied by check/doc/test modes too. + + for krate in &*self.crates { + cargo.arg("-p").arg(krate); +@@ -997,7 +952,12 @@ fn run(self, builder: &Builder<'_>) -> u32 { + } + } + +-pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelection, stage: u32) { ++pub fn rustc_cargo( ++ builder: &Builder<'_>, ++ cargo: &mut Cargo, ++ target: TargetSelection, ++ compiler: &Compiler, ++) { + cargo + .arg("--features") + .arg(builder.rustc_features(builder.kind)) +@@ -1008,7 +968,7 @@ pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelec + + // We currently don't support cross-crate LTO in stage0. This also isn't hugely necessary + // and may just be a time sink. +- if stage != 0 { ++ if compiler.stage != 0 { + match builder.config.rust_lto { + RustcLto::Thin | RustcLto::Fat => { + // Since using LTO for optimizing dylibs is currently experimental, +@@ -1034,7 +994,52 @@ pub fn rustc_cargo(builder: &Builder<'_>, cargo: &mut Cargo, target: TargetSelec + cargo.rustflag("-Clto=off"); + } + +- rustc_cargo_env(builder, cargo, target, stage); ++ // With LLD, we can use ICF (identical code folding) to reduce the executable size ++ // of librustc_driver/rustc and to improve i-cache utilization. ++ // ++ // -Wl,[link options] doesn't work on MSVC. However, /OPT:ICF (technically /OPT:REF,ICF) ++ // is already on by default in MSVC optimized builds, which is interpreted as --icf=all: ++ // https://github.com/llvm/llvm-project/blob/3329cec2f79185bafd678f310fafadba2a8c76d2/lld/COFF/Driver.cpp#L1746 ++ // https://github.com/rust-lang/rust/blob/f22819bcce4abaff7d1246a56eec493418f9f4ee/compiler/rustc_codegen_ssa/src/back/linker.rs#L827 ++ if builder.config.lld_mode.is_used() && !compiler.host.is_msvc() { ++ cargo.rustflag("-Clink-args=-Wl,--icf=all"); ++ } ++ ++ if builder.config.rust_profile_use.is_some() && builder.config.rust_profile_generate.is_some() { ++ panic!("Cannot use and generate PGO profiles at the same time"); ++ } ++ let is_collecting = if let Some(path) = &builder.config.rust_profile_generate { ++ if compiler.stage == 1 { ++ cargo.rustflag(&format!("-Cprofile-generate={path}")); ++ // Apparently necessary to avoid overflowing the counters during ++ // a Cargo build profile ++ cargo.rustflag("-Cllvm-args=-vp-counters-per-site=4"); ++ true ++ } else { ++ false ++ } ++ } else if let Some(path) = &builder.config.rust_profile_use { ++ if compiler.stage == 1 { ++ cargo.rustflag(&format!("-Cprofile-use={path}")); ++ if builder.is_verbose() { ++ cargo.rustflag("-Cllvm-args=-pgo-warn-missing-function"); ++ } ++ true ++ } else { ++ false ++ } ++ } else { ++ false ++ }; ++ if is_collecting { ++ // Ensure paths to Rust sources are relative, not absolute. ++ cargo.rustflag(&format!( ++ "-Cllvm-args=-static-func-strip-dirname-prefix={}", ++ builder.config.src.components().count() ++ )); ++ } ++ ++ rustc_cargo_env(builder, cargo, target, compiler.stage); + } + + pub fn rustc_cargo_env( +diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs +index 57e63927c95e..e10035f07c05 100644 +--- a/src/bootstrap/src/core/build_steps/doc.rs ++++ b/src/bootstrap/src/core/build_steps/doc.rs +@@ -794,7 +794,7 @@ fn run(self, builder: &Builder<'_>) { + cargo.rustdocflag("-Znormalize-docs"); + cargo.rustdocflag("--show-type-layout"); + cargo.rustdocflag("--generate-link-to-definition"); +- compile::rustc_cargo(builder, &mut cargo, target, compiler.stage); ++ compile::rustc_cargo(builder, &mut cargo, target, &compiler); + cargo.arg("-Zunstable-options"); + cargo.arg("-Zskip-rustdoc-fingerprint"); + +diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs +index 04728e2e00dc..c4fdda0a2606 100644 +--- a/src/bootstrap/src/core/build_steps/test.rs ++++ b/src/bootstrap/src/core/build_steps/test.rs +@@ -2558,7 +2558,7 @@ fn run(self, builder: &Builder<'_>) { + } + } + Mode::Rustc => { +- compile::rustc_cargo(builder, &mut cargo, target, compiler.stage); ++ compile::rustc_cargo(builder, &mut cargo, target, &compiler); + } + _ => panic!("can only test libraries"), + }; +-- +2.44.0 + diff --git a/0001-remove-stderr-per-bitwidth-from-some-tests.patch b/0001-remove-stderr-per-bitwidth-from-some-tests.patch new file mode 100644 index 0000000000000000000000000000000000000000..57a0c1f833d5da57d478e5eacd0b65361b8e3399 --- /dev/null +++ b/0001-remove-stderr-per-bitwidth-from-some-tests.patch @@ -0,0 +1,82 @@ +From 96e7b2767b30c215361d26626ef235f5ec0e8cd5 Mon Sep 17 00:00:00 2001 +From: Ralf Jung +Date: Fri, 16 Feb 2024 10:01:43 +0100 +Subject: [PATCH] remove stderr-per-bitwidth from some tests + +(cherry picked from commit f68e79dcac3acb635c58ff2fa4178b9a0b040fe4) +--- + ...ut_ref_in_final_dynamic_check.64bit.stderr | 20 ------------------- + .../mut_ref_in_final_dynamic_check.rs | 3 ++- + ... => mut_ref_in_final_dynamic_check.stderr} | 8 ++++---- + 3 files changed, 6 insertions(+), 25 deletions(-) + delete mode 100644 tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.64bit.stderr + rename tests/ui/consts/const-mut-refs/{mut_ref_in_final_dynamic_check.32bit.stderr => mut_ref_in_final_dynamic_check.stderr} (75%) + +diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.64bit.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.64bit.stderr +deleted file mode 100644 +index fc68207512c0..000000000000 +--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.64bit.stderr ++++ /dev/null +@@ -1,20 +0,0 @@ +-error[E0080]: it is undefined behavior to use this value +- --> $DIR/mut_ref_in_final_dynamic_check.rs:15:1 +- | +-LL | const A: Option<&mut i32> = helper(); +- | ^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered mutable reference in a `const` or `static` +- | +- = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. +- = note: the raw bytes of the constant (size: 8, align: 8) { +- 2a 00 00 00 00 00 00 00 │ *....... +- } +- +-error: encountered dangling pointer in final value of constant +- --> $DIR/mut_ref_in_final_dynamic_check.rs:22:1 +- | +-LL | const B: Option<&mut i32> = helper2(); +- | ^^^^^^^^^^^^^^^^^^^^^^^^^ +- +-error: aborting due to 2 previous errors +- +-For more information about this error, try `rustc --explain E0080`. +diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs +index 455b557b97c4..b98f4d920694 100644 +--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs ++++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs +@@ -1,4 +1,5 @@ +-// stderr-per-bitwidth ++// normalize-stderr-test "(the raw bytes of the constant) \(size: [0-9]*, align: [0-9]*\)" -> "$1 (size: $$SIZE, align: $$ALIGN)" ++// normalize-stderr-test "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?()?─*╼ )+ *│.*" -> "HEX_DUMP" + #![feature(const_mut_refs)] + #![feature(raw_ref_op)] + +diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.32bit.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr +similarity index 75% +rename from tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.32bit.stderr +rename to tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr +index 87420a037514..bb3c5518680b 100644 +--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.32bit.stderr ++++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr +@@ -1,16 +1,16 @@ + error[E0080]: it is undefined behavior to use this value +- --> $DIR/mut_ref_in_final_dynamic_check.rs:15:1 ++ --> $DIR/mut_ref_in_final_dynamic_check.rs:16:1 + | + LL | const A: Option<&mut i32> = helper(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at ..0: encountered mutable reference in a `const` or `static` + | + = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. +- = note: the raw bytes of the constant (size: 4, align: 4) { +- 2a 00 00 00 │ *... ++ = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) { ++ HEX_DUMP + } + + error: encountered dangling pointer in final value of constant +- --> $DIR/mut_ref_in_final_dynamic_check.rs:22:1 ++ --> $DIR/mut_ref_in_final_dynamic_check.rs:23:1 + | + LL | const B: Option<&mut i32> = helper2(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ +-- +2.44.0 + diff --git a/0001-test-don-t-compress-test-registry-crates.patch b/0001-test-don-t-compress-test-registry-crates.patch new file mode 100644 index 0000000000000000000000000000000000000000..60f2f275c93215c009dc17c384b694ac9b258f87 --- /dev/null +++ b/0001-test-don-t-compress-test-registry-crates.patch @@ -0,0 +1,185 @@ +From ed8e223cc58103cae0586351fd9113a727523cab Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Thu, 11 Apr 2024 14:58:42 -0700 +Subject: [PATCH] test: don't compress test registry crates + +They are still nominally gzipped, but using `Compression::none()` makes +them consistent even across zlib and zlib-ng, and this fixes checksum +differences in the testsuite. There is a one-time update of all those +checksums to catch up with this change though. + +(cherry picked from commit a70f23c50b61c1a3335f2943375a04ae7abf2fa4) +--- + crates/cargo-test-support/src/registry.rs | 2 +- + tests/testsuite/alt_registry.rs | 2 +- + .../cargo_add/locked_unchanged/in/Cargo.lock | 2 +- + .../cargo_add/lockfile_updated/in/Cargo.lock | 2 +- + .../cargo_add/lockfile_updated/out/Cargo.lock | 4 ++-- + .../cargo_remove/update_lock_file/in/Cargo.lock | 16 ++++++++-------- + .../cargo_remove/update_lock_file/out/Cargo.lock | 12 ++++++------ + 7 files changed, 20 insertions(+), 20 deletions(-) + +diff --git a/crates/cargo-test-support/src/registry.rs b/crates/cargo-test-support/src/registry.rs +index cc51707dbbf9..e27d1e354d7b 100644 +--- a/crates/cargo-test-support/src/registry.rs ++++ b/crates/cargo-test-support/src/registry.rs +@@ -1469,7 +1469,7 @@ impl Package { + let dst = self.archive_dst(); + t!(fs::create_dir_all(dst.parent().unwrap())); + let f = t!(File::create(&dst)); +- let mut a = Builder::new(GzEncoder::new(f, Compression::default())); ++ let mut a = Builder::new(GzEncoder::new(f, Compression::none())); + + if !self + .files +diff --git a/tests/testsuite/alt_registry.rs b/tests/testsuite/alt_registry.rs +index f286dc018122..42b818493244 100644 +--- a/tests/testsuite/alt_registry.rs ++++ b/tests/testsuite/alt_registry.rs +@@ -1466,7 +1466,7 @@ dependencies = [ + name = "foo" + version = "0.1.0" + source = "sparse+http://[..]/" +-checksum = "f6a200a9339fef960979d94d5c99cbbfd899b6f5a396a55d9775089119050203""#, ++checksum = "458c1addb23fde7dfbca0410afdbcc0086f96197281ec304d9e0e10def3cb899""#, + ); + } + +diff --git a/tests/testsuite/cargo_add/locked_unchanged/in/Cargo.lock b/tests/testsuite/cargo_add/locked_unchanged/in/Cargo.lock +index 011b335926ee..b88709a9e9be 100644 +--- a/tests/testsuite/cargo_add/locked_unchanged/in/Cargo.lock ++++ b/tests/testsuite/cargo_add/locked_unchanged/in/Cargo.lock +@@ -13,4 +13,4 @@ dependencies = [ + name = "my-package" + version = "99999.0.0+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "62c45acf9e11d2f97f5b318143219c0b4102eafef1c22a4b545b47104691d915" ++checksum = "73cfa03cf28feb001362b377a837910c5a6ec1cc5cceaa562b97fc14d15edec8" +diff --git a/tests/testsuite/cargo_add/lockfile_updated/in/Cargo.lock b/tests/testsuite/cargo_add/lockfile_updated/in/Cargo.lock +index d9bcc988d3f2..d8fa962f3069 100644 +--- a/tests/testsuite/cargo_add/lockfile_updated/in/Cargo.lock ++++ b/tests/testsuite/cargo_add/lockfile_updated/in/Cargo.lock +@@ -14,4 +14,4 @@ dependencies = [ + name = "unrelateed-crate" + version = "0.2.0+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "266de4849a570b5dfda5e8e082a2aff885e9d2d4965dae8f8b6c8535e1ec731f" ++checksum = "b16af1a8ba7e4331ca62d945483a3028c2afbbe06a7f2ffaa0a3538ef0a7d63e" +diff --git a/tests/testsuite/cargo_add/lockfile_updated/out/Cargo.lock b/tests/testsuite/cargo_add/lockfile_updated/out/Cargo.lock +index 4b5fb465f104..e423b3d1f8b7 100644 +--- a/tests/testsuite/cargo_add/lockfile_updated/out/Cargo.lock ++++ b/tests/testsuite/cargo_add/lockfile_updated/out/Cargo.lock +@@ -14,10 +14,10 @@ dependencies = [ + name = "my-package" + version = "99999.0.0+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "62c45acf9e11d2f97f5b318143219c0b4102eafef1c22a4b545b47104691d915" ++checksum = "73cfa03cf28feb001362b377a837910c5a6ec1cc5cceaa562b97fc14d15edec8" + + [[package]] + name = "unrelateed-crate" + version = "0.2.0+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "266de4849a570b5dfda5e8e082a2aff885e9d2d4965dae8f8b6c8535e1ec731f" ++checksum = "b16af1a8ba7e4331ca62d945483a3028c2afbbe06a7f2ffaa0a3538ef0a7d63e" +diff --git a/tests/testsuite/cargo_remove/update_lock_file/in/Cargo.lock b/tests/testsuite/cargo_remove/update_lock_file/in/Cargo.lock +index 2302220f2fb7..a4018e70eb47 100644 +--- a/tests/testsuite/cargo_remove/update_lock_file/in/Cargo.lock ++++ b/tests/testsuite/cargo_remove/update_lock_file/in/Cargo.lock +@@ -19,40 +19,40 @@ dependencies = [ + name = "clippy" + version = "0.4.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "47ced0eda54e9ddc6063f0e1d0164493cd16c84c6b6a0329a536967c44e205f7" ++checksum = "e95568c5ce98de9c470c1d9b387466f4d5efa9687d3af7998e7c9c1da5e399fb" + + [[package]] + name = "docopt" + version = "0.6.2+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "b600540c4fafb27bf6e6961f0f1e6f547c9d6126ce581ab3a92f878c8e2c9a2c" ++checksum = "d4414d2705e6b42fe10772b4ab4e3260f362669e45606eb562dc4c0023e911f6" + + [[package]] + name = "regex" + version = "0.1.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "84949cb53285a6c481d0133065a7b669871acfd9e20f273f4ce1283c309775d5" ++checksum = "bc4552a1d503f3a436bb18d1efff62eb95bd97f724d06466c55ef151ea2de9e0" + + [[package]] + name = "rustc-serialize" +-version = "0.4.1+my-package" ++version = "0.4.0+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "31162e7d23a085553c42dee375787b451a481275473f7779c4a63bcc267a24fd" ++checksum = "48c3645ec42f69a343fbe9734a477ae59448192e779206dbcb1a9c3397563fd8" + + [[package]] + name = "semver" + version = "0.1.1" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "106bee742e3199d9e59f4269e458dfc825c1b4648c483b1c2b7a45cd2610a308" ++checksum = "20070289360e74dcdc28f437b08dda0c0c861c2328d749bb0d6e1a428013af83" + + [[package]] + name = "serde" + version = "1.0.90" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "be7d269f612a60e3c2c4a4a120e2d878a3f3298a5285eda6e95453905a107d9a" ++checksum = "ba76b226746eabf28375d5ad184926bbb9cd727425c8d027ea10f6c508895c6c" + + [[package]] + name = "toml" + version = "0.1.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "a0f6c7804525ce0a968ef270e55a516cf4bdcf1fea0b09d130e0aa34a66745b3" ++checksum = "a9ea5fa6eaed7d7e6d9fb4571bb9d915b577e19bf2a95321ebb70fd3d894ce49" +diff --git a/tests/testsuite/cargo_remove/update_lock_file/out/Cargo.lock b/tests/testsuite/cargo_remove/update_lock_file/out/Cargo.lock +index 0946cee47717..af60414ddad2 100644 +--- a/tests/testsuite/cargo_remove/update_lock_file/out/Cargo.lock ++++ b/tests/testsuite/cargo_remove/update_lock_file/out/Cargo.lock +@@ -18,34 +18,34 @@ dependencies = [ + name = "clippy" + version = "0.4.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "47ced0eda54e9ddc6063f0e1d0164493cd16c84c6b6a0329a536967c44e205f7" ++checksum = "e95568c5ce98de9c470c1d9b387466f4d5efa9687d3af7998e7c9c1da5e399fb" + + [[package]] + name = "docopt" + version = "0.6.2+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "b600540c4fafb27bf6e6961f0f1e6f547c9d6126ce581ab3a92f878c8e2c9a2c" ++checksum = "d4414d2705e6b42fe10772b4ab4e3260f362669e45606eb562dc4c0023e911f6" + + [[package]] + name = "regex" + version = "0.1.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "84949cb53285a6c481d0133065a7b669871acfd9e20f273f4ce1283c309775d5" ++checksum = "bc4552a1d503f3a436bb18d1efff62eb95bd97f724d06466c55ef151ea2de9e0" + + [[package]] + name = "semver" + version = "0.1.1" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "106bee742e3199d9e59f4269e458dfc825c1b4648c483b1c2b7a45cd2610a308" ++checksum = "20070289360e74dcdc28f437b08dda0c0c861c2328d749bb0d6e1a428013af83" + + [[package]] + name = "serde" + version = "1.0.90" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "be7d269f612a60e3c2c4a4a120e2d878a3f3298a5285eda6e95453905a107d9a" ++checksum = "ba76b226746eabf28375d5ad184926bbb9cd727425c8d027ea10f6c508895c6c" + + [[package]] + name = "toml" + version = "0.1.1+my-package" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "a0f6c7804525ce0a968ef270e55a516cf4bdcf1fea0b09d130e0aa34a66745b3" ++checksum = "a9ea5fa6eaed7d7e6d9fb4571bb9d915b577e19bf2a95321ebb70fd3d894ce49" +-- +2.44.0 + diff --git a/0002-set-an-external-library-path-for-wasm32-wasi.patch b/0002-set-an-external-library-path-for-wasm32-wasi.patch new file mode 100644 index 0000000000000000000000000000000000000000..e2da2fe53612794766355ead2467b7d28f97a0f4 --- /dev/null +++ b/0002-set-an-external-library-path-for-wasm32-wasi.patch @@ -0,0 +1,78 @@ +From 79bb610c8fc5d9df7dd4720ae847b8f17e7b1ad4 Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Thu, 28 Sep 2023 18:18:16 -0700 +Subject: [PATCH 2/2] set an external library path for wasm32-wasi + +--- + compiler/rustc_codegen_ssa/src/back/link.rs | 9 +++++++++ + compiler/rustc_target/src/spec/mod.rs | 2 ++ + compiler/rustc_target/src/spec/targets/wasm32_wasi.rs | 6 +++++- + 3 files changed, 16 insertions(+), 1 deletion(-) + +diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs +index dd9d277fb775..3d0f0502f255 100644 +--- a/compiler/rustc_codegen_ssa/src/back/link.rs ++++ b/compiler/rustc_codegen_ssa/src/back/link.rs +@@ -1496,6 +1496,12 @@ fn get_object_file_path(sess: &Session, name: &str, self_contained: bool) -> Pat + return file_path; + } + } ++ if let Some(lib_path) = &sess.target.options.external_lib_path { ++ let file_path = Path::new(lib_path.as_ref()).join(name); ++ if file_path.exists() { ++ return file_path; ++ } ++ } + for search_path in fs.search_paths() { + let file_path = search_path.dir.join(name); + if file_path.exists() { +@@ -1982,6 +1988,9 @@ fn add_library_search_dirs(cmd: &mut dyn Linker, sess: &Session, self_contained: + let lib_path = sess.target_filesearch(PathKind::All).get_self_contained_lib_path(); + cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path)); + } ++ if let Some(lib_path) = &sess.target.options.external_lib_path { ++ cmd.include_path(Path::new(lib_path.as_ref())); ++ } + } + + /// Add options making relocation sections in the produced ELF files read-only +diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs +index f04799482c83..25410b37ba24 100644 +--- a/compiler/rustc_target/src/spec/mod.rs ++++ b/compiler/rustc_target/src/spec/mod.rs +@@ -1874,6 +1874,7 @@ pub struct TargetOptions { + /// Objects to link before and after all other object code. + pub pre_link_objects: CrtObjects, + pub post_link_objects: CrtObjects, ++ pub external_lib_path: Option>, + /// Same as `(pre|post)_link_objects`, but when self-contained linking mode is enabled. + pub pre_link_objects_self_contained: CrtObjects, + pub post_link_objects_self_contained: CrtObjects, +@@ -2352,6 +2353,7 @@ fn default() -> TargetOptions { + relro_level: RelroLevel::None, + pre_link_objects: Default::default(), + post_link_objects: Default::default(), ++ external_lib_path: None, + pre_link_objects_self_contained: Default::default(), + post_link_objects_self_contained: Default::default(), + link_self_contained: LinkSelfContainedDefault::False, +diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasi.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasi.rs +index 6dbcb01ea436..2151f86d0648 100644 +--- a/compiler/rustc_target/src/spec/targets/wasm32_wasi.rs ++++ b/compiler/rustc_target/src/spec/targets/wasm32_wasi.rs +@@ -86,7 +86,11 @@ pub fn target() -> Target { + options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained(); + + // FIXME: Figure out cases in which WASM needs to link with a native toolchain. +- options.link_self_contained = LinkSelfContainedDefault::True; ++ options.link_self_contained = LinkSelfContainedDefault::False; ++ ++ options.pre_link_objects = options.pre_link_objects_self_contained.clone(); ++ options.post_link_objects = options.post_link_objects_self_contained.clone(); ++ options.external_lib_path = Some("/usr/wasm32-wasi/lib/wasm32-wasi".into()); + + // Right now this is a bit of a workaround but we're currently saying that + // the target by default has a static crt which we're taking as a signal +-- +2.41.0 + diff --git a/0003-rustc-1.65.0-disable-libssh2.patch b/0003-rustc-1.65.0-disable-libssh2.patch deleted file mode 100644 index 24be1f3a5a859608ad9f7baddae055c1749c6c49..0000000000000000000000000000000000000000 --- a/0003-rustc-1.65.0-disable-libssh2.patch +++ /dev/null @@ -1,43 +0,0 @@ ---- rustc-beta-src/Cargo.lock.orig 2022-09-24 10:20:14.000000000 -0700 -+++ rustc-beta-src/Cargo.lock 2022-10-04 10:26:35.490270607 -0700 -@@ -1971,7 +1971,6 @@ - dependencies = [ - "cc", - "libc", -- "libssh2-sys", - "libz-sys", - "openssl-sys", - "pkg-config", -@@ -2004,20 +2003,6 @@ - ] - - [[package]] --name = "libssh2-sys" --version = "0.2.23" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "b094a36eb4b8b8c8a7b4b8ae43b2944502be3e59cd87687595cf6b0a71b3f4ca" --dependencies = [ -- "cc", -- "libc", -- "libz-sys", -- "openssl-sys", -- "pkg-config", -- "vcpkg", --] -- --[[package]] - name = "libz-sys" - version = "1.1.3" - source = "registry+https://github.com/rust-lang/crates.io-index" ---- rustc-beta-src/vendor/git2/Cargo.toml.orig 2022-10-04 10:26:35.490270607 -0700 -+++ rustc-beta-src/vendor/git2/Cargo.toml 2022-10-04 10:28:14.002187686 -0700 -@@ -58,9 +58,7 @@ - - [features] - default = [ -- "ssh", - "https", -- "ssh_key_from_memory", - ] - https = [ - "libgit2-sys/https", diff --git a/0004-rustc-1.69.0-disable-http2.patch b/0004-rustc-1.69.0-disable-http2.patch deleted file mode 100644 index 09e7930e2e77a1d3b56e5023f2e0ef9884097562..0000000000000000000000000000000000000000 --- a/0004-rustc-1.69.0-disable-http2.patch +++ /dev/null @@ -1,92 +0,0 @@ ---- rustc-beta-src/Cargo.lock.orig 2023-03-23 17:10:30.810989345 -0700 -+++ rustc-beta-src/Cargo.lock 2023-03-23 17:10:30.812989303 -0700 -@@ -1142,7 +1142,6 @@ - dependencies = [ - "cc", - "libc", -- "libnghttp2-sys", - "libz-sys", - "openssl-sys", - "pkg-config", -@@ -2375,16 +2374,6 @@ - checksum = "7fc7aa29613bd6a620df431842069224d8bc9011086b1db4c0e0cd47fa03ec9a" - - [[package]] --name = "libnghttp2-sys" --version = "0.1.4+1.41.0" --source = "registry+https://github.com/rust-lang/crates.io-index" --checksum = "03624ec6df166e79e139a2310ca213283d6b3c30810c54844f307086d4488df1" --dependencies = [ -- "cc", -- "libc", --] -- --[[package]] - name = "libz-sys" - version = "1.1.3" - source = "registry+https://github.com/rust-lang/crates.io-index" ---- rustc-beta-src/src/tools/cargo/Cargo.toml.orig 2023-03-23 17:10:30.812989303 -0700 -+++ rustc-beta-src/src/tools/cargo/Cargo.toml 2023-03-23 17:11:26.242836664 -0700 -@@ -23,7 +23,7 @@ - cargo-util = { path = "crates/cargo-util", version = "0.2.3" } - clap = "4.1.3" - crates-io = { path = "crates/crates-io", version = "0.36.0" } --curl = { version = "0.4.44", features = ["http2"] } -+curl = { version = "0.4.44", features = [] } - curl-sys = "0.4.59" - env_logger = "0.10.0" - filetime = "0.2.9" ---- rustc-beta-src/src/tools/cargo/src/cargo/core/package.rs.orig 2023-03-19 00:20:55.000000000 -0700 -+++ rustc-beta-src/src/tools/cargo/src/cargo/core/package.rs 2023-03-23 17:10:30.812989303 -0700 -@@ -401,16 +401,9 @@ - sources: SourceMap<'cfg>, - config: &'cfg Config, - ) -> CargoResult> { -- // We've enabled the `http2` feature of `curl` in Cargo, so treat -- // failures here as fatal as it would indicate a build-time problem. -- let mut multi = Multi::new(); -- let multiplexing = config.http_config()?.multiplexing.unwrap_or(true); -- multi -- .pipelining(false, multiplexing) -- .with_context(|| "failed to enable multiplexing/pipelining in curl")?; -- -- // let's not flood crates.io with connections -- multi.set_max_host_connections(2)?; -+ // Multiplexing is disabled because the system libcurl doesn't support it. -+ let multi = Multi::new(); -+ let multiplexing = false; - - Ok(PackageSet { - packages: package_ids ---- rustc-beta-src/src/tools/cargo/src/cargo/sources/registry/http_remote.rs.orig 2023-03-19 00:20:55.000000000 -0700 -+++ rustc-beta-src/src/tools/cargo/src/cargo/sources/registry/http_remote.rs 2023-03-23 17:10:30.813989282 -0700 -@@ -220,16 +220,8 @@ - } - self.fetch_started = true; - -- // We've enabled the `http2` feature of `curl` in Cargo, so treat -- // failures here as fatal as it would indicate a build-time problem. -- self.multiplexing = self.config.http_config()?.multiplexing.unwrap_or(true); -- -- self.multi -- .pipelining(false, self.multiplexing) -- .with_context(|| "failed to enable multiplexing/pipelining in curl")?; -- -- // let's not flood the server with connections -- self.multi.set_max_host_connections(2)?; -+ // Multiplexing is disabled because the system libcurl doesn't support it. -+ self.multiplexing = false; - - self.config - .shell() ---- rustc-beta-src/src/tools/cargo/src/cargo/util/network.rs.orig 2023-03-19 00:20:55.000000000 -0700 -+++ rustc-beta-src/src/tools/cargo/src/cargo/util/network.rs 2023-03-23 17:10:30.813989282 -0700 -@@ -116,7 +116,7 @@ - macro_rules! try_old_curl { - ($e:expr, $msg:expr) => { - let result = $e; -- if cfg!(target_os = "macos") { -+ if cfg!(any(target_os = "linux", target_os = "macos")) { - if let Err(e) = result { - warn!("ignoring libcurl {} error: {}", $msg, e); - } diff --git a/0005-Allow-using-external-builds-of-the-compiler-rt-profi.patch b/0005-Allow-using-external-builds-of-the-compiler-rt-profi.patch deleted file mode 100644 index 2dbdb269889bfd5daf0b846d59e48af5f9bf60ab..0000000000000000000000000000000000000000 --- a/0005-Allow-using-external-builds-of-the-compiler-rt-profi.patch +++ /dev/null @@ -1,141 +0,0 @@ -From f2fd2d01f96b50b039402c9ab4278230687f7922 Mon Sep 17 00:00:00 2001 -From: Josh Stone -Date: Tue, 25 Jul 2023 13:11:50 -0700 -Subject: [PATCH] Allow using external builds of the compiler-rt profile lib - -This changes the bootstrap config `target.*.profiler` from a plain bool -to also allow a string, which will be used as a path to the pre-built -profiling runtime for that target. Then `profiler_builtins/build.rs` -reads that in a `LLVM_PROFILER_RT_LIB` environment variable. ---- - config.example.toml | 6 ++++-- - library/profiler_builtins/build.rs | 6 ++++++ - src/bootstrap/compile.rs | 4 ++++ - src/bootstrap/config.rs | 30 ++++++++++++++++++++++++------ - 4 files changed, 38 insertions(+), 8 deletions(-) - -diff --git a/config.example.toml b/config.example.toml -index d0eaa9fd7ffa..e0e991e679af 100644 ---- a/config.example.toml -+++ b/config.example.toml -@@ -745,8 +745,10 @@ changelog-seen = 2 - # This option will override the same option under [build] section. - #sanitizers = build.sanitizers (bool) - --# Build the profiler runtime for this target(required when compiling with options that depend --# on this runtime, such as `-C profile-generate` or `-C instrument-coverage`). -+# When true, build the profiler runtime for this target(required when compiling -+# with options that depend on this runtime, such as `-C profile-generate` or -+# `-C instrument-coverage`). This may also be given a path to an existing build -+# of the profiling runtime library from LLVM's compiler-rt. - # This option will override the same option under [build] section. - #profiler = build.profiler (bool) - -diff --git a/library/profiler_builtins/build.rs b/library/profiler_builtins/build.rs -index 1b1f11798d74..d14d0b82229a 100644 ---- a/library/profiler_builtins/build.rs -+++ b/library/profiler_builtins/build.rs -@@ -6,6 +6,12 @@ - use std::path::Path; - - fn main() { -+ println!("cargo:rerun-if-env-changed=LLVM_PROFILER_RT_LIB"); -+ if let Ok(rt) = env::var("LLVM_PROFILER_RT_LIB") { -+ println!("cargo:rustc-link-lib=static:+verbatim={rt}"); -+ return; -+ } -+ - let target = env::var("TARGET").expect("TARGET was not set"); - let cfg = &mut cc::Build::new(); - -diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs -index 33addb90da37..1d8b3c6e5435 100644 ---- a/src/bootstrap/compile.rs -+++ b/src/bootstrap/compile.rs -@@ -305,6 +305,10 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car - cargo.env("MACOSX_DEPLOYMENT_TARGET", target); - } - -+ if let Some(path) = builder.config.profiler_path(target) { -+ cargo.env("LLVM_PROFILER_RT_LIB", path); -+ } -+ - // Determine if we're going to compile in optimized C intrinsics to - // the `compiler-builtins` crate. These intrinsics live in LLVM's - // `compiler-rt` repository, but our `src/llvm-project` submodule isn't -diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs -index e192cda9a9a7..a4803db0a470 100644 ---- a/src/bootstrap/config.rs -+++ b/src/bootstrap/config.rs -@@ -467,7 +467,7 @@ pub struct Target { - pub linker: Option, - pub ndk: Option, - pub sanitizers: Option, -- pub profiler: Option, -+ pub profiler: Option, - pub rpath: Option, - pub crt_static: Option, - pub musl_root: Option, -@@ -796,9 +796,9 @@ struct Dist { - } - } - --#[derive(Debug, Deserialize)] -+#[derive(Clone, Debug, Deserialize)] - #[serde(untagged)] --enum StringOrBool { -+pub enum StringOrBool { - String(String), - Bool(bool), - } -@@ -809,6 +809,12 @@ fn default() -> StringOrBool { - } - } - -+impl StringOrBool { -+ fn is_string_or_true(&self) -> bool { -+ matches!(self, Self::String(_) | Self::Bool(true)) -+ } -+} -+ - define_config! { - /// TOML representation of how the Rust build is configured. - struct Rust { -@@ -880,7 +886,7 @@ struct TomlTarget { - llvm_libunwind: Option = "llvm-libunwind", - android_ndk: Option = "android-ndk", - sanitizers: Option = "sanitizers", -- profiler: Option = "profiler", -+ profiler: Option = "profiler", - rpath: Option = "rpath", - crt_static: Option = "crt-static", - musl_root: Option = "musl-root", -@@ -1744,12 +1750,24 @@ pub fn any_sanitizers_enabled(&self) -> bool { - self.target_config.values().any(|t| t.sanitizers == Some(true)) || self.sanitizers - } - -+ pub fn profiler_path(&self, target: TargetSelection) -> Option<&str> { -+ match self.target_config.get(&target)?.profiler.as_ref()? { -+ StringOrBool::String(s) => Some(s), -+ StringOrBool::Bool(_) => None, -+ } -+ } -+ - pub fn profiler_enabled(&self, target: TargetSelection) -> bool { -- self.target_config.get(&target).map(|t| t.profiler).flatten().unwrap_or(self.profiler) -+ self.target_config -+ .get(&target) -+ .and_then(|t| t.profiler.as_ref()) -+ .map(StringOrBool::is_string_or_true) -+ .unwrap_or(self.profiler) - } - - pub fn any_profiler_enabled(&self) -> bool { -- self.target_config.values().any(|t| t.profiler == Some(true)) || self.profiler -+ self.target_config.values().any(|t| matches!(&t.profiler, Some(p) if p.is_string_or_true())) -+ || self.profiler - } - - pub fn rpath_enabled(&self, target: TargetSelection) -> bool { --- -2.41.0 diff --git a/0006-bootstrap-config-fix-version-comparison-bug.patch b/0006-bootstrap-config-fix-version-comparison-bug.patch deleted file mode 100644 index 1dc9d4e6908b052a8057b8710628e3851140c205..0000000000000000000000000000000000000000 --- a/0006-bootstrap-config-fix-version-comparison-bug.patch +++ /dev/null @@ -1,35 +0,0 @@ -From a627c8f54cab6880dc7d36c55092a94c6f750a6e Mon Sep 17 00:00:00 2001 -From: Ariadne Conill -Date: Thu, 3 Aug 2023 15:05:40 -0700 -Subject: [PATCH] bootstrap: config: fix version comparison bug - -Rust requires a previous version of Rust to build, such as the current version, or the -previous version. However, the version comparison logic did not take patch releases -into consideration when doing the version comparison for the current branch, e.g. -Rust 1.71.1 could not be built by Rust 1.71.0 because it is neither an exact version -match, or the previous version. - -Adjust the version comparison logic to tolerate mismatches in the patch version. - -Signed-off-by: Ariadne Conill -(cherry picked from commit 31a81a08786826cc6e832bd0b49fb8b934e29648) ---- - src/bootstrap/config.rs | 3 ++- - 1 file changed, 2 insertions(+), 1 deletion(-) - -diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs -index e192cda9a9a7..2b5d0b94e968 100644 ---- a/src/bootstrap/config.rs -+++ b/src/bootstrap/config.rs -@@ -1805,7 +1805,8 @@ pub fn check_build_rustc_version(&self) { - .unwrap(); - if !(source_version == rustc_version - || (source_version.major == rustc_version.major -- && source_version.minor == rustc_version.minor + 1)) -+ && (source_version.minor == rustc_version.minor -+ || source_version.minor == rustc_version.minor + 1))) - { - let prev_version = format!("{}.{}.x", source_version.major, source_version.minor - 1); - eprintln!( --- -2.41.0 diff --git a/0007-asm-Stabilize-loongarch64.patch b/0007-asm-Stabilize-loongarch64.patch deleted file mode 100644 index 9ee4e033910f68bd53deaddd7f07602fffdaa67d..0000000000000000000000000000000000000000 --- a/0007-asm-Stabilize-loongarch64.patch +++ /dev/null @@ -1,24 +0,0 @@ -From e7b292cf944a69a854f0264d9ac63de8ba7527af Mon Sep 17 00:00:00 2001 -From: WANG Rui -Date: Fri, 5 May 2023 14:20:45 +0800 -Subject: [PATCH] asm: Stabilize loongarch64 - ---- - compiler/rustc_ast_lowering/src/asm.rs | 1 + - 1 file changed, 1 insertion(+) - -diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs -index 941d3179..d350498b 100644 ---- a/compiler/rustc_ast_lowering/src/asm.rs -+++ b/compiler/rustc_ast_lowering/src/asm.rs -@@ -44,6 +44,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { - | asm::InlineAsmArch::AArch64 - | asm::InlineAsmArch::RiscV32 - | asm::InlineAsmArch::RiscV64 -+ | asm::InlineAsmArch::LoongArch64 - ); - if !is_stable && !self.tcx.features().asm_experimental_arch { - feature_err( --- -2.40.1 - diff --git a/120529.patch b/120529.patch new file mode 100644 index 0000000000000000000000000000000000000000..9e53295c3699f164e700ccd93d59b32ed866af19 --- /dev/null +++ b/120529.patch @@ -0,0 +1,62 @@ +From 8eb48b4f4c6e3d48f2600159a75184ec4d74b249 Mon Sep 17 00:00:00 2001 +From: Nikita Popov +Date: Wed, 31 Jan 2024 15:08:08 +0100 +Subject: [PATCH] Update data layouts in custom target tests for LLVM 18 + +Fixes https://github.com/rust-lang/rust/issues/120492. +--- + tests/run-make/rust-lld-custom-target/custom-target.json | 2 +- + tests/run-make/rustdoc-target-spec-json-path/target.json | 2 +- + tests/run-make/target-specs/my-awesome-platform.json | 2 +- + .../target-specs/my-x86_64-unknown-linux-gnu-platform.json | 2 +- + 4 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/tests/run-make/rust-lld-custom-target/custom-target.json b/tests/run-make/rust-lld-custom-target/custom-target.json +index 7828a99f235c1..e2c64cbdb43c2 100644 +--- a/tests/run-make/rust-lld-custom-target/custom-target.json ++++ b/tests/run-make/rust-lld-custom-target/custom-target.json +@@ -2,7 +2,7 @@ + "arch": "x86_64", + "cpu": "x86-64", + "crt-static-respected": true, +- "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", ++ "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", + "dynamic-linking": true, + "env": "gnu", + "has-rpath": true, +diff --git a/tests/run-make/rustdoc-target-spec-json-path/target.json b/tests/run-make/rustdoc-target-spec-json-path/target.json +index 34357182c205e..c478f1196fae0 100644 +--- a/tests/run-make/rustdoc-target-spec-json-path/target.json ++++ b/tests/run-make/rustdoc-target-spec-json-path/target.json +@@ -2,7 +2,7 @@ + "arch": "x86_64", + "cpu": "x86-64", + "crt-static-respected": true, +- "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", ++ "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", + "dynamic-linking": true, + "env": "gnu", + "executables": true, +diff --git a/tests/run-make/target-specs/my-awesome-platform.json b/tests/run-make/target-specs/my-awesome-platform.json +index 00de3de05f07a..1673ef7bd54d1 100644 +--- a/tests/run-make/target-specs/my-awesome-platform.json ++++ b/tests/run-make/target-specs/my-awesome-platform.json +@@ -1,5 +1,5 @@ + { +- "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128", ++ "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128", + "linker-flavor": "gcc", + "llvm-target": "i686-unknown-linux-gnu", + "target-endian": "little", +diff --git a/tests/run-make/target-specs/my-x86_64-unknown-linux-gnu-platform.json b/tests/run-make/target-specs/my-x86_64-unknown-linux-gnu-platform.json +index 6d5e964ed4fee..0cafce15a9fef 100644 +--- a/tests/run-make/target-specs/my-x86_64-unknown-linux-gnu-platform.json ++++ b/tests/run-make/target-specs/my-x86_64-unknown-linux-gnu-platform.json +@@ -1,6 +1,6 @@ + { + "pre-link-args": {"gcc": ["-m64"]}, +- "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", ++ "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", + "linker-flavor": "gcc", + "llvm-target": "x86_64-unknown-linux-gnu", + "target-endian": "little", diff --git a/121088.patch b/121088.patch new file mode 100644 index 0000000000000000000000000000000000000000..b70b52a78189eefcf4511dec9041f480ec292300 --- /dev/null +++ b/121088.patch @@ -0,0 +1,55 @@ +From 369fff6c0640fe89be9b915adaa83e66a022e00d Mon Sep 17 00:00:00 2001 +From: Nikita Popov +Date: Wed, 14 Feb 2024 16:26:20 +0100 +Subject: [PATCH] Implicitly enable evex512 if avx512 is enabled + +LLVM 18 requires the evex512 feature to allow use of zmm registers. +LLVM automatically sets it when using a generic CPU, but not when +`-C target-cpu` is specified. This will result either in backend +legalization crashes, or code unexpectedly using ymm instead of +zmm registers. + +For now, make sure that `avx512*` features imply `evex512`. Long +term we'll probably have to deal with the AVX10 mess somehow. +--- + compiler/rustc_codegen_llvm/src/llvm_util.rs | 4 ++++ + tests/ui/asm/x86_64/evex512-implicit-feature.rs | 15 +++++++++++++++ + 2 files changed, 19 insertions(+) + create mode 100644 tests/ui/asm/x86_64/evex512-implicit-feature.rs + +diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs +index e48479c8da279..54e8ed85e3250 100644 +--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs ++++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs +@@ -266,6 +266,10 @@ pub fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> { + ("riscv32" | "riscv64", "fast-unaligned-access") if get_version().0 <= 17 => { + LLVMFeature::new("unaligned-scalar-mem") + } ++ // For LLVM 18, enable the evex512 target feature if a avx512 target feature is enabled. ++ ("x86", s) if get_version().0 >= 18 && s.starts_with("avx512") => { ++ LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512")) ++ } + (_, s) => LLVMFeature::new(s), + } + } +diff --git a/tests/ui/asm/x86_64/evex512-implicit-feature.rs b/tests/ui/asm/x86_64/evex512-implicit-feature.rs +new file mode 100644 +index 0000000000000..a15060857eccb +--- /dev/null ++++ b/tests/ui/asm/x86_64/evex512-implicit-feature.rs +@@ -0,0 +1,15 @@ ++// build-pass ++// only-x86_64 ++// compile-flags: --crate-type=lib -C target-cpu=skylake ++ ++#![feature(avx512_target_feature)] ++#![feature(stdarch_x86_avx512)] ++ ++use std::arch::x86_64::*; ++ ++#[target_feature(enable = "avx512f")] ++#[no_mangle] ++pub unsafe fn test(res: *mut f64, p: *const f64) { ++ let arg = _mm512_load_pd(p); ++ _mm512_store_pd(res, _mm512_fmaddsub_pd(arg, arg, arg)); ++} diff --git a/bootstrap b/bootstrap deleted file mode 100644 index d4fd0f5d6c75149e1e75c0b0e67334f020c4975c..0000000000000000000000000000000000000000 --- a/bootstrap +++ /dev/null @@ -1,25 +0,0 @@ -%if %{with bootstrap} -%{lua: do - local bootstrap_arches = {} - for arch in string.gmatch(rpm.expand("%{bootstrap_arches}"), "%S+") do - table.insert(bootstrap_arches, arch) - end - local base = rpm.expand("https://static.rust-lang.org/dist/%{bootstrap_date}") - local channel = rpm.expand("%{bootstrap_version}") - local target_arch = rpm.expand("%{_target_cpu}") - for i, arch in ipairs(bootstrap_arches) do - i = 1000 + i * 3 - local suffix = channel.."-"..rust_triple(arch) - print(string.format("Source%d: %s/cargo-%s.tar.xz\n", i, base, suffix)) - print(string.format("Source%d: %s/rustc-%s.tar.xz\n", i+1, base, suffix)) - print(string.format("Source%d: %s/rust-std-%s.tar.xz\n", i+2, base, suffix)) - if arch == target_arch then - rpm.define("bootstrap_source_cargo "..i) - rpm.define("bootstrap_source_rustc "..i+1) - rpm.define("bootstrap_source_std "..i+2) - rpm.define("bootstrap_suffix "..suffix) - end - end -end} -%endif - diff --git a/cargo-config b/cargo-config deleted file mode 100644 index 621c190a45fb404035d3285a4737f691d7b119a2..0000000000000000000000000000000000000000 --- a/cargo-config +++ /dev/null @@ -1,5 +0,0 @@ -[source.crates-io] -replace-with = 'ustc' - -[source.ustc] -registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/" diff --git a/cargo-config.csh b/cargo-config.csh deleted file mode 100644 index 7613473719d1fdccdef429b66b565403a1caa799..0000000000000000000000000000000000000000 --- a/cargo-config.csh +++ /dev/null @@ -1,5 +0,0 @@ -# Copy cargo config from skel if it is not exist -if ( ! -e "$HOME/.cargo/config.toml" ) then - mkdir -p $HOME/.cargo - cp -f /etc/skel/.cargo/config.toml $HOME/.cargo -endif diff --git a/cargo-config.sh b/cargo-config.sh deleted file mode 100644 index 2338945be912705cafbb21934bdb7143098f4aab..0000000000000000000000000000000000000000 --- a/cargo-config.sh +++ /dev/null @@ -1,5 +0,0 @@ -# Copy cargo config from skel if it is not exist -if [ ! -f "$HOME/.cargo/config.toml" ] ; then - mkdir -p $HOME/.cargo - cp -f /etc/skel/.cargo/config.toml $HOME/.cargo -fi diff --git a/cargo_vendor.attr b/cargo_vendor.attr new file mode 100644 index 0000000000000000000000000000000000000000..be2d48fa12b6bb8dfe8279dcf87b8af921e8dbb0 --- /dev/null +++ b/cargo_vendor.attr @@ -0,0 +1,2 @@ +%__cargo_vendor_path ^%{_defaultlicensedir}(/[^/]+)+/cargo-vendor.txt$ +%__cargo_vendor_provides %{_rpmconfigdir}/cargo_vendor.prov diff --git a/cargo_vendor.prov b/cargo_vendor.prov new file mode 100755 index 0000000000000000000000000000000000000000..6efca18196800b99d4e172de25780e59706e2a66 --- /dev/null +++ b/cargo_vendor.prov @@ -0,0 +1,127 @@ +#! /usr/bin/python3 -s +# Stripped down replacement for cargo2rpm parse-vendor-manifest + +import re +import subprocess +import sys +from typing import Optional + + +VERSION_REGEX = re.compile( + r""" + ^ + (?P0|[1-9]\d*) + \.(?P0|[1-9]\d*) + \.(?P0|[1-9]\d*) + (?:-(?P
(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?
+    (?:\+(?P[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
+    """,
+    re.VERBOSE,
+)
+
+
+class Version:
+    """
+    Version that adheres to the "semantic versioning" format.
+    """
+
+    def __init__(self, major: int, minor: int, patch: int, pre: Optional[str] = None, build: Optional[str] = None):
+        self.major: int = major
+        self.minor: int = minor
+        self.patch: int = patch
+        self.pre: Optional[str] = pre
+        self.build: Optional[str] = build
+
+    @staticmethod
+    def parse(version: str) -> "Version":
+        """
+        Parses a version string and return a `Version` object.
+        Raises a `ValueError` if the string does not match the expected format.
+        """
+
+        match = VERSION_REGEX.match(version)
+        if not match:
+            raise ValueError(f"Invalid version: {version!r}")
+
+        matches = match.groupdict()
+
+        major_str = matches["major"]
+        minor_str = matches["minor"]
+        patch_str = matches["patch"]
+        pre = matches["pre"]
+        build = matches["build"]
+
+        major = int(major_str)
+        minor = int(minor_str)
+        patch = int(patch_str)
+
+        return Version(major, minor, patch, pre, build)
+
+    def to_rpm(self) -> str:
+        """
+        Formats the `Version` object as an equivalent RPM version string.
+        Characters that are invalid in RPM versions are replaced ("-" -> "_")
+
+        Build metadata (the optional `Version.build` attribute) is dropped, so
+        the conversion is not lossless for versions where this attribute is not
+        `None`. However, build metadata is not intended to be part of the
+        version (and is not even considered when doing version comparison), so
+        dropping it when converting to the RPM version format is correct.
+        """
+
+        s = f"{self.major}.{self.minor}.{self.patch}"
+        if self.pre:
+            s += f"~{self.pre.replace('-', '_')}"
+        return s
+
+
+def break_the_build(error: str):
+    """
+    This function writes a string that is an invalid RPM dependency specifier,
+    which causes dependency generators to fail and break the build. The
+    additional error message is printed to stderr.
+    """
+
+    print("*** FATAL ERROR ***")
+    print(error, file=sys.stderr)
+
+ 
+def get_cargo_vendor_txt_paths_from_stdin() -> set[str]:  # pragma nocover
+    """
+    Read lines from standard input and filter out lines that look like paths
+    to `cargo-vendor.txt` files. This is how RPM generators pass lists of files.
+    """
+
+    lines = {line.rstrip("\n") for line in sys.stdin.readlines()}
+    return {line for line in lines if line.endswith("/cargo-vendor.txt")}
+
+
+def action_parse_vendor_manifest():
+    paths = get_cargo_vendor_txt_paths_from_stdin()
+
+    for path in paths:
+        with open(path) as file:
+            manifest = file.read()
+
+        for line in manifest.strip().splitlines():
+            crate, version = line.split(" v")
+            print(f"bundled(crate({crate})) = {Version.parse(version).to_rpm()}")
+
+
+def main():
+    try:
+        action_parse_vendor_manifest()
+        exit(0)
+
+    # print an error message that is not a valid RPM dependency
+    # to cause the generator to break the build
+    except (IOError, ValueError) as exc:
+        break_the_build(str(exc))
+        exit(1)
+
+    break_the_build("Uncaught exception: This should not happen, please report a bug.")
+    exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/macros.rust-srpm b/macros.rust-srpm
new file mode 100644
index 0000000000000000000000000000000000000000..45287a8d5d218f51fc873c29d6d7f9052848898e
--- /dev/null
+++ b/macros.rust-srpm
@@ -0,0 +1,62 @@
+# rust_arches: list of architectures where building Rust is supported
+#
+# Since RPM itself now depends on Rust code (via its GPG backend, rpm-sequoia),
+# this list will probably always be a superset of all architectures that are
+# supported by Fedora, which is why it is no longer required to set
+# "ExclusiveArch: rust_arches" for Rust packages in Fedora.
+%rust_arches x86_64 %{ix86} armv7hl aarch64 ppc64 ppc64le riscv64 s390x
+
+# version_no_tilde: lua macro for reconstructing the original crate version
+#       from the RPM version (i.e. replace any "~" characters with "-")
+%version_no_tilde() %{lua:
+    local sep = rpm.expand('%1')
+    local ver = rpm.expand('%2')
+\
+    if sep == '%1' then
+        sep = '-'
+    end
+\
+    if ver == '%2' then
+        ver = rpm.expand('%version')
+    end
+    ver = ver:gsub('~', sep)
+\
+    print(ver)
+}
+
+# __crates_url: default API endpoint for downloading .crate files from crates.io
+%__crates_url https://crates.io/api/v1/crates/
+
+# crates_source: lua macro for constructing the Source URL for a crate
+%crates_source() %{lua:
+    local crate = rpm.expand('%1')
+    local version = rpm.expand('%2')
+    local url = rpm.expand('%__crates_url')
+\
+    -- first argument missing: fall back to %crate
+    if crate == '%1' then
+        crate = rpm.expand('%crate')
+    end
+    -- %crate macro not defined: fall back to %name
+    if crate == '%crate' then
+        crate = rpm.expand('%name')
+    end
+\
+    -- second argument missing: fall back to %crate_version
+    if version == '%2' then
+        version = rpm.expand('%crate_version')
+    end
+    -- %crate_version macro not defined: fall back to %version
+    if version == '%crate_version' then
+        version = rpm.expand('%version')
+    end
+    -- replace '~' with '-' for backwards compatibility
+    -- can be removed in the future
+    version = version:gsub('~', '-')
+\
+    print(url .. crate .. '/' .. version .. '/download#/' .. crate .. '-' .. version .. '.crate')
+}
+
+# __cargo_skip_build: unused macro, set to 0 for backwards compatibility
+%__cargo_skip_build 0
+
diff --git a/macros.rust-toolset b/macros.rust-toolset
index 41bb129e5c8eced23dfc086036f3aa16ae9521c9..396f6c360cedbace5214316f0477fb7a30f002d1 100644
--- a/macros.rust-toolset
+++ b/macros.rust-toolset
@@ -1,29 +1,100 @@
-# Explicitly use bindir tools, in case others are in the PATH,
-# like the rustup shims in a user's ~/.cargo/bin/.
-#
-# Since cargo 1.31, install only uses $CARGO_HOME/config, ignoring $PWD.
-#   https://github.com/rust-lang/cargo/issues/6397
-# But we can set CARGO_HOME locally, which is a good idea anyway to make sure
-# it never writes to ~/.cargo during rpmbuild.
-%__cargo %{_bindir}/env CARGO_HOME=.cargo %{_bindir}/cargo
-%__rustc %{_bindir}/rustc
-%__rustdoc %{_bindir}/rustdoc
-
-# Enable optimization, debuginfo, and link hardening.
-%__global_rustflags -Copt-level=3 -Cdebuginfo=2 -Clink-arg=-Wl,-z,relro,-z,now
-
-%__global_rustflags_toml [%{lua:
-    for arg in string.gmatch(rpm.expand("%{__global_rustflags}"), "%S+") do
-        print('"' .. arg .. '", ')
-    end}]
-
-%cargo_prep(V:) (\
-%{__mkdir} -p .cargo \
-cat > .cargo/config << EOF \
+# __rustc: path to the default rustc executable
+%__rustc /usr/bin/rustc
+
+# __rustdoc: path to the default rustdoc executable
+%__rustdoc /usr/bin/rustdoc
+
+# rustflags_opt_level: default optimization level
+#
+# It corresponds to the "-Copt-level" rustc command line option.
+%rustflags_opt_level 3
+
+# rustflags_debuginfo: default verbosity of debug information
+#
+# It corresponds to the "-Cdebuginfo" rustc command line option.
+# In some cases, it might be required to override this macro with "1" or even
+# "0", if memory usage gets too high during builds on some resource-constrained
+# architectures (most likely on 32-bit architectures), which will however
+# reduce the quality of the produced debug symbols.
+%rustflags_debuginfo 2
+
+# rustflags_codegen_units: default number of parallel code generation units
+#
+# The default value of "1" results in generation of better code, but comes at
+# the cost of longer build times.
+%rustflags_codegen_units 1
+
+# build_rustflags: default compiler flags for rustc (RUSTFLAGS)
+#
+# -Copt-level: set optimization level (default: highest optimization level)
+# -Cdebuginfo: set debuginfo verbosity (default: full debug information)
+# -Ccodegen-units: set number of parallel code generation units (default: 1)
+# -Cforce-frame-pointers: force inclusion of frame pointers (default: enabled
+#       on x86_64 and aarch64 on Fedora 37+)
+#
+# Additionally, some linker flags are set which correspond to the default
+# Fedora compiler flags for hardening and for embedding package versions into
+# compiled binaries.
+#
+# ref. https://doc.rust-lang.org/rustc/codegen-options/index.html
+%build_rustflags %{shrink:
+  -Copt-level=%rustflags_opt_level
+  -Cdebuginfo=%rustflags_debuginfo
+  -Ccodegen-units=%rustflags_codegen_units
+  -Cstrip=none
+  %{expr:0%{?_include_frame_pointers} && ("%{_arch}" != "ppc64le" && "%{_arch}" != "s390x" && "%{_arch}" != "i386") ? "-Cforce-frame-pointers=yes" : ""}
+  %[0%{?_package_note_status} ? "-Clink-arg=%_package_note_flags" : ""]
+}
+
+# __cargo: cargo command with environment variables
+#
+# CARGO_HOME: This ensures cargo reads configuration file from .cargo/config,
+#       and prevents writing any files to $HOME during RPM builds.
+%__cargo /usr/bin/env CARGO_HOME=.cargo RUSTFLAGS='%{build_rustflags}' /usr/bin/cargo
+
+# __cargo_common_opts: common command line flags for cargo
+#
+# _smp_mflags: run builds and tests in parallel
+%__cargo_common_opts %{?_smp_mflags}
+
+# cargo_prep: macro to set up build environment for cargo projects
+#
+# This involves four steps:
+# - create the ".cargo" directory if it doesn't exist yet
+# - dump custom cargo configuration into ".cargo/config"
+# - remove "Cargo.lock" if it exists (it breaks builds with custom cargo config)
+# - remove "Cargo.toml.orig" if it exists (it breaks running "cargo package")
+#
+# Options:
+#   -V     - unpack and use vendored sources from Source tarball
+#                    (deprecated; use -v instead)
+#   -v  - use vendored sources from 
+#   -N             - Don't set up any registry. Only set up the build configuration.
+%cargo_prep(V:v:N)\
+%{-v:%{-V:%{error:-v and -V are mutually exclusive!}}}\
+%{-v:%{-N:%{error:-v and -N are mutually exclusive!}}}\
+(\
+set -euo pipefail\
+%{__mkdir} -p target/rpm\
+/usr/bin/ln -s rpm target/release\
+%{__rm} -rf .cargo/\
+%{__mkdir} -p .cargo\
+cat > .cargo/config << EOF\
 [build]\
 rustc = "%{__rustc}"\
 rustdoc = "%{__rustdoc}"\
-rustflags = %{__global_rustflags_toml}\
+\
+[profile.rpm]\
+inherits = "release"\
+opt-level = %{rustflags_opt_level}\
+codegen-units = %{rustflags_codegen_units}\
+debug = %{rustflags_debuginfo}\
+strip = "none"\
+\
+[env]\
+CFLAGS = "%{build_cflags}"\
+CXXFLAGS = "%{build_cxxflags}"\
+LDFLAGS = "%{build_ldflags}"\
 \
 [install]\
 root = "%{buildroot}%{_prefix}"\
@@ -31,21 +102,155 @@ root = "%{buildroot}%{_prefix}"\
 [term]\
 verbose = true\
 EOF\
-%if 0%{-V:1}\
-%{__tar} -xoaf %{S:%{-V*}}\
-cat >> .cargo/config << EOF \
+%{-V:%{__tar} -xoaf %{S:%{-V*}}}\
+%{!?-N:\
+cat >> .cargo/config << EOF\
+[source.vendored-sources]\
+directory = "%{-v*}%{-V:./vendor}"\
 \
 [source.crates-io]\
+registry = "https://crates.io"\
 replace-with = "vendored-sources"\
-\
-[source.vendored-sources]\
-directory = "./vendor"\
-EOF\
-%endif\
+EOF}\
+%{__rm} -f Cargo.toml.orig\
 )
 
-%cargo_build %__cargo build --release %{?_smp_mflags}
+# __cargo_parse_opts: function-like macro which parses common flags into the
+#       equivalent command-line flags for cargo
+%__cargo_parse_opts(naf:) %{shrink:\
+    %{-n:%{-a:%{error:Can't specify both -n and -a}}}           \
+    %{-f:%{-a:%{error:Can't specify both -f(%{-f*}) and -a}}}   \
+    %{-n:--no-default-features}                                 \
+    %{-a:--all-features}                                        \
+    %{-f:--features %{-f*}}                                     \
+    %{nil}                                                      \
+}
+
+# cargo_build: builds the crate with cargo with the specified feature flags
+%cargo_build(naf:)\
+%{shrink:                                               \
+    %{__cargo} build                                    \
+    %{__cargo_common_opts}                              \
+    --profile rpm                                       \
+    %{__cargo_parse_opts %{-n} %{-a} %{-f:-f%{-f*}}}    \
+    %*                                                  \
+}
+
+# cargo_test: runs the test suite with cargo with the specified feature flags
+#
+# To pass command-line arguments to the cargo test runners directly (for
+# example, to skip certain tests during package builds), both the cargo_test
+# macro argument parsing and "cargo test" argument parsing need to be bypassed,
+# i.e. "%%cargo_test -- -- --skip foo" for skipping all tests with names that
+# match "foo".
+%cargo_test(naf:)\
+%{shrink:                                               \
+    %{__cargo} test                                     \
+    %{__cargo_common_opts}                              \
+    --profile rpm                                       \
+    --no-fail-fast                                      \
+    %{__cargo_parse_opts %{-n} %{-a} %{-f:-f%{-f*}}}    \
+    %*                                                  \
+}
 
-%cargo_test %__cargo test --release %{?_smp_mflags} --no-fail-fast
+# cargo_install: install files into the buildroot
+#
+# For "binary" crates, this macro installs all "bin" build targets to _bindir
+# inside the buildroot. The "--no-track" option prevents the creation of the
+# "$CARGO_HOME/.crates.toml" file, which is used to keep track of which version
+# of a specific binary has been installed, but which conflicts between builds
+# of different Rust applications and is not needed when building RPM packages.
+%cargo_install(t:naf:)\
+(\
+set -euo pipefail                                                   \
+  %{shrink:                                                         \
+    %{__cargo} install                                              \
+      %{__cargo_common_opts}                                        \
+      --profile rpm                                                 \
+      --no-track                                                    \
+      --path .                                                      \
+      %{__cargo_parse_opts %{-n} %{-a} %{-f:-f%{-f*}}}              \
+      %*                                                            \
+  }                                                                 \
+)
+
+# cargo_license: print license information for all crate dependencies
+#
+# The "no-build,no-dev,no-proc-macro" argument results in only crates which are
+# linked into the final binary to be considered.
+#
+# Additionally, deprecated SPDX syntax ("/" instead of "OR") is normalized
+# before sorting the results to ensure reproducible output of this macro.
+#
+# This macro must be called with the same feature flags as other cargo macros,
+# in particular, "cargo_build", otherwise its output will be incomplete.
+#
+# The "cargo tree" command called by this macro will fail if there are missing
+# (optional) dependencies.
+%cargo_license(naf:)\
+(\
+set -euo pipefail\
+%{shrink:                                                           \
+    %{__cargo} tree                                                 \
+    --workspace                                                     \
+    --offline                                                       \
+    --edges no-build,no-dev,no-proc-macro                           \
+    --no-dedupe                                                     \
+    %{__cargo_parse_opts %{-n} %{-a} %{-f:-f%{-f*}}}                \
+    --prefix none                                                   \
+    --format "{l}: {p}"                                             \
+    | sed -e "s: ($(pwd)[^)]*)::g" -e "s: / :/:g" -e "s:/: OR :g"   \
+    | sort -u                                                       \
+}\
+)
+
+# cargo_license_summary: print license summary for all crate dependencies
+#
+# This macro works in the same way as cargo_license, except that it only prints
+# a list of licenses, and not the complete license information for every crate
+# in the dependency tree. This is useful for determining the correct License
+# tag for packages that contain compiled Rust binaries.
+%cargo_license_summary(naf:)\
+(\
+set -euo pipefail\
+%{shrink:                                                           \
+    %{__cargo} tree                                                 \
+    --workspace                                                     \
+    --offline                                                       \
+    --edges no-build,no-dev,no-proc-macro                           \
+    --no-dedupe                                                     \
+    %{__cargo_parse_opts %{-n} %{-a} %{-f:-f%{-f*}}}                \
+    --prefix none                                                   \
+    --format "# {l}"                                                \
+    | sed -e "s: / :/:g" -e "s:/: OR :g"                            \
+    | sort -u                                                       \
+}\
+)
+
+# cargo_vendor_manifest: write list of vendored crates and their versions
+#
+# The arguments for the internal "cargo tree" call emulate the logic
+# that determines which crates are included when running "cargo vendor".
+# The results are written to "cargo-vendor.txt".
+#
+# TODO: --all-features may be overly broad; this should be modified to
+# use %%__cargo_parse_opts to handle feature flags.
+%cargo_vendor_manifest()\
+(\
+set -euo pipefail\
+%{shrink:                                                           \
+    %{__cargo} tree                                                 \
+    --workspace                                                     \
+    --offline                                                       \
+    --edges normal,build                                            \
+    --no-dedupe                                                     \
+    --all-features                                                  \
+    --prefix none                                                   \
+    --format "{p}"                                                  \
+    | grep -v "$(pwd)"                                              \
+    | sed -e "s: (proc-macro)::"                                    \
+    | sort -u                                                       \
+    > cargo-vendor.txt                                              \
+}\
+)
 
-%cargo_install %__cargo install --no-track --path .
diff --git a/rust.spec b/rust.spec
index b772ea56be731fa83bc472dcb59bf08f1d9094e0..85f276ed75e8bd6f92549897cb72b1dd00a4de91 100644
--- a/rust.spec
+++ b/rust.spec
@@ -1,497 +1,879 @@
-%define anolis_release 2
+%define anolis_release 1
+
+Name:           rust
+Version:        1.77.2
+Release:        %{anolis_release}%{?dist}
+Summary:        The Rust Programming Language
+License:        (Apache-2.0 OR MIT) AND (Artistic-2.0 AND BSD-3-Clause AND ISC AND MIT AND MPL-2.0 AND Unicode-DFS-2016)
+# ^ written as: (rust itself) and (bundled libraries)
+URL:            https://www.rust-lang.org
+
+# Only x86_64, i686, and aarch64 are Tier 1 platforms at this time.
+# https://doc.rust-lang.org/nightly/rustc/platform-support.html
 %global rust_arches x86_64 aarch64 loongarch64
-%global channel stable
-%global bootstrap_version 1.70.0
-%global bootstrap_date 2023-06-01
-%global __ranlib %{_bindir}/ranlib
-%global _privatelibs lib(.*-[[:xdigit:]]{16}*|rustc.*)[.]so.*
-%global __provides_exclude ^(%{_privatelibs})$
-%global __requires_exclude ^(%{_privatelibs})$
-%global __provides_exclude_from ^(%{_docdir}|%{rustlibdir}/src)/.*$
-%global __requires_exclude_from ^(%{_docdir}|%{rustlibdir}/src)/.*$
-%global _find_debuginfo_opts --keep-section .rustc
-%global common_libdir %{_prefix}/lib
-%global rustlibdir %{common_libdir}/rustlib
+ExclusiveArch:  %{rust_arches}
 
+# To bootstrap from scratch, set the channel and date from src/stage0.json
+# e.g. 1.59.0 wants rustc: 1.58.0-2022-01-13
+# or nightly wants some beta-YYYY-MM-DD
+%global bootstrap_version 1.76.0
+%global bootstrap_channel 1.76.0
+%global bootstrap_date 2024-02-08
+
+# Only the specified arches will use bootstrap binaries.
+# NOTE: Those binaries used to be uploaded with every new release, but that was
+# a waste of lookaside cache space when they're most often unused.
+# Run "spectool -g rust.spec" after changing this and then "fedpkg upload" to
+# add them to sources. Remember to remove them again after the bootstrap build!
+#global bootstrap_arches %%{rust_arches}
+
+# Define a space-separated list of targets to ship rust-std-static-$triple for
+# cross-compilation. The packages are noarch, but they're not fully
+# reproducible between hosts, so only x86_64 actually builds it.
 %ifarch x86_64
-%bcond_without wasm
-%endif
-
-%if %{with wasm}
+#%%global mingw_targets i686-pc-windows-gnu x86_64-pc-windows-gnu
 %global wasm_targets wasm32-unknown-unknown wasm32-wasi
+%global extra_targets x86_64-unknown-none x86_64-unknown-uefi
 %endif
-
+%global all_targets %{?wasm_targets} %{?extra_targets}
+#%%{?mingw_targets} %{?wasm_targets} %{?extra_targets}
+%define target_enabled() %{lua:
+  print(string.find(rpm.expand(" %{all_targets} "), rpm.expand(" %1 "), 1, true) or 0)
+}
+
+# We need CRT files for *-wasi targets, at least as new as the commit in
+# src/ci/docker/host-x86_64/dist-various-2/build-wasi-toolchain.sh
 %global wasi_libc_url https://github.com/WebAssembly/wasi-libc
-%global wasi_libc_ref wasi-sdk-20
+#global wasi_libc_ref wasi-sdk-21
+%global wasi_libc_ref 03b228e46bb02fcc5927253e1b8ad715072b1ae4
 %global wasi_libc_name wasi-libc-%{wasi_libc_ref}
 %global wasi_libc_source %{wasi_libc_url}/archive/%{wasi_libc_ref}/%{wasi_libc_name}.tar.gz
 %global wasi_libc_dir %{_builddir}/%{wasi_libc_name}
-
-%bcond_with bootstrap
-%bcond_with static
-%bcond_with cmake_path
+#%%bcond_with bundled_wasi_libc
+%bcond_without bundled_wasi_libc
+
+# Using llvm-static may be helpful as an opt-in, e.g. to aid LLVM rebases.
+%bcond_with llvm_static
+
+# We can also choose to just use Rust's bundled LLVM, in case the system LLVM
+# is insufficient.  Rust currently requires LLVM 15.0+.
+%global min_llvm_version 15.0.0
+%global bundled_llvm_version 17.0.6
+%bcond_with bundled_llvm
+
+# Requires stable libgit2 1.7, and not the next minor soname change.
+# This needs to be consistent with the bindings in vendor/libgit2-sys.
+%global min_libgit2_version 1.7.2
+%global next_libgit2_version 1.8.0~
+%global bundled_libgit2_version 1.7.2
 %bcond_with bundled_libgit2
-%bcond_without curl_http2
-%bcond_without lldb
-%bcond_without debug
-%bcond_without libssh2
+#%%bcond_without bundled_libgit2
 
-%global ligbit2_version 1.6.0
-%global next_ligbit2_version 1.7.0~
-%global libssh2_version 1.6.0
+# Disable cargo->libgit2->libssh2 on RHEL, as it's not approved for FIPS (rhbz1732949)
+#%%bcond_without disabled_libssh2
+%bcond_with disabled_libssh2
 
-%if %{without bootstrap}
-%bcond_with llvm_has_filecheck
+# Reduce rustc's own debuginfo and optimizations to conserve 32-bit memory.
+# e.g. https://github.com/rust-lang/rust/issues/45854
+%global reduced_debuginfo 0
+%if 0%{?__isa_bits} == 32
+%global reduced_debuginfo 1
+%endif
+# Also on current riscv64 hardware, although future hardware will be
+# able to handle it.
+# e.g. http://fedora.riscv.rocks/koji/buildinfo?buildID=249870
+%ifarch riscv64
+%global reduced_debuginfo 1
 %endif
 
-Name:           rust
-Version:        1.71.1
-Release:        %{anolis_release}%{?dist}
-Summary:        The Rust Programming Language
-License:        (ASL 2.0 or MIT) and (BSD and MIT)
-URL:            https://www.rust-lang.org
+%if 0%{?reduced_debuginfo}
+%global enable_debuginfo --debuginfo-level=0 --debuginfo-level-std=2
+%global enable_rust_opts --set rust.codegen-units-std=1
+%bcond_with rustc_pgo
+%else
+# Build rustc with full debuginfo, CGU=1, ThinLTO, and PGO.
+%global enable_debuginfo --debuginfo-level=2
+%global enable_rust_opts --set rust.codegen-units=1 --set rust.lto=thin
+%bcond_without rustc_pgo
+%endif
 
-Source0:        https://static.rust-lang.org/dist/rustc-%{version}-src.tar.xz
+# Detect non-stable channels from the version, like 1.74.0~beta.1
+%{lua: do
+  local version = rpm.expand("%{version}")
+  local version_channel, subs = string.gsub(version, "^.*~(%w+).*$", "%1", 1)
+  rpm.define("channel " .. (subs ~= 0 and version_channel or "stable"))
+  rpm.define("rustc_package rustc-" .. version_channel .. "-src")
+end}
+Source0:        https://static.rust-lang.org/dist/%{rustc_package}.tar.xz
 Source1:        %{wasi_libc_source}
+# Sources for bootstrap_arches are inserted by lua below
+
+# By default, rust tries to use "rust-lld" as a linker for some targets.
+Patch1:         0001-Use-lld-provided-by-system.patch
+
+# Set a substitute-path in rust-gdb for standard library sources.
+Patch2:         rustc-1.70.0-rust-gdb-substitute-path.patch
+
+# Override default target CPUs to match distro settings
+# TODO: upstream this ability into the actual build configuration
+Patch3:         0001-Let-environment-variables-override-some-default-CPUs.patch
+
+# Override the default self-contained system libraries
+# TODO: the first can probably be upstreamed, but the second is hard-coded,
+# and we're only applying that if not with bundled_wasi_libc.
+Patch4:         0001-bootstrap-allow-disabling-target-self-contained.patch
+Patch5:         0002-set-an-external-library-path-for-wasm32-wasi.patch
+
+# We don't want to use the bundled library in libsqlite3-sys
+Patch6:         rustc-1.77.0-unbundle-sqlite.patch
+
+# Backports of fixes for LLVM 18 compatibility
+Patch7:         120529.patch
+Patch8:         121088.patch
+
+# https://github.com/rust-lang/rust/pull/123520
+Patch9:         0001-bootstrap-move-all-of-rustc-s-flags-to-rustc_cargo.patch
+
+# https://github.com/rust-lang/rust/pull/123652
+Patch10:        0001-Fix-UI-tests-with-dist-vendored-dependencies.patch
+
+# https://github.com/rust-lang/rust/pull/121179 (partial)
+Patch11:        0001-remove-stderr-per-bitwidth-from-some-tests.patch
+
+# https://github.com/rust-lang/cargo/pull/13744
+Patch12:        0001-test-don-t-compress-test-registry-crates.patch
+
+# https://github.com/rust-lang/rust-clippy/pull/12682
+Patch13:        0001-The-multiple_unsafe_ops_per_block-test-needs-asm.patch
+
+# https://github.com/rust-lang/rust/pull/120676 (partial)
+Patch14:        0001-Step-all-bootstrap-cfgs-forward.patch
+
+### RHEL-specific patches below ###
+
+# Simple rpm macros for rust-toolset (as opposed to full rust-packaging)
 Source100:      macros.rust-toolset
-Source101:      cargo-config
-Source102:      cargo-config.sh
-Source103:      cargo-config.csh
-Source104:	bootstrap
-
-Patch0001:      0001-Use-lld-provided-by-system-for-wasm.patch
-Patch0002:      rustc-1.70.0-rust-gdb-substitute-path.patch
-Patch0003:      0003-rustc-1.65.0-disable-libssh2.patch
-Patch0004:      0004-rustc-1.69.0-disable-http2.patch
-Patch0005:      0005-Allow-using-external-builds-of-the-compiler-rt-profi.patch
-Patch0006:      0006-bootstrap-config-fix-version-comparison-bug.patch
-Patch0007:      0007-asm-Stabilize-loongarch64.patch
+Source101:      macros.rust-srpm
+Source102:      cargo_vendor.attr
+Source103:      cargo_vendor.prov
 
-ExclusiveArch:  %{rust_arches}
+# Disable cargo->libgit2->libssh2 on RHEL, as it's not approved for FIPS (rhbz1732949)
+Patch100:       rustc-1.77.0-disable-libssh2.patch
 
+# Get the Rust triple for any arch.
 %{lua: function rust_triple(arch)
-  return arch.."-unknown-linux-gnu"
+  local abi = "gnu"
+  return arch.."-unknown-linux-"..abi
 end}
 
 %global rust_triple %{lua: print(rust_triple(rpm.expand("%{_target_cpu}")))}
 
-BuildRequires:  make gcc gcc-c++ autoconf automake gdb clang lld
-BuildRequires:  glibc-static llvm-devel
-BuildRequires:  ncurses-devel curl-devel pkgconfig(libcurl) procps-ng
-BuildRequires:  pkgconfig(liblzma) pkgconfig(openssl) pkgconfig(zlib)
-BuildRequires:  python3 python3-rpm-macros procps-ng gdb
-BuildRequires:  git-core libxml2-devel compiler-rt
+# Get the environment form of the Rust triple
+%global rust_triple_env %{lua:
+  print(string.upper(string.gsub(rpm.expand("%{rust_triple}"), "-", "_")))
+}
+
+%if %defined bootstrap_arches
+# For each bootstrap arch, add an additional binary Source.
+# Also define bootstrap_source just for the current target.
+%{lua: do
+  local bootstrap_arches = {}
+  for arch in string.gmatch(rpm.expand("%{bootstrap_arches}"), "%S+") do
+    table.insert(bootstrap_arches, arch)
+  end
+  local base = rpm.expand("https://static.rust-lang.org/dist/%{bootstrap_date}")
+  local channel = rpm.expand("%{bootstrap_channel}")
+  local target_arch = rpm.expand("%{_target_cpu}")
+  for i, arch in ipairs(bootstrap_arches) do
+    i = 1000 + i * 3
+    local suffix = channel.."-"..rust_triple(arch)
+    print(string.format("Source%d: %s/cargo-%s.tar.xz\n", i, base, suffix))
+    print(string.format("Source%d: %s/rustc-%s.tar.xz\n", i+1, base, suffix))
+    print(string.format("Source%d: %s/rust-std-%s.tar.xz\n", i+2, base, suffix))
+    if arch == target_arch then
+      rpm.define("bootstrap_source_cargo "..i)
+      rpm.define("bootstrap_source_rustc "..i+1)
+      rpm.define("bootstrap_source_std "..i+2)
+      rpm.define("bootstrap_suffix "..suffix)
+    end
+  end
+end}
+%endif
+
+%ifarch %{bootstrap_arches}
+%global local_rust_root %{_builddir}/rust-%{bootstrap_suffix}
+Provides:       bundled(%{name}-bootstrap) = %{bootstrap_version}
+%else
+BuildRequires:  cargo 
+#>= %{bootstrap_version}
+BuildRequires:  (%{name} >= %{bootstrap_version} with %{name} <= %{version})
+%global local_rust_root %{_prefix}
+%endif
+
+BuildRequires:  make
+BuildRequires:  gcc
+BuildRequires:  gcc-c++
+BuildRequires:  ncurses-devel
+# explicit curl-devel to avoid httpd24-curl (rhbz1540167)
+BuildRequires:  curl-devel
+BuildRequires:  pkgconfig(libcurl)
+BuildRequires:  pkgconfig(liblzma)
+BuildRequires:  pkgconfig(openssl)
+BuildRequires:  pkgconfig(sqlite3)
+BuildRequires:  pkgconfig(zlib)
 
 %if %{without bundled_libgit2}
-BuildRequires:  (pkgconfig(libgit2) >= %{ligbit2_version} with pkgconfig(libgit2) < %{next_ligbit2_version})
+BuildRequires:  (pkgconfig(libgit2) >= %{min_libgit2_version} with pkgconfig(libgit2) < %{next_libgit2_version})
 %endif
 
-%if %{with libssh2}
-BuildRequires:  pkgconfig(libssh2) >= %{libssh2_version}
+%if %{without disabled_libssh2}
+BuildRequires:  pkgconfig(libssh2)
 %endif
 
-%if %{with bootstrap}
-%global local_rust_root %{_builddir}/rust-%{bootstrap_suffix}
-BuildRequires:  cmake3 >= 3.13.4 ninja-build
-Provides:       bundled(%{name}-bootstrap) = %{bootstrap_version}
-Provides:       bundled(llvm) = 15.0.6
+BuildRequires:  python3
+BuildRequires:  python3-rpm-macros
+
+%if %with bundled_llvm
+BuildRequires:  cmake >= 3.20.0
+BuildRequires:  ninja-build
+Provides:       bundled(llvm) = %{bundled_llvm_version}
+%else
+BuildRequires:  cmake >= 3.5.1
+%if %defined llvm
+%global llvm_root %{_libdir}/%{llvm}
 %else
+%global llvm llvm
 %global llvm_root %{_prefix}
-%global local_rust_root %{_prefix}
-BuildRequires:  cargo >= %{bootstrap_version} cmake >= 2.8.11
-BuildRequires:  (%{name} >= %{bootstrap_version} with %{name} <= %{version})
 %endif
-
-%if %{with static}
-BuildRequires:  llvm-static libffi-devel
+BuildRequires:  %{llvm}-devel >= %{min_llvm_version}
+%if %with llvm_static
+BuildRequires:  %{llvm}-static
+BuildRequires:  libffi-devel
+%endif
 %endif
 
-Requires:       %{name}-std-static = %{EVR} /usr/bin/cc
-Provides:       rustc = %{EVR}
+# make check needs "ps" for src/test/ui/wait-forked-but-failed-child.rs
+BuildRequires:  procps-ng
+
+# debuginfo-gdb tests need gdb
+BuildRequires:  gdb
+
+# For src/test/run-make/static-pie
+BuildRequires:  glibc-static
+
+# Virtual provides for folks who attempt "dnf install rustc"
+Provides:       rustc = %{version}-%{release}
 
-%if %{without wasm}
-Obsoletes:	rust-std-static-wasm32-wasi < %{EVR}
-Obsoletes:	rust-std-static-wasm32-unknown-unknown < %{EVR}
+# Always require our exact standard library
+Requires:       %{name}-std-static = %{version}-%{release}
+
+# The C compiler is needed at runtime just for linking.  Someday rustc might
+# invoke the linker directly, and then we'll only need binutils.
+# https://github.com/rust-lang/rust/issues/11937
+Requires:       /usr/bin/cc
+
+%global __ranlib %{_bindir}/ranlib
+
+# ALL Rust libraries are private, because they don't keep an ABI.
+%global _privatelibs lib(.*-[[:xdigit:]]{16}*|rustc.*)[.]so.*
+%global __provides_exclude ^(%{_privatelibs})$
+%global __requires_exclude ^(%{_privatelibs})$
+%global __provides_exclude_from ^(%{_docdir}|%{rustlibdir}/src)/.*$
+%global __requires_exclude_from ^(%{_docdir}|%{rustlibdir}/src)/.*$
+
+# While we don't want to encourage dynamic linking to Rust shared libraries, as
+# there's no stable ABI, we still need the unallocated metadata (.rustc) to
+# support custom-derive plugins like #[proc_macro_derive(Foo)].
+%global _find_debuginfo_opts --keep-section .rustc
+
+%if %{without bundled_llvm}
+%if "%{llvm_root}" == "%{_prefix}" || 0%{?scl:1}
+%global llvm_has_filecheck 1
+%endif
 %endif
 
-%if %{with wasm}
-BuildRequires:  clang lld
+# We're going to override --libdir when configuring to get rustlib into a
+# common path, but we'll fix the shared libraries during install.
+%global common_libdir %{_prefix}/lib
+%global rustlibdir %{common_libdir}/rustlib
+
+%if %defined wasm_targets
+%if %with bundled_wasi_libc
+BuildRequires:  clang
+%else
+BuildRequires:  wasi-libc-static
+%endif
+BuildRequires:  lld
+# brp-strip-static-archive breaks the archive index for wasm
 %global __os_install_post \
 %__os_install_post \
 find '%{buildroot}%{rustlibdir}'/wasm*/lib -type f -regex '.*\\.\\(a\\|rlib\\)' -print -exec '%{llvm_root}/bin/llvm-ranlib' '{}' ';' \
 %{nil}
 %endif
 
+# For profiler_builtins
+BuildRequires:  compiler-rt
+
 # This component was removed as of Rust 1.69.0.
 # https://github.com/rust-lang/rust/pull/101841
-Obsoletes:      %{name}-analysis < 1.69.0
+Obsoletes:      %{name}-analysis < 1.69.0~
 
 %description
-Rust is blazingly fast and memory-efficient: with no runtime or garbage collector, 
-it can power performance-critical services, run on embedded devices, and easily 
-integrate with other languages.
+Rust is a systems programming language that runs blazingly fast, prevents
+segfaults, and guarantees thread safety.
 
-%package -n cargo
-Summary:        Rust's package manager and build tool
-Requires:       %{name} = %{EVR}
-Provides:       cargo-vendor = %{EVR}
-Obsoletes:      cargo-vendor < %{EVR}
-%if %{with bundled_libgit2}
-Provides:       bundled(libgit2) = %{ligbit2_version}
+This package includes the Rust compiler and documentation generator.
+
+
+%package std-static
+Summary:        Standard library for Rust
+Provides:       %{name}-std-static-%{rust_triple} = %{version}-%{release}
+Requires:       %{name} = %{version}-%{release}
+Requires:       glibc-devel >= 2.17
+
+%description std-static
+This package includes the standard libraries for building applications
+written in Rust.
+
+%global target_package()                        \
+%package std-static-%1                          \
+Summary:        Standard library for Rust %1    \
+Requires:       %{name} = %{version}-%{release}
+
+%global target_description()                                            \
+%description std-static-%1                                              \
+This package includes the standard libraries for building applications  \
+written in Rust for the %2 target %1.
+
+%if %target_enabled wasm32-unknown-unknown
+%target_package wasm32-unknown-unknown
+Requires:       lld >= 8.0
+BuildArch:      noarch
+%target_description wasm32-unknown-unknown WebAssembly
 %endif
 
-%description -n cargo
-Cargo is a tool that allows Rust projects to declare their various dependencies
-and ensure that you'll always get a repeatable build.
+%if %target_enabled wasm32-wasi
+%target_package wasm32-wasi
+Requires:       lld >= 8.0
+%if %with bundled_wasi_libc
+Provides:       bundled(wasi-libc)
+%else
+Requires:       wasi-libc-static
+%endif
+BuildArch:      noarch
+%target_description wasm32-wasi WebAssembly
+%endif
 
-%package -n rustfmt
-Summary:        Tool to find and fix Rust formatting issues
-Requires:       cargo
-Provides:       rustfmt-preview = %{EVR}
-Obsoletes:      rustfmt-preview < %{EVR}
+%if %target_enabled x86_64-unknown-none
+%target_package x86_64-unknown-none
+Requires:       lld
+%target_description x86_64-unknown-none embedded
+%endif
+
+%if %target_enabled x86_64-unknown-uefi
+%target_package x86_64-unknown-uefi
+Requires:       lld
+%target_description x86_64-unknown-uefi embedded
+%endif
+
+
+%package debugger-common
+Summary:        Common debugger pretty printers for Rust
+BuildArch:      noarch
+
+%description debugger-common
+This package includes the common functionality for %{name}-gdb and %{name}-lldb.
 
-%description -n rustfmt
-A tool for formatting Rust code according to style guidelines.
 
 %package gdb
 Summary:        GDB pretty printers for Rust
-Requires:       %{name}-debugger-common = %{EVR} gdb
 BuildArch:      noarch
+Requires:       gdb
+Requires:       %{name}-debugger-common = %{version}-%{release}
 
 %description gdb
 This package includes the rust-gdb script, which allows easier debugging of Rust
 programs.
 
-%if %{with lldb}
+
 %package lldb
 Summary:        LLDB pretty printers for Rust
-Requires:       lldb python3-lldb
-Requires:       %{name}-debugger-common = %{EVR}
 BuildArch:      noarch
+Requires:       lldb
+Requires:       python3-lldb
+Requires:       %{name}-debugger-common = %{version}-%{release}
 
 %description lldb
 This package includes the rust-lldb script, which allows easier debugging of Rust
 programs.
+
+
+%package doc
+Summary:        Documentation for Rust
+# NOT BuildArch:      noarch
+# Note, while docs are mostly noarch, some things do vary by target_arch.
+# Koji will fail the build in rpmdiff if two architectures build a noarch
+# subpackage differently, so instead we have to keep its arch.
+
+# Cargo no longer builds its own documentation
+# https://github.com/rust-lang/cargo/pull/4904
+# We used to keep a shim cargo-doc package, but now that's merged too.
+Obsoletes:      cargo-doc < 1.65.0~
+Provides:       cargo-doc = %{version}-%{release}
+
+%description doc
+This package includes HTML documentation for the Rust programming language and
+its standard library.
+
+
+%package -n cargo
+Summary:        Rust's package manager and build tool
+%if %with bundled_libgit2
+Provides:       bundled(libgit2) = %{bundled_libgit2_version}
 %endif
+# For tests:
+BuildRequires:  git-core
+# Cargo is not much use without Rust
+Requires:       %{name}
+
+# "cargo vendor" is a builtin command starting with 1.37.  The Obsoletes and
+# Provides are mostly relevant to RHEL, but harmless to have on Fedora/etc. too
+Obsoletes:      cargo-vendor <= 0.1.23
+Provides:       cargo-vendor = %{version}-%{release}
+
+%description -n cargo
+Cargo is a tool that allows Rust projects to declare their various dependencies
+and ensure that you'll always get a repeatable build.
+
+
+%package -n rustfmt
+Summary:        Tool to find and fix Rust formatting issues
+Requires:       cargo
+
+# /usr/bin/rustfmt is dynamically linked against internal rustc libs
+Requires:       %{name} = %{version}-%{release}
+
+# The component/package was rustfmt-preview until Rust 1.31.
+Obsoletes:      rustfmt-preview < 1.0.0
+Provides:       rustfmt-preview = %{version}-%{release}
+
+%description -n rustfmt
+A tool for formatting Rust code according to style guidelines.
+
 
 %package analyzer
 Summary:        Rust implementation of the Language Server Protocol
-Recommends:     %{name}-src = %{EVR}
-Obsoletes:      rls < %{EVR} rls-preview < %{EVR}
+
+# The standard library sources are needed for most functionality.
+Recommends:     %{name}-src
+
+# RLS is no longer available as of Rust 1.65, but we're including the stub
+# binary that implements LSP just enough to recommend rust-analyzer.
+Obsoletes:      rls < 1.65.0~
+# The component/package was rls-preview until Rust 1.31.
+Obsoletes:      rls-preview < 1.31.6
 
 %description analyzer
 rust-analyzer is an implementation of Language Server Protocol for the Rust
 programming language. It provides features like completion and goto definition
 for many code editors, including VS Code, Emacs and Vim.
 
+
 %package -n clippy
 Summary:        Lints to catch common mistakes and improve your Rust code
-Requires:       cargo %{name} = %{EVR}
-Provides:       clippy-preview = %{EVR}
-Obsoletes:      clippy-preview < %{EVR}
+Requires:       cargo
+# /usr/bin/clippy-driver is dynamically linked against internal rustc libs
+Requires:       %{name} = %{version}-%{release}
+
+# The component/package was clippy-preview until Rust 1.31.
+Obsoletes:      clippy-preview <= 0.0.212
+Provides:       clippy-preview = %{version}-%{release}
 
 %description -n clippy
 A collection of lints to catch common mistakes and improve your Rust code.
 
+
 %package src
 Summary:        Sources for the Rust standard library
-Recommends:     %{name}-std-static = %{EVR}
 BuildArch:      noarch
+Recommends:     %{name}-std-static = %{version}-%{release}
 
 %description src
 This package includes source files for the Rust standard library.  It may be
 useful as a reference for code completion tools in various editors.
 
-%package toolset
-Summary:        Rust Toolset
-Requires:       rust = %{EVR} cargo = %{EVR}
-Buildarch:      noarch
 
-%description toolset
-This is the metapackage for Rust Toolset, bringing in the Rust compiler,
-the Cargo package manager, and a few convenience macros for rpm builds.
-
-%package std-static
-Summary:        Standard library for Rust
-Requires:       %{name} = %{EVR}
-Requires:       glibc-devel >= 2.17
-Provides:       %{name}-std-static-%{rust_triple} = %{EVR}
-
-%description std-static
-This package includes the standard libraries for building applications
-written in Rust.
+#%%if 0%{?rhel}
 
-%if %{with wasm}
-%package std-static-wasm32-unknown-unknown
-Summary:        Standard library for Rust wasm32-unknown-unknown
-Requires: 	%{name} = %{EVR} lld >= 8.0
+%package srpm-macros
+Summary:        RPM macros for building Rust source packages
 BuildArch:      noarch
 
-%description std-static-wasm32-unknown-unknown
-This package includes the standard libraries for building applications
-written in Rust for the WebAssembly target wasm32-unknown-unknown
-
-%package std-static-wasm32-wasi
-Summary:        Standard library for Rust wasm32-wasi
-Requires:       %{name} = %{EVR} lld >= 8.0
-Provides:	bundled(wasi-libc)
-BuildArch:      noarch
+%description srpm-macros
+RPM macros for building source packages for Rust projects.
 
-%description std-static-wasm32-wasi
-This package includes the standard libraries for building applications
-written in Rust for the WebAssembly target wasm32-wasi
-%endif
 
-%package debugger-common
-Summary:        Common debugger pretty printers for Rust
+%package toolset
+Summary:        Rust Toolset
 BuildArch:      noarch
+Requires:       rust = %{version}-%{release}
+Requires:       cargo = %{version}-%{release}
 
-%description debugger-common
-This package includes the common functionality for %{name}-gdb and %{name}-lldb.
-
-%package doc
-# This package can not set the noarch
-Summary:        Documentation for Rust
-Requires:	%{name} = %{EVR}
-Provides:       cargo-doc = %{EVR}
-Obsoletes:      cargo-doc < %{EVR}
+%description toolset
+This is the metapackage for Rust Toolset, bringing in the Rust compiler,
+the Cargo package manager, and a few convenience macros for rpm builds.
 
-%description doc
-This package includes HTML documentation for the Rust programming language and
-its standard library.
+#%%endif
 
-%if %{with bootstrap}
-%include %{SOURCE4}
-%endif
 
 %prep
-%if %{with bootstrap}
+
+%ifarch %{bootstrap_arches}
 rm -rf %{local_rust_root}
-for d_src in %{bootstrap_source_cargo} %{bootstrap_source_rustc} %{bootstrap_source_std}; do:
-  %setup -q -n cargo-%{bootstrap_suffix} -T -b %{d_src}
-  ./install.sh --prefix=%{local_rust_root} --disable-ldconfig
-done
+%setup -q -n cargo-%{bootstrap_suffix} -T -b %{bootstrap_source_cargo}
+./install.sh --prefix=%{local_rust_root} --disable-ldconfig
+%setup -q -n rustc-%{bootstrap_suffix} -T -b %{bootstrap_source_rustc}
+./install.sh --prefix=%{local_rust_root} --disable-ldconfig
+%setup -q -n rust-std-%{bootstrap_suffix} -T -b %{bootstrap_source_std}
+./install.sh --prefix=%{local_rust_root} --disable-ldconfig
 test -f '%{local_rust_root}/bin/cargo'
 test -f '%{local_rust_root}/bin/rustc'
 %endif
 
-%if %{with wasm}
+%if %{defined wasm_targets} && %{with bundled_wasi_libc}
 %setup -q -n %{wasi_libc_name} -T -b 1
+rm -rf %{wasi_libc_dir}/dlmalloc/
 %endif
 
-%setup -q -n rustc-%{version}-src
-%patch -P0001 -p1
-%patch -P0002 -p1
+%setup -q -n %{rustc_package}
 
-%if %{without libssh2}
-%patch -P0003 -p1
+%patch -P1 -p1
+%patch -P2 -p1
+%patch -P3 -p1
+%patch -P4 -p1
+%if %without bundled_wasi_libc
+%patch -P5 -p1
 %endif
+%patch -P6 -p1
 
-%if %{without curl_http2}
-%patch -P0004 -p1
-rm -rf vendor/libnghttp2-sys/
-%endif
+%patch -P7 -p1
+%patch -P8 -p1
+%patch -P9 -p1
+%patch -P10 -p1
+%patch -P11 -p1
+%patch -P12 -p1 -d src/tools/cargo
+%patch -P13 -p1 -d src/tools/clippy
+%patch -P14 -p1
 
-%patch -P0005 -p1
-%patch -P0006 -p1
-%patch -P0007 -p1
 
+%if %with disabled_libssh2
+%patch -P100 -p1
+%endif
+
+# Use our explicit python3 first
 sed -i.try-python -e '/^try python3 /i try "%{__python3}" "$@"' ./configure
+
+# Set a substitute-path in rust-gdb for standard library sources.
 sed -i.rust-src -e "s#@BUILDDIR@#$PWD#" ./src/etc/rust-gdb
 
-%if %{without bootstrap}
+%if %without bundled_llvm
 rm -rf src/llvm-project/
 mkdir -p src/llvm-project/libunwind/
 %endif
 
-%if %{without bundled_libgit2}
-rm -rf vendor/libgit2-sys/libgit2/
-%endif
 
-%if %{without libssh2}
-rm -rf vendor/libssh2-sys/
+# Remove other unused vendored libraries. This leaves the directory in place,
+# because some build scripts watch them, e.g. "cargo:rerun-if-changed=curl".
+%define clear_dir() find ./%1 -mindepth 1 -delete
+%clear_dir vendor/curl-sys*/curl/
+%clear_dir vendor/*jemalloc-sys*/jemalloc/
+%clear_dir vendor/libffi-sys*/libffi/
+%clear_dir vendor/libmimalloc-sys*/c_src/mimalloc/
+%clear_dir vendor/libsqlite3-sys*/{sqlite3,sqlcipher}/
+%clear_dir vendor/libssh2-sys*/libssh2/
+%clear_dir vendor/libz-sys*/src/zlib{,-ng}/
+%clear_dir vendor/lzma-sys*/xz-*/
+%clear_dir vendor/openssl-src*/openssl/
+
+%if %without bundled_libgit2
+%clear_dir vendor/libgit2-sys*/libgit2/
 %endif
 
-pushd vendor
-rm -rf curl-sys/curl/
-rm -rf *jemalloc-sys*/jemalloc/
-rm -rf libmimalloc-sys/c_src/mimalloc/
-rm -rf libssh2-sys/libssh2/
-rm -rf libz-sys/src/zlib/
-rm -rf libz-sys/src/zlib-ng/
-rm -rf lzma-sys/xz-*/
-rm -rf openssl-src/openssl/
-popd
+%if %with disabled_libssh2
+rm -rf vendor/libssh2-sys*/
+%endif
 
-sed -i.lzma -e '/LZMA_API_STATIC/d' src/bootstrap/tool.rs
+# This only affects the transient rust-installer, but let it use our dynamic xz-libs
+sed -i.lzma -e '/LZMA_API_STATIC/d' src/bootstrap/src/core/build_steps/tool.rs
 
-%if %{without bootstrap} && %{with static}
+%if %{without bundled_llvm} && %{with llvm_static}
+# Static linking to distro LLVM needs to add -lffi
+# https://github.com/rust-lang/rust/issues/34486
 sed -i.ffi -e '$a #[link(name = "ffi")] extern {}' \
   compiler/rustc_llvm/src/lib.rs
 %endif
 
+# The configure macro will modify some autoconf-related files, which upsets
+# cargo when it tries to verify checksums in those files.  If we just truncate
+# that file list, cargo won't have anything to complain about.
 find vendor -name .cargo-checksum.json \
   -exec sed -i.uncheck -e 's/"files":{[^}]*}/"files":{ }/' '{}' '+'
 
+# Sometimes Rust sources start with #![...] attributes, and "smart" editors think
+# it's a shebang and make them executable. Then brp-mangle-shebangs gets upset...
 find -name '*.rs' -type f -perm /111 -exec chmod -v -x '{}' '+'
 
-%if %{defined build_rustflags}
-%global build_rustflags %{nil}            
+# The distro flags are only appropriate for the host, not our cross-targets,
+# and they're not as fine-grained as the settings we choose for std vs rustc.
+%if %defined build_rustflags
+%global build_rustflags %{nil}
 %endif
 
-%global rust_env %{?rustflags:RUSTFLAGS="%{rustflags}"}
-%if %{with cmake_path}
-%global rust_env %{?rust_env} PATH="%{cmake_path}:$PATH"
-%endif
-%if %{with libssh2}
-%global rust_env %{?rust_env} LIBSSH2_SYS_USE_PKG_CONFIG=1
-%endif
-%global export_rust_env %{?rust_env:export %{rust_env}}
+# These are similar to __cflags_arch_* in /usr/lib/rpm/redhat/macros
+%global rustc_target_cpus %{lua: do
+  local env =
+    " RUSTC_TARGET_CPU_X86_64=x86-64" .. ""
+  print(env)
+end}
+
+# Set up shared environment variables for build/install/check.
+# *_USE_PKG_CONFIG=1 convinces *-sys crates to use the system library.
+%global rust_env %{shrink:
+  %{?rustflags:RUSTFLAGS="%{rustflags}"}
+  %{rustc_target_cpus}
+  LIBSQLITE3_SYS_USE_PKG_CONFIG=1
+  %{!?with_disabled_libssh2:LIBSSH2_SYS_USE_PKG_CONFIG=1}
+}
+%global export_rust_env export %{rust_env}
 
 %build
 %{export_rust_env}
 
+# Some builders have relatively little memory for their CPU count.
+# At least 2GB per CPU is a good rule of thumb for building rustc.
 ncpus=$(/usr/bin/getconf _NPROCESSORS_ONLN)
 max_cpus=$(( ($(free -g | awk '/^Mem:/{print $2}') + 1) / 2 ))
 if [ "$max_cpus" -ge 1 -a "$max_cpus" -lt "$ncpus" ]; then
   ncpus="$max_cpus"
 fi
 
-%if %{with wasm}
-%make_build --quiet -C %{wasi_libc_dir} CC=clang AR=llvm-ar NM=llvm-nm
+%if %defined wasm_targets
+%if %with bundled_wasi_libc
+%make_build --quiet -C %{wasi_libc_dir} MALLOC_IMPL=emmalloc CC=clang AR=llvm-ar NM=llvm-nm
+%define wasm_target_config --set target.wasm32-wasi.wasi-root=%{wasi_libc_dir}/sysroot
+%else
+%define wasm_target_config %{shrink:
+  --set target.wasm32-wasi.wasi-root=%{_prefix}/wasm32-wasi
+  --set target.wasm32-wasi.self-contained=false
+}
+%endif
 %endif
 
-PROFILER=$(find %{_libdir}/clang -type f -name 'libclang_rt.profile-*.a')       
+# Find the compiler-rt library for the Rust profiler_builtins crate.
+%if 0%{?clang_major_version} >= 17
+%define profiler %{clang_resource_dir}/lib/%{_arch}-redhat-linux-gnu/libclang_rt.profile.a
+%else
+# The exact profiler path is version dependent..
+%define profiler %(echo %{_libdir}/clang/??/lib/libclang_rt.profile-*.a)
+%endif
+test -r "%{profiler}"
 
-%configure --disable-option-checking --libdir=%{common_libdir} \
+%configure --disable-option-checking \
+  --libdir=%{common_libdir} \
   --build=%{rust_triple} --host=%{rust_triple} --target=%{rust_triple} \
-  --set target.%{rust_triple}.linker=%{__cc} --set target.%{rust_triple}.cc=%{__cc} \
-  --set target.%{rust_triple}.cxx=%{__cxx} --set target.%{rust_triple}.ar=%{__ar} \
+  --set target.%{rust_triple}.linker=%{__cc} \
+  --set target.%{rust_triple}.cc=%{__cc} \
+  --set target.%{rust_triple}.cxx=%{__cxx} \
+  --set target.%{rust_triple}.ar=%{__ar} \
   --set target.%{rust_triple}.ranlib=%{__ranlib} \
-  ${PROFILER:+--set target.%{rust_triple}.profiler="$PROFILER"} \
-%if %{with wasm}
-  --set target.wasm32-wasi.wasi-root=%{wasi_libc_dir}/sysroot \
-%endif
-  %{?wasm_target_config} --python=%{__python3} --local-rust-root=%{local_rust_root} \
-  --set build.rustfmt=/bin/true --disable-llvm-static-stdcpp \
-%if %{without bootstrap}
-  --llvm-root=%{llvm_root} \
-%endif
-%if %{without llvm_has_filecheck}
-    --disable-codegen-tests \
-%endif
-%if %{without static}
-    --enable-llvm-link-shared \
-%endif
-%if %{with debug}
-  --debuginfo-level=2 \
-%endif
-  --set rust.codegen-units-std=1 --set build.build-stage=2 \
-  --set build.doc-stage=2 --set build.install-stage=2 \
-  --set build.test-stage=2 --enable-extended \
+  --set target.%{rust_triple}.profiler="%{profiler}" \
+  %{?wasm_target_config} \
+  --python=%{__python3} \
+  --local-rust-root=%{local_rust_root} \
+  --set build.rustfmt=/bin/true \
+  %{!?with_bundled_llvm: --llvm-root=%{llvm_root} \
+    %{!?llvm_has_filecheck: --disable-codegen-tests} \
+    %{!?with_llvm_static: --enable-llvm-link-shared } } \
+  --disable-llvm-static-stdcpp \
+  --disable-rpath \
+  %{enable_debuginfo} \
+  %{enable_rust_opts} \
+  --set build.build-stage=2 \
+  --set build.doc-stage=2 \
+  --set build.install-stage=2 \
+  --set build.test-stage=2 \
+  --set build.optimized-compiler-builtins=false \
+  --enable-extended \
   --tools=cargo,clippy,rls,rust-analyzer,rustfmt,src \
-  --enable-vendor --enable-verbose-tests  --dist-compression-formats=gz \
-  --disable-rpath --release-channel=%{channel}\
-  --release-description="Anolis %{anolis_ver} %{EVR}"
+  --enable-vendor \
+  --enable-verbose-tests \
+  --dist-compression-formats=gz \
+  --release-channel=%{channel} \
+  --release-description="%{?fedora:Fedora }%{?rhel:Red Hat }%{version}-%{release}"
+
+%global __x %{__python3} ./x.py
+%global __xk %{__x} --keep-stage=0 --keep-stage=1
+
+%if %with rustc_pgo
+# Build the compiler with profile instrumentation
+PROFRAW="$PWD/build/profiles"
+PROFDATA="$PWD/build/rustc.profdata"
+mkdir -p "$PROFRAW"
+%{__x} build -j "$ncpus" sysroot --rust-profile-generate="$PROFRAW"
+# Build cargo as a workload to generate compiler profiles
+env LLVM_PROFILE_FILE="$PROFRAW/default_%%m_%%p.profraw" %{__xk} build cargo
+llvm-profdata merge -o "$PROFDATA" "$PROFRAW"
+rm -r "$PROFRAW" build/%{rust_triple}/stage2*/
+# Rebuild the compiler using the profile data
+%{__x} build -j "$ncpus" sysroot --rust-profile-use="$PROFDATA"
+%else
+# Build the compiler without PGO
+%{__x} build -j "$ncpus" sysroot
+%endif
 
-%{__python3} ./x.py build -j "$ncpus"
-%{__python3} ./x.py doc
+# Build everything else normally
+%{__xk} build
+%{__xk} doc
 
-%if %{with wasm}
-for triple in %{?wasm_targets}; do
-  %{__python3} ./x.py build --target=$triple std
+for triple in %{?all_targets} ; do
+  %{__xk} build --target=$triple std
 done
-%endif
 
 %install
 %{export_rust_env}
 
-DESTDIR=%{buildroot} %{__python3} ./x.py install
+DESTDIR=%{buildroot} %{__xk} install
 
-%if %{with wasm}
-for triple in %{?wasm_targets}; do
-  DESTDIR=%{buildroot} %{__python3} ./x.py install --target=$triple std
+for triple in %{?all_targets} ; do
+  DESTDIR=%{buildroot} %{__xk} install --target=$triple std
 done
-%endif
 
-install -t %{buildroot}%{_bindir} build/%{rust_triple}/stage2-tools-bin/rls
+# The rls stub doesn't have an install target, but we can just copy it.
+%{__install} -t %{buildroot}%{_bindir} build/%{rust_triple}/stage2-tools-bin/rls
 
+# These are transient files used by x.py dist and install
 rm -rf ./build/dist/ ./build/tmp/
 
+# Some of the components duplicate-install binaries, leaving backups we don't want
 rm -f %{buildroot}%{_bindir}/*.old
 
+# Make sure the shared libraries are in the proper libdir
 %if "%{_libdir}" != "%{common_libdir}"
 mkdir -p %{buildroot}%{_libdir}
 find %{buildroot}%{common_libdir} -maxdepth 1 -type f -name '*.so' \
   -exec mv -v -t %{buildroot}%{_libdir} '{}' '+'
 %endif
 
+# The shared libraries should be executable for debuginfo extraction.
 find %{buildroot}%{_libdir} -maxdepth 1 -type f -name '*.so' \
   -exec chmod -v +x '{}' '+'
 
-pushd %{buildroot}%{rustlibdir}
-find lib -maxdepth 1 -type f -name '*.so' |
+# The libdir libraries are identical to those under rustlib/.  It's easier on
+# library loading if we keep them in libdir, but we do need them in rustlib/
+# to support dynamic linking for compiler plugins, so we'll symlink.
+find %{buildroot}%{rustlibdir}/%{rust_triple}/lib/ -maxdepth 1 -type f -name '*.so' |
 while read lib; do
  lib2="%{buildroot}%{_libdir}/${lib##*/}"
  if [ -f "$lib2" ]; then
+   # make sure they're actually identical!
    cmp "$lib" "$lib2"
    ln -v -f -r -s -T "$lib2" "$lib"
  fi
 done
-find ./ -maxdepth 1 -type f -exec rm -v '{}' '+'
-find ./ -type f -name '*.orig' -exec rm -v '{}' '+'
-find src -type f -name '*.py' -exec rm -v '{}' '+'
-popd
-
-pushd %{buildroot}
-install -m 0644 -D -p %{SOURCE100} ./%{rpmmacrodir}/macros.rust-toolset
-install -m 0644 -D -p %{SOURCE101} ./%{_sysconfdir}/skel/.cargo/config.toml
-install -m 0644 -D -p %{SOURCE102} ./%{_sysconfdir}/profile.d/cargo-config.sh
-install -m 0644 -D -p %{SOURCE103} ./%{_sysconfdir}/profile.d/cargo-config.csh
-popd
 
+# Remove installer artifacts (manifests, uninstall scripts, etc.)
+find %{buildroot}%{rustlibdir} -maxdepth 1 -type f -exec rm -v '{}' '+'
+
+# Remove backup files from %%configure munging
+find %{buildroot}%{rustlibdir} -type f -name '*.orig' -exec rm -v '{}' '+'
+
+# https://fedoraproject.org/wiki/Changes/Make_ambiguous_python_shebangs_error
+# We don't actually need to ship any of those python scripts in rust-src anyway.
+find %{buildroot}%{rustlibdir}/src -type f -name '*.py' -exec rm -v '{}' '+'
+
+# FIXME: __os_install_post will strip the rlibs
+# -- should we find a way to preserve debuginfo?
+
+# Remove unwanted documentation files (we already package them)
+rm -f %{buildroot}%{_docdir}/%{name}/README.md
+rm -f %{buildroot}%{_docdir}/%{name}/COPYRIGHT
+rm -f %{buildroot}%{_docdir}/%{name}/LICENSE
+rm -f %{buildroot}%{_docdir}/%{name}/LICENSE-APACHE
+rm -f %{buildroot}%{_docdir}/%{name}/LICENSE-MIT
+rm -f %{buildroot}%{_docdir}/%{name}/LICENSE-THIRD-PARTY
+rm -f %{buildroot}%{_docdir}/%{name}/*.old
+
+# Sanitize the HTML documentation
+find %{buildroot}%{_docdir}/%{name}/html -empty -delete
+find %{buildroot}%{_docdir}/%{name}/html -type f -exec chmod -x '{}' '+'
+
+# Create the path for crate-devel packages
 mkdir -p %{buildroot}%{_datadir}/cargo/registry
+
+# Cargo no longer builds its own documentation
+# https://github.com/rust-lang/cargo/pull/4904
 mkdir -p %{buildroot}%{_docdir}/cargo
 ln -sT ../rust/html/cargo/ %{buildroot}%{_docdir}/cargo/html
 
-%if %{without lldb}
-rm -f %{buildroot}%{_bindir}/rust-lldb
-rm -f %{buildroot}%{rustlibdir}/etc/lldb_*
-%endif
-
-rm -rf ./build/dist/ ./build/tmp/
+# We don't want Rust copies of LLVM tools (rust-lld, rust-llvm-dwp)
 rm -f %{buildroot}%{rustlibdir}/%{rust_triple}/bin/rust-ll*
-rm -rf %{buildroot}%{_docdir}/%{name}/README*
-rm -rf %{buildroot}%{_docdir}/%{name}/LICENSE*
-rm -rf %{buildroot}%{_docdir}/%{name}/COPYRIGHT
 
-%check
-%{export_rust_env}
+#%%if 0%{?rhel}
+# This allows users to build packages using Rust Toolset.
+%{__install} -D -m 644 %{S:100} %{buildroot}%{rpmmacrodir}/macros.rust-toolset
+%{__install} -D -m 644 %{S:101} %{buildroot}%{rpmmacrodir}/macros.rust-srpm
+%{__install} -D -m 644 %{S:102} %{buildroot}%{_fileattrsdir}/cargo_vendor.attr
+%{__install} -D -m 755 %{S:103} %{buildroot}%{_rpmconfigdir}/cargo_vendor.prov
+#%%endif
 
-%{buildroot}%{_bindir}/cargo new build/hello-world
-env RUSTC=%{buildroot}%{_bindir}/rustc \
-    LD_LIBRARY_PATH="%{buildroot}%{_libdir}:$LD_LIBRARY_PATH" \
-    %{buildroot}%{_bindir}/cargo run --manifest-path build/hello-world/Cargo.toml
 
-%if %{with wasm}
-for triple in %{?wasm_targets}; do
-  env RUSTC=%{buildroot}%{_bindir}/rustc \
-      LD_LIBRARY_PATH="%{buildroot}%{_libdir}:$LD_LIBRARY_PATH" \
-      %{buildroot}%{_bindir}/cargo build --manifest-path build/hello-world/Cargo.toml --target=$triple
-done
-%endif
+%check
+%{export_rust_env}
 
-%{__python3} ./x.py test --no-fail-fast --exclude src/bootstrap || :            
+# Sanity-check the installed binaries, debuginfo-stripped and all.
+TMP_HELLO=$(mktemp -d)
+(
+  cd "$TMP_HELLO"
+  export RUSTC=%{buildroot}%{_bindir}/rustc \
+    LD_LIBRARY_PATH="%{buildroot}%{_libdir}:$LD_LIBRARY_PATH"
+  %{buildroot}%{_bindir}/cargo init --name hello-world
+  %{buildroot}%{_bindir}/cargo run --verbose
+
+  # Sanity-check that code-coverage builds and runs
+  env RUSTFLAGS="-Cinstrument-coverage" %{buildroot}%{_bindir}/cargo run --verbose
+  test -r default_*.profraw
+
+  # Try a build sanity-check for other std-enabled targets
+  for triple in %{?wasm_targets}; do
+    %{buildroot}%{_bindir}/cargo build --verbose --target=$triple
+  done
+)
+rm -rf "$TMP_HELLO"
+
+# The results are not stable on koji, so mask errors and just log it.
+# Some of the larger test artifacts are manually cleaned to save space.
+
+# Bootstrap is excluded because it's not something we ship, and a lot of its
+# tests are geared toward the upstream CI environment.
+%{__xk} test --no-fail-fast --skip src/bootstrap || :
 rm -rf "./build/%{rust_triple}/test/"
-%{__python3} ./x.py test --no-fail-fast cargo || :
+
+%{__xk} test --no-fail-fast cargo || :
 rm -rf "./build/%{rust_triple}/stage2-tools/%{rust_triple}/cit/"
 
-for d_modle in clippy rust-analyzer rustfmt; do
-  %{__python3} ./x.py test --no-fail-fast %{d_modle} || :
-done
+%{__xk} test --no-fail-fast clippy || :
+
+%{__xk} test --no-fail-fast rust-analyzer || :
+
+%{__xk} test --no-fail-fast rustfmt || :
+
+
+%ldconfig_scriptlets
+
 
 %files
 %license COPYRIGHT LICENSE-APACHE LICENSE-MIT
+%doc README.md
 %{_bindir}/rustc
 %{_bindir}/rustdoc
 %{_libdir}/*.so
@@ -503,90 +885,138 @@ done
 %dir %{rustlibdir}/%{rust_triple}/lib
 %{rustlibdir}/%{rust_triple}/lib/*.so
 
+
+%files std-static
+%dir %{rustlibdir}
+%dir %{rustlibdir}/%{rust_triple}
+%dir %{rustlibdir}/%{rust_triple}/lib
+%{rustlibdir}/%{rust_triple}/lib/*.rlib
+
+%global target_files()      \
+%files std-static-%1        \
+%dir %{rustlibdir}          \
+%dir %{rustlibdir}/%1       \
+%dir %{rustlibdir}/%1/lib   \
+%{rustlibdir}/%1/lib/*.rlib
+
+%if %target_enabled i686-pc-windows-gnu
+%target_files i686-pc-windows-gnu
+%{rustlibdir}/i686-pc-windows-gnu/lib/rs*.o
+%exclude %{rustlibdir}/i686-pc-windows-gnu/lib/*.dll
+%exclude %{rustlibdir}/i686-pc-windows-gnu/lib/*.dll.a
+%endif
+
+%if %target_enabled x86_64-pc-windows-gnu
+%target_files x86_64-pc-windows-gnu
+%{rustlibdir}/x86_64-pc-windows-gnu/lib/rs*.o
+%exclude %{rustlibdir}/x86_64-pc-windows-gnu/lib/*.dll
+%exclude %{rustlibdir}/x86_64-pc-windows-gnu/lib/*.dll.a
+%endif
+
+%if %target_enabled wasm32-unknown-unknown
+%target_files wasm32-unknown-unknown
+%endif
+
+%if %target_enabled wasm32-wasi
+%target_files wasm32-wasi
+%if %with bundled_wasi_libc
+%dir %{rustlibdir}/wasm32-wasi/lib/self-contained
+%{rustlibdir}/wasm32-wasi/lib/self-contained/crt*.o
+%{rustlibdir}/wasm32-wasi/lib/self-contained/libc.a
+%endif
+%endif
+
+%if %target_enabled x86_64-unknown-none
+%target_files x86_64-unknown-none
+%endif
+
+%if %target_enabled x86_64-unknown-uefi
+%target_files x86_64-unknown-uefi
+%endif
+
+
+%files debugger-common
+%dir %{rustlibdir}
+%dir %{rustlibdir}/etc
+%{rustlibdir}/etc/rust_*.py*
+
+
+%files gdb
+%{_bindir}/rust-gdb
+%{rustlibdir}/etc/gdb_*
+%exclude %{_bindir}/rust-gdbgui
+
+
+%files lldb
+%{_bindir}/rust-lldb
+%{rustlibdir}/etc/lldb_*
+
+
+%files doc
+%docdir %{_docdir}/%{name}
+%dir %{_docdir}/%{name}
+%{_docdir}/%{name}/html
+# former cargo-doc
+%docdir %{_docdir}/cargo
+%dir %{_docdir}/cargo
+%{_docdir}/cargo/html
+
+
 %files -n cargo
 %license src/tools/cargo/LICENSE-{APACHE,MIT,THIRD-PARTY}
 %doc src/tools/cargo/README.md
-%config(noreplace) %{_sysconfdir}/skel/.cargo/config.toml
-%{_sysconfdir}/profile.d/cargo-config.*
 %{_bindir}/cargo
-%{_libexecdir}/cargo*
 %{_mandir}/man1/cargo*.1*
 %{_sysconfdir}/bash_completion.d/cargo
 %{_datadir}/zsh/site-functions/_cargo
 %dir %{_datadir}/cargo
 %dir %{_datadir}/cargo/registry
 
+
 %files -n rustfmt
 %{_bindir}/rustfmt
 %{_bindir}/cargo-fmt
+%doc src/tools/rustfmt/{README,CHANGELOG,Configurations}.md
+%license src/tools/rustfmt/LICENSE-{APACHE,MIT}
 
-%files gdb
-%{_bindir}/rust-gdb
-%{rustlibdir}/etc/gdb_*
-%exclude %{_bindir}/rust-gdbgui
-
-%if %{with lldb}
-%files lldb
-%{_bindir}/rust-lldb
-%{rustlibdir}/etc/lldb_*
-%endif
 
 %files analyzer
 %{_bindir}/rls
 %{_bindir}/rust-analyzer
+%doc src/tools/rust-analyzer/README.md
+%license src/tools/rust-analyzer/LICENSE-{APACHE,MIT}
+
 
 %files -n clippy
 %{_bindir}/cargo-clippy
 %{_bindir}/clippy-driver
+%doc src/tools/clippy/{README.md,CHANGELOG.md}
+%license src/tools/clippy/LICENSE-{APACHE,MIT}
+
 
 %files src
 %dir %{rustlibdir}
 %{rustlibdir}/src
 
-%files toolset
-%{rpmmacrodir}/macros.rust-toolset
 
-%files std-static
-%dir %{rustlibdir}
-%dir %{rustlibdir}/%{rust_triple}
-%dir %{rustlibdir}/%{rust_triple}/lib
-%{rustlibdir}/%{rust_triple}/lib/*.rlib
+#%%if 0%{?rhel}
+%files srpm-macros
+%{rpmmacrodir}/macros.rust-srpm
 
-%if %{with wasm}
-%files std-static-wasm32-unknown-unknown
-%dir %{rustlibdir}
-%dir %{rustlibdir}/wasm32-unknown-unknown
-%dir %{rustlibdir}/wasm32-unknown-unknown/lib
-%{rustlibdir}/wasm32-unknown-unknown/lib/*.rlib
+%files toolset
+%{rpmmacrodir}/macros.rust-toolset
+%{_fileattrsdir}/cargo_vendor.attr
+%{_rpmconfigdir}/cargo_vendor.prov
+#%%endif
 
-%files std-static-wasm32-wasi
-%dir %{rustlibdir}
-%dir %{rustlibdir}/wasm32-wasi
-%dir %{rustlibdir}/wasm32-wasi/lib
-%dir %{rustlibdir}/wasm32-wasi/lib/self-contained
-%{rustlibdir}/wasm32-wasi/lib/*.rlib
-%{rustlibdir}/wasm32-wasi/lib/self-contained/crt*.o
-%{rustlibdir}/wasm32-wasi/lib/self-contained/libc.a
-%endif
 
-%files debugger-common
-%dir %{rustlibdir}
-%dir %{rustlibdir}/etc
-%{rustlibdir}/etc/rust_*.py*
+%changelog
+* Thu May 30 2024 gaoxulin  - 1.77.2-1
+- Update to 1.77.2 to fix CVE-2024-24576
 
-%files doc
-%doc README.md
-%docdir %{_docdir}/%{name}
-%dir %{_docdir}/%{name}
-%{_docdir}/%{name}/html
-%docdir %{_docdir}/cargo
-%dir %{_docdir}/cargo
-%{_docdir}/cargo/html
-%doc src/tools/clippy/{README.md,CHANGELOG.md}
-%doc src/tools/rustfmt/{README,CHANGELOG,Configurations}.md
-%doc src/tools/rust-analyzer/README.md
+* Tue Mar 26 2024 mgb01105731  - 1.77.0-1
+- Update to 1.77.0
 
-%changelog
 * Mon Oct 30 2023 WANG Rui  - 1.71.1-2
 - Stabilize inline-asm for loongarch64.
 
diff --git a/rustc-1.77.0-disable-libssh2.patch b/rustc-1.77.0-disable-libssh2.patch
new file mode 100644
index 0000000000000000000000000000000000000000..859fecb7018c134dca64ce1bb18123ca4f061ce2
--- /dev/null
+++ b/rustc-1.77.0-disable-libssh2.patch
@@ -0,0 +1,44 @@
+diff -up rustc-beta-src/src/tools/cargo/Cargo.lock.orig rustc-beta-src/src/tools/cargo/Cargo.lock
+--- rustc-beta-src/src/tools/cargo/Cargo.lock.orig	2024-02-14 14:06:05.881165093 +0100
++++ rustc-beta-src/src/tools/cargo/Cargo.lock	2024-02-14 14:06:27.169456166 +0100
+@@ -2072,7 +2072,6 @@ checksum = "ee4126d8b4ee5c9d9ea891dd875c
+ dependencies = [
+  "cc",
+  "libc",
+- "libssh2-sys",
+  "libz-sys",
+  "openssl-sys",
+  "pkg-config",
+@@ -2113,20 +2112,6 @@ dependencies = [
+  "pkg-config",
+  "vcpkg",
+ ]
+-
+-[[package]]
+-name = "libssh2-sys"
+-version = "0.3.0"
+-source = "registry+https://github.com/rust-lang/crates.io-index"
+-checksum = "2dc8a030b787e2119a731f1951d6a773e2280c660f8ec4b0f5e1505a386e71ee"
+-dependencies = [
+- "cc",
+- "libc",
+- "libz-sys",
+- "openssl-sys",
+- "pkg-config",
+- "vcpkg",
+-]
+ 
+ [[package]]
+ name = "libz-sys"
+diff -up rustc-beta-src/src/tools/cargo/Cargo.toml.orig rustc-beta-src/src/tools/cargo/Cargo.toml
+--- rustc-beta-src/src/tools/cargo/Cargo.toml.orig	2024-02-14 14:06:10.400226884 +0100
++++ rustc-beta-src/src/tools/cargo/Cargo.toml	2024-02-14 14:06:51.225785086 +0100
+@@ -44,7 +44,7 @@ curl = "0.4.44"
+ curl-sys = "0.4.70"
+ filetime = "0.2.23"
+ flate2 = { version = "1.0.28", default-features = false, features = ["zlib"] }
+-git2 = "0.18.2"
++git2 = { version = "0.18.2", default-features = false, features = ["https"] }
+ git2-curl = "0.19.0"
+ gix = { version = "0.57.1", default-features = false, features = ["blocking-http-transport-curl", "progress-tree", "revision"] }
+ gix-features-for-configuration-only = { version = "0.37.1", package = "gix-features", features = [ "parallel" ] }
diff --git a/rustc-1.77.0-unbundle-sqlite.patch b/rustc-1.77.0-unbundle-sqlite.patch
new file mode 100644
index 0000000000000000000000000000000000000000..50aa4a817680901ddb22013925fdf3b74de4c0a7
--- /dev/null
+++ b/rustc-1.77.0-unbundle-sqlite.patch
@@ -0,0 +1,23 @@
+diff -up rustc-beta-src/src/tools/cargo/Cargo.lock.orig rustc-beta-src/src/tools/cargo/Cargo.lock
+--- rustc-beta-src/src/tools/cargo/Cargo.lock.orig	2024-02-14 13:00:20.318976752 +0100
++++ rustc-beta-src/src/tools/cargo/Cargo.lock	2024-02-14 13:00:28.447051475 +0100
+@@ -2110,7 +2110,6 @@ version = "0.27.0"
+ source = "registry+https://github.com/rust-lang/crates.io-index"
+ checksum = "cf4e226dcd58b4be396f7bd3c20da8fdee2911400705297ba7d2d7cc2c30f716"
+ dependencies = [
+- "cc",
+  "pkg-config",
+  "vcpkg",
+ ]
+diff -up rustc-beta-src/src/tools/cargo/Cargo.toml.orig rustc-beta-src/src/tools/cargo/Cargo.toml
+--- rustc-beta-src/src/tools/cargo/Cargo.toml.orig	2024-02-14 13:00:14.942927327 +0100
++++ rustc-beta-src/src/tools/cargo/Cargo.toml	2024-02-14 13:00:40.688164017 +0100
+@@ -77,7 +77,7 @@ proptest = "1.4.0"
+ pulldown-cmark = { version = "0.9.3", default-features = false }
+ rand = "0.8.5"
+ regex = "1.10.2"
+-rusqlite = { version = "0.30.0", features = ["bundled"] }
++rusqlite = { version = "0.30.0", features = [] }
+ rustfix = { version = "0.8.0", path = "crates/rustfix" }
+ same-file = "1.0.6"
+ security-framework = "2.9.2"
diff --git a/rustc-1.71.1-src.tar.xz b/rustc-1.77.2-src.tar.xz
similarity index 85%
rename from rustc-1.71.1-src.tar.xz
rename to rustc-1.77.2-src.tar.xz
index 9a7b8a5781c895bb2884cff7a2b6301e78bb1bce..ed7d5176f3ff1514be8dd2c2c46c4a81bd073645 100644
Binary files a/rustc-1.71.1-src.tar.xz and b/rustc-1.77.2-src.tar.xz differ
diff --git a/wasi-libc-03b228e46bb02fcc5927253e1b8ad715072b1ae4.tar.gz b/wasi-libc-03b228e46bb02fcc5927253e1b8ad715072b1ae4.tar.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e3fea7b83a2726cf7707f95b276f65cd6b12b371
Binary files /dev/null and b/wasi-libc-03b228e46bb02fcc5927253e1b8ad715072b1ae4.tar.gz differ
diff --git a/wasi-libc-wasi-sdk-20.tar.gz b/wasi-libc-wasi-sdk-20.tar.gz
deleted file mode 100644
index 2b610eaa2259673607592c6426989c346b018d60..0000000000000000000000000000000000000000
Binary files a/wasi-libc-wasi-sdk-20.tar.gz and /dev/null differ