24 changed files with 1159 additions and 1806 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,2 @@
-SOURCES/rustc-1.79.0-src.tar.xz
+SOURCES/rustc-1.66.1-src.tar.xz
-SOURCES/wasi-libc-wasi-sdk-22.tar.gz
+SOURCES/wasi-libc-wasi-sdk-17.tar.gz
--- a/.rust.metadata
+++ b/.rust.metadata
@ -1,2 +1,2 @@
-fdd94a3bdb321d18a0021d4dce9b8546a1db2eec SOURCES/rustc-1.79.0-src.tar.xz
+a8cc02cc11a942bddf67f1cfdcdd2bd867296f8e SOURCES/rustc-1.66.1-src.tar.xz
-13451249ddb71e69f12565ef4803b71ce4092191 SOURCES/wasi-libc-wasi-sdk-22.tar.gz
+1f4561760c6c7e9f9f30c8cf0d156b8d551e04e2 SOURCES/wasi-libc-wasi-sdk-17.tar.gz
--- a/SOURCES/0001-Disable-jump-threading-of-float-equality.patch
+++ b/SOURCES/0001-Disable-jump-threading-of-float-equality.patch
@ -1,212 +0,0 @@
 From 49166c7dd925244f631277b4aa9ae4233f300884 Mon Sep 17 00:00:00 2001
 From: Nilstrieb <48135649+Nilstrieb@users.noreply.github.com>
 Date: Sat, 27 Jul 2024 15:08:11 +0200
 Subject: [PATCH] Disable jump threading of float equality
 Jump threading stores values as `u128` (`ScalarInt`) and does its
 comparisons for equality as integer comparisons.
 This works great for integers. Sadly, not everything is an integer.
 Floats famously have wonky equality semantcs, with `NaN!=NaN` and
 `0.0 == -0.0`. This does not match our beautiful integer bitpattern
 equality and therefore causes things to go horribly wrong.
 While jump threading could be extended to support floats by remembering
 that they're floats in the value state and handling them properly,
 it's signficantly easier to just disable it for now.
 (cherry picked from commit eca0a7e72346ba123ace318a0f9c28c57d990aeb)
 ---
 .../rustc_mir_transform/src/jump_threading.rs |  7 +++
 ...ding.floats.JumpThreading.panic-abort.diff | 59 +++++++++++++++++++
 ...ing.floats.JumpThreading.panic-unwind.diff | 59 +++++++++++++++++++
 tests/mir-opt/jump_threading.rs               | 12 ++++
 4 files changed, 137 insertions(+)
 create mode 100644 tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
 create mode 100644 tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
 diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
 index a458297210db..e2d2864ad2a0 100644
 --- a/compiler/rustc_mir_transform/src/jump_threading.rs
 +++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -493,6 +493,13 @@ fn process_assign(
                     BinOp::Ne => ScalarInt::FALSE,
                     _ => return None,
                 };
 +                if value.const_.ty().is_floating_point() {
 +                    // Floating point equality does not follow bit-patterns.
 +                    // -0.0 and NaN both have special rules for equality,
 +                    // and therefore we cannot use integer comparisons for them.
 +                    // Avoid handling them, though this could be extended in the future.
 +                    return None;
 +                }
                 let value = value.const_.normalize(self.tcx, self.param_env).try_to_scalar_int()?;
                 let conds = conditions.map(self.arena, |c| Condition {
                     value,
 diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
 new file mode 100644
 index 000000000000..6ca37e96d297
 --- /dev/null
 +++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
@@ -0,0 +1,59 @@
 +- // MIR for `floats` before JumpThreading
 ++ // MIR for `floats` after JumpThreading
 +  
 +  fn floats() -> u32 {
 +      let mut _0: u32;
 +      let _1: f64;
 +      let mut _2: bool;
 +      let mut _3: bool;
 +      let mut _4: f64;
 +      scope 1 {
 +          debug x => _1;
 +      }
 +  
 +      bb0: {
 +          StorageLive(_1);
 +          StorageLive(_2);
 +          _2 = const true;
 +-         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 ++         goto -> bb1;
 +      }
 +  
 +      bb1: {
 +          _1 = const -0f64;
 +          goto -> bb3;
 +      }
 +  
 +      bb2: {
 +          _1 = const 1f64;
 +          goto -> bb3;
 +      }
 +  
 +      bb3: {
 +          StorageDead(_2);
 +          StorageLive(_3);
 +          StorageLive(_4);
 +          _4 = _1;
 +          _3 = Eq(move _4, const 0f64);
 +          switchInt(move _3) -> [0: bb5, otherwise: bb4];
 +      }
 +  
 +      bb4: {
 +          StorageDead(_4);
 +          _0 = const 0_u32;
 +          goto -> bb6;
 +      }
 +  
 +      bb5: {
 +          StorageDead(_4);
 +          _0 = const 1_u32;
 +          goto -> bb6;
 +      }
 +  
 +      bb6: {
 +          StorageDead(_3);
 +          StorageDead(_1);
 +          return;
 +      }
 +  }
 +  
 diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
 new file mode 100644
 index 000000000000..6ca37e96d297
 --- /dev/null
 +++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
@@ -0,0 +1,59 @@
 +- // MIR for `floats` before JumpThreading
 ++ // MIR for `floats` after JumpThreading
 +  
 +  fn floats() -> u32 {
 +      let mut _0: u32;
 +      let _1: f64;
 +      let mut _2: bool;
 +      let mut _3: bool;
 +      let mut _4: f64;
 +      scope 1 {
 +          debug x => _1;
 +      }
 +  
 +      bb0: {
 +          StorageLive(_1);
 +          StorageLive(_2);
 +          _2 = const true;
 +-         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 ++         goto -> bb1;
 +      }
 +  
 +      bb1: {
 +          _1 = const -0f64;
 +          goto -> bb3;
 +      }
 +  
 +      bb2: {
 +          _1 = const 1f64;
 +          goto -> bb3;
 +      }
 +  
 +      bb3: {
 +          StorageDead(_2);
 +          StorageLive(_3);
 +          StorageLive(_4);
 +          _4 = _1;
 +          _3 = Eq(move _4, const 0f64);
 +          switchInt(move _3) -> [0: bb5, otherwise: bb4];
 +      }
 +  
 +      bb4: {
 +          StorageDead(_4);
 +          _0 = const 0_u32;
 +          goto -> bb6;
 +      }
 +  
 +      bb5: {
 +          StorageDead(_4);
 +          _0 = const 1_u32;
 +          goto -> bb6;
 +      }
 +  
 +      bb6: {
 +          StorageDead(_3);
 +          StorageDead(_1);
 +          return;
 +      }
 +  }
 +  
 diff --git a/tests/mir-opt/jump_threading.rs b/tests/mir-opt/jump_threading.rs
 index 57f4e4a2654f..3e7e8995f1a3 100644
 --- a/tests/mir-opt/jump_threading.rs
 +++ b/tests/mir-opt/jump_threading.rs
@@ -514,6 +514,16 @@ fn assume(a: u8, b: bool) -> u8 {
     )
 }
 +fn floats() -> u32 {
 +    // CHECK-LABEL: fn floats(
 +    // CHECK: switchInt(
 +
 +    // Test for issue #128243, where float equality was assumed to be bitwise.
 +    // When adding float support, it must be ensured that this continues working properly.
 +    let x = if true { -0.0 } else { 1.0 };
 +    if x == 0.0 { 0 } else { 1 }
 +}
 +
 fn main() {
     // CHECK-LABEL: fn main(
     too_complex(Ok(0));
@@ -528,6 +538,7 @@ fn main() {
     disappearing_bb(7);
     aggregate(7);
     assume(7, false);
 +    floats();
 }
 // EMIT_MIR jump_threading.too_complex.JumpThreading.diff
@@ -542,3 +553,4 @@ fn main() {
 // EMIT_MIR jump_threading.disappearing_bb.JumpThreading.diff
 // EMIT_MIR jump_threading.aggregate.JumpThreading.diff
 // EMIT_MIR jump_threading.assume.JumpThreading.diff
 +// EMIT_MIR jump_threading.floats.JumpThreading.diff
 -- 
 2.46.0
--- a/SOURCES/0001-Improve-generating-Custom-entry-function.patch
+++ b/SOURCES/0001-Improve-generating-Custom-entry-function.patch
@ -0,0 +1,302 @@
 From 9f0a8620bd7d325e6d42417b08daff3e55cb88f6 Mon Sep 17 00:00:00 2001
 From: Ayush Singh <ayushsingh1325@gmail.com>
 Date: Sat, 5 Nov 2022 14:36:38 +0530
 Subject: [PATCH] Improve generating Custom entry function
 This commit is aimed at making compiler generated entry functions
 (Basically just C `main` right now) more generic so other targets can do
 similar things for custom entry. This was initially implemented as part
 of https://github.com/rust-lang/rust/pull/100316.
 Currently, this moves the entry function name and Call convention to the
 target spec.
 Signed-off-by: Ayush Singh <ayushsingh1325@gmail.com>
 ---
 compiler/rustc_codegen_llvm/src/abi.rs        | 40 +++++++++++--------
 compiler/rustc_codegen_llvm/src/context.rs    | 10 ++++-
 compiler/rustc_codegen_llvm/src/declare.rs    | 22 ++++++++++
 .../src/back/symbol_export.rs                 |  3 +-
 compiler/rustc_target/src/abi/call/mod.rs     | 28 +++++++++++++
 compiler/rustc_target/src/json.rs             | 25 ++++++++++++
 compiler/rustc_target/src/spec/mod.rs         | 27 +++++++++++++
 7 files changed, 135 insertions(+), 20 deletions(-)
 diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
 index d478efc863a9..a6fd2a7de6bd 100644
 --- a/compiler/rustc_codegen_llvm/src/abi.rs
 +++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -398,23 +398,7 @@ fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
     }
     fn llvm_cconv(&self) -> llvm::CallConv {
 -        match self.conv {
 -            Conv::C | Conv::Rust | Conv::CCmseNonSecureCall => llvm::CCallConv,
 -            Conv::RustCold => llvm::ColdCallConv,
 -            Conv::AmdGpuKernel => llvm::AmdGpuKernel,
 -            Conv::AvrInterrupt => llvm::AvrInterrupt,
 -            Conv::AvrNonBlockingInterrupt => llvm::AvrNonBlockingInterrupt,
 -            Conv::ArmAapcs => llvm::ArmAapcsCallConv,
 -            Conv::Msp430Intr => llvm::Msp430Intr,
 -            Conv::PtxKernel => llvm::PtxKernel,
 -            Conv::X86Fastcall => llvm::X86FastcallCallConv,
 -            Conv::X86Intr => llvm::X86_Intr,
 -            Conv::X86Stdcall => llvm::X86StdcallCallConv,
 -            Conv::X86ThisCall => llvm::X86_ThisCall,
 -            Conv::X86VectorCall => llvm::X86_VectorCall,
 -            Conv::X86_64SysV => llvm::X86_64_SysV,
 -            Conv::X86_64Win64 => llvm::X86_64_Win64,
 -        }
 +        self.conv.into()
     }
     fn apply_attrs_llfn(&self, cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value) {
@@ -596,3 +580,25 @@ fn get_param(&mut self, index: usize) -> Self::Value {
         llvm::get_param(self.llfn(), index as c_uint)
     }
 }
 +
 +impl From<Conv> for llvm::CallConv {
 +    fn from(conv: Conv) -> Self {
 +        match conv {
 +            Conv::C | Conv::Rust | Conv::CCmseNonSecureCall => llvm::CCallConv,
 +            Conv::RustCold => llvm::ColdCallConv,
 +            Conv::AmdGpuKernel => llvm::AmdGpuKernel,
 +            Conv::AvrInterrupt => llvm::AvrInterrupt,
 +            Conv::AvrNonBlockingInterrupt => llvm::AvrNonBlockingInterrupt,
 +            Conv::ArmAapcs => llvm::ArmAapcsCallConv,
 +            Conv::Msp430Intr => llvm::Msp430Intr,
 +            Conv::PtxKernel => llvm::PtxKernel,
 +            Conv::X86Fastcall => llvm::X86FastcallCallConv,
 +            Conv::X86Intr => llvm::X86_Intr,
 +            Conv::X86Stdcall => llvm::X86StdcallCallConv,
 +            Conv::X86ThisCall => llvm::X86_ThisCall,
 +            Conv::X86VectorCall => llvm::X86_VectorCall,
 +            Conv::X86_64SysV => llvm::X86_64_SysV,
 +            Conv::X86_64Win64 => llvm::X86_64_Win64,
 +        }
 +    }
 +}
 diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
 index 79ddfd884dfa..f3ef618fff54 100644
 --- a/compiler/rustc_codegen_llvm/src/context.rs
 +++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -570,8 +570,14 @@ fn apply_target_cpu_attr(&self, llfn: &'ll Value) {
     }
     fn declare_c_main(&self, fn_type: Self::Type) -> Option<Self::Function> {
 -        if self.get_declared_value("main").is_none() {
 -            Some(self.declare_cfn("main", llvm::UnnamedAddr::Global, fn_type))
 +        let entry_name = self.sess().target.entry_name.as_ref();
 +        if self.get_declared_value(entry_name).is_none() {
 +            Some(self.declare_entry_fn(
 +                entry_name,
 +                self.sess().target.entry_abi.into(),
 +                llvm::UnnamedAddr::Global,
 +                fn_type,
 +            ))
         } else {
             // If the symbol already exists, it is an error: for example, the user wrote
             // #[no_mangle] extern "C" fn main(..) {..}
 diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
 index f79ef11720df..dc21a02cec44 100644
 --- a/compiler/rustc_codegen_llvm/src/declare.rs
 +++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -90,6 +90,28 @@ pub fn declare_cfn(
         declare_raw_fn(self, name, llvm::CCallConv, unnamed, visibility, fn_type)
     }
 +    /// Declare an entry Function
 +    ///
 +    /// The ABI of this function can change depending on the target (although for now the same as
 +    /// `declare_cfn`)
 +    ///
 +    /// If there’s a value with the same name already declared, the function will
 +    /// update the declaration and return existing Value instead.
 +    pub fn declare_entry_fn(
 +        &self,
 +        name: &str,
 +        callconv: llvm::CallConv,
 +        unnamed: llvm::UnnamedAddr,
 +        fn_type: &'ll Type,
 +    ) -> &'ll Value {
 +        let visibility = if self.tcx.sess.target.default_hidden_visibility {
 +            llvm::Visibility::Hidden
 +        } else {
 +            llvm::Visibility::Default
 +        };
 +        declare_raw_fn(self, name, callconv, unnamed, visibility, fn_type)
 +    }
 +
     /// Declare a Rust function.
     ///
     /// If there’s a value with the same name already declared, the function will
 diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
 index 752f6b1ef40c..22f534d909ab 100644
 --- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
 +++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -180,7 +180,8 @@ fn exported_symbols_provider_local<'tcx>(
         .collect();
     if tcx.entry_fn(()).is_some() {
 -        let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, "main"));
 +        let exported_symbol =
 +            ExportedSymbol::NoDefId(SymbolName::new(tcx, tcx.sess.target.entry_name.as_ref()));
         symbols.push((
             exported_symbol,
 diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
 index 9e5f0e4d158b..c622bd36b00c 100644
 --- a/compiler/rustc_target/src/abi/call/mod.rs
 +++ b/compiler/rustc_target/src/abi/call/mod.rs
@@ -3,6 +3,7 @@
 use crate::spec::{self, HasTargetSpec};
 use rustc_span::Symbol;
 use std::fmt;
 +use std::str::FromStr;
 mod aarch64;
 mod amdgpu;
@@ -735,6 +736,33 @@ pub fn adjust_for_foreign_abi<C>(
     }
 }
 +impl FromStr for Conv {
 +    type Err = String;
 +
 +    fn from_str(s: &str) -> Result<Self, Self::Err> {
 +        match s {
 +            "C" => Ok(Conv::C),
 +            "Rust" => Ok(Conv::Rust),
 +            "RustCold" => Ok(Conv::Rust),
 +            "ArmAapcs" => Ok(Conv::ArmAapcs),
 +            "CCmseNonSecureCall" => Ok(Conv::CCmseNonSecureCall),
 +            "Msp430Intr" => Ok(Conv::Msp430Intr),
 +            "PtxKernel" => Ok(Conv::PtxKernel),
 +            "X86Fastcall" => Ok(Conv::X86Fastcall),
 +            "X86Intr" => Ok(Conv::X86Intr),
 +            "X86Stdcall" => Ok(Conv::X86Stdcall),
 +            "X86ThisCall" => Ok(Conv::X86ThisCall),
 +            "X86VectorCall" => Ok(Conv::X86VectorCall),
 +            "X86_64SysV" => Ok(Conv::X86_64SysV),
 +            "X86_64Win64" => Ok(Conv::X86_64Win64),
 +            "AmdGpuKernel" => Ok(Conv::AmdGpuKernel),
 +            "AvrInterrupt" => Ok(Conv::AvrInterrupt),
 +            "AvrNonBlockingInterrupt" => Ok(Conv::AvrNonBlockingInterrupt),
 +            _ => Err(format!("'{}' is not a valid value for entry function call convetion.", s)),
 +        }
 +    }
 +}
 +
 // Some types are used a lot. Make sure they don't unintentionally get bigger.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 mod size_asserts {
 diff --git a/compiler/rustc_target/src/json.rs b/compiler/rustc_target/src/json.rs
 index b5d926352122..75bb76a9de08 100644
 --- a/compiler/rustc_target/src/json.rs
 +++ b/compiler/rustc_target/src/json.rs
@@ -89,3 +89,28 @@ fn to_json(&self) -> Json {
         }
     }
 }
 +
 +impl ToJson for crate::abi::call::Conv {
 +    fn to_json(&self) -> Json {
 +        let s = match self {
 +            Self::C => "C",
 +            Self::Rust => "Rust",
 +            Self::RustCold => "RustCold",
 +            Self::ArmAapcs => "ArmAapcs",
 +            Self::CCmseNonSecureCall => "CCmseNonSecureCall",
 +            Self::Msp430Intr => "Msp430Intr",
 +            Self::PtxKernel => "PtxKernel",
 +            Self::X86Fastcall => "X86Fastcall",
 +            Self::X86Intr => "X86Intr",
 +            Self::X86Stdcall => "X86Stdcall",
 +            Self::X86ThisCall => "X86ThisCall",
 +            Self::X86VectorCall => "X86VectorCall",
 +            Self::X86_64SysV => "X86_64SysV",
 +            Self::X86_64Win64 => "X86_64Win64",
 +            Self::AmdGpuKernel => "AmdGpuKernel",
 +            Self::AvrInterrupt => "AvrInterrupt",
 +            Self::AvrNonBlockingInterrupt => "AvrNonBlockingInterrupt",
 +        };
 +        Json::String(s.to_owned())
 +    }
 +}
 diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
 index 72b088d663b1..617de46a55aa 100644
 --- a/compiler/rustc_target/src/spec/mod.rs
 +++ b/compiler/rustc_target/src/spec/mod.rs
@@ -34,6 +34,7 @@
 //! the target's settings, though `target-feature` and `link-args` will *add*
 //! to the list specified by the target, rather than replace.
 +use crate::abi::call::Conv;
 use crate::abi::Endian;
 use crate::json::{Json, ToJson};
 use crate::spec::abi::{lookup as lookup_abi, Abi};
@@ -1668,6 +1669,14 @@ pub struct TargetOptions {
     /// Whether the target supports stack canary checks. `true` by default,
     /// since this is most common among tier 1 and tier 2 targets.
     pub supports_stack_protector: bool,
 +
 +    // The name of entry function.
 +    // Default value is "main"
 +    pub entry_name: StaticCow<str>,
 +
 +    // The ABI of entry function.
 +    // Default value is `Conv::C`, i.e. C call convention
 +    pub entry_abi: Conv,
 }
 /// Add arguments for the given flavor and also for its "twin" flavors
@@ -1884,6 +1893,8 @@ fn default() -> TargetOptions {
             c_enum_min_bits: 32,
             generate_arange_section: true,
             supports_stack_protector: true,
 +            entry_name: "main".into(),
 +            entry_abi: Conv::C,
         }
     }
 }
@@ -2401,6 +2412,18 @@ macro_rules! key {
                     }
                 }
             } );
 +            ($key_name:ident, Conv) => ( {
 +                let name = (stringify!($key_name)).replace("_", "-");
 +                obj.remove(&name).and_then(|o| o.as_str().and_then(|s| {
 +                    match Conv::from_str(s) {
 +                        Ok(c) => {
 +                            base.$key_name = c;
 +                            Some(Ok(()))
 +                        }
 +                        Err(e) => Some(Err(e))
 +                    }
 +                })).unwrap_or(Ok(()))
 +            } );
         }
         if let Some(j) = obj.remove("target-endian") {
@@ -2520,6 +2543,8 @@ macro_rules! key {
         key!(c_enum_min_bits, u64);
         key!(generate_arange_section, bool);
         key!(supports_stack_protector, bool);
 +        key!(entry_name);
 +        key!(entry_abi, Conv)?;
         if base.is_builtin {
             // This can cause unfortunate ICEs later down the line.
@@ -2770,6 +2795,8 @@ macro_rules! target_option_val {
         target_option_val!(c_enum_min_bits);
         target_option_val!(generate_arange_section);
         target_option_val!(supports_stack_protector);
 +        target_option_val!(entry_name);
 +        target_option_val!(entry_abi);
         if let Some(abi) = self.default_adjusted_cabi {
             d.insert("default-adjusted-cabi".into(), Abi::name(abi).to_json());
 -- 
 2.38.1
--- a/SOURCES/0001-Let-environment-variables-override-some-default-CPUs.patch
+++ b/SOURCES/0001-Let-environment-variables-override-some-default-CPUs.patch
@ -1,53 +0,0 @@
 From 184d61d2c12aa2db01de9a14ccb2be0cfae5039b Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 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
--- a/SOURCES/0001-Make-issue-122805.rs-big-endian-compatible.patch
+++ b/SOURCES/0001-Make-issue-122805.rs-big-endian-compatible.patch
@ -1,49 +0,0 @@
 From 26fa5c2c300f3c3a3ee3109c009bd4a6803a2a4c Mon Sep 17 00:00:00 2001
 From: Nikita Popov <npopov@redhat.com>
 Date: Tue, 11 Jun 2024 10:13:07 +0200
 Subject: [PATCH] Make issue-122805.rs big endian compatible
 Instead of not generating the function at all on big endian (which
 makes the CHECK lines fail), instead use to_le() on big endian,
 so that we essentially perform a bswap for both endiannesses.
 ---
 tests/codegen/issues/issue-122805.rs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)
 diff --git a/tests/codegen/issues/issue-122805.rs b/tests/codegen/issues/issue-122805.rs
 index 6d108ada6dd..8e03c6c8884 100644
 --- a/tests/codegen/issues/issue-122805.rs
 +++ b/tests/codegen/issues/issue-122805.rs
@@ -39,17 +39,20 @@
 // OPT3WINX64-NEXT: store <8 x i16>
 // CHECK-NEXT: ret void
 #[no_mangle]
 -#[cfg(target_endian = "little")]
 pub fn convert(value: [u16; 8]) -> [u8; 16] {
 +    #[cfg(target_endian = "little")]
 +    let bswap = u16::to_be;
 +    #[cfg(target_endian = "big")]
 +    let bswap = u16::to_le;
     let addr16 = [
 -        value[0].to_be(),
 -        value[1].to_be(),
 -        value[2].to_be(),
 -        value[3].to_be(),
 -        value[4].to_be(),
 -        value[5].to_be(),
 -        value[6].to_be(),
 -        value[7].to_be(),
 +        bswap(value[0]),
 +        bswap(value[1]),
 +        bswap(value[2]),
 +        bswap(value[3]),
 +        bswap(value[4]),
 +        bswap(value[5]),
 +        bswap(value[6]),
 +        bswap(value[7]),
     ];
     unsafe { core::mem::transmute::<_, [u8; 16]>(addr16) }
 }
 -- 
 2.45.1
--- a/SOURCES/0001-Mangle-main-as-__main_void-on-wasm32-wasi.patch
+++ b/SOURCES/0001-Mangle-main-as-__main_void-on-wasm32-wasi.patch
@ -0,0 +1,34 @@
 From 98ae83daae67e9e7663b8345eced1de8c667271f Mon Sep 17 00:00:00 2001
 From: Dan Gohman <dev@sunfishcode.online>
 Date: Thu, 8 Dec 2022 10:35:46 -0800
 Subject: [PATCH] Mangle "main" as "__main_void" on wasm32-wasi
 On wasm, the age-old C trick of having a main function which can either have
 no arguments or argc+argv doesn't work, because wasm requires caller and
 callee signatures to match. WASI's current strategy is to have compilers
 mangle main's name to indicate which signature they're using. Rust uses the
 no-argument form, which should be mangled as `__main_void`.
 This is needed on wasm32-wasi as of #105395.
 ---
 compiler/rustc_target/src/spec/wasm32_wasi.rs | 4 ++++
 1 file changed, 4 insertions(+)
 diff --git a/compiler/rustc_target/src/spec/wasm32_wasi.rs b/compiler/rustc_target/src/spec/wasm32_wasi.rs
 index 6f0bbf0672d4..a0476d542e64 100644
 --- a/compiler/rustc_target/src/spec/wasm32_wasi.rs
 +++ b/compiler/rustc_target/src/spec/wasm32_wasi.rs
@@ -104,6 +104,10 @@ pub fn target() -> Target {
     // `args::args()` makes the WASI API calls itself.
     options.main_needs_argc_argv = false;
 +    // And, WASI mangles the name of "main" to distinguish between different
 +    // signatures.
 +    options.entry_name = "__main_void".into();
 +
     Target {
         llvm_target: "wasm32-wasi".into(),
         pointer_width: 32,
 -- 
 2.38.1
--- a/SOURCES/0001-Use-an-explicit-x86-64-cpu-in-tests-that-are-sensiti.patch
+++ b/SOURCES/0001-Use-an-explicit-x86-64-cpu-in-tests-that-are-sensiti.patch
@ -1,264 +0,0 @@
 From 706f06c39a9e08a4708a53722429d13ae4069c2f Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 Date: Wed, 1 May 2024 15:25:26 -0700
 Subject: [PATCH] Use an explicit x86-64 cpu in tests that are sensitive to it
 There are a few tests that depend on some target features **not** being
 enabled by default, and usually they are correct with the default x86-64
 target CPU. However, in downstream builds we have modified the default
 to fit our distros -- `x86-64-v2` in RHEL 9 and `x86-64-v3` in RHEL 10
 -- and the latter especially trips tests that expect not to have AVX.
 These cases are few enough that we can just set them back explicitly.
 ---
 tests/assembly/simd-intrinsic-mask-reduce.rs  |  1 +
 tests/assembly/x86_64-floating-point-clamp.rs |  2 +-
 .../codegen/target-feature-inline-closure.rs  |  2 +-
 tests/ui/asm/x86_64/target-feature-attr.rs    |  1 +
 .../ui/asm/x86_64/target-feature-attr.stderr  |  8 +++---
 .../const-eval/const_fn_target_feature.rs     |  2 +-
 .../rfc-2396-target_feature-11/safe-calls.rs  |  1 +
 .../safe-calls.stderr                         | 28 +++++++++----------
 tests/ui/sse2.rs                              |  4 +--
 9 files changed, 26 insertions(+), 23 deletions(-)
 diff --git a/tests/assembly/simd-intrinsic-mask-reduce.rs b/tests/assembly/simd-intrinsic-mask-reduce.rs
 index 763401755fad..0d77fc410511 100644
 --- a/tests/assembly/simd-intrinsic-mask-reduce.rs
 +++ b/tests/assembly/simd-intrinsic-mask-reduce.rs
@@ -1,6 +1,7 @@
 // verify that simd mask reductions do not introduce additional bit shift operations
 //@ revisions: x86 aarch64
 //@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 +//@ [x86] compile-flags: -C target-cpu=x86-64
 //@ [x86] needs-llvm-components: x86
 //@ [aarch64] compile-flags: --target=aarch64-unknown-linux-gnu
 //@ [aarch64] needs-llvm-components: aarch64
 diff --git a/tests/assembly/x86_64-floating-point-clamp.rs b/tests/assembly/x86_64-floating-point-clamp.rs
 index 4a72a7f44fa0..b963aee35590 100644
 --- a/tests/assembly/x86_64-floating-point-clamp.rs
 +++ b/tests/assembly/x86_64-floating-point-clamp.rs
@@ -2,7 +2,7 @@
 // so check to make sure that's what it's actually emitting.
 //@ assembly-output: emit-asm
 -//@ compile-flags: --crate-type=lib -O -C llvm-args=-x86-asm-syntax=intel
 +//@ compile-flags: --crate-type=lib -O -C llvm-args=-x86-asm-syntax=intel -C target-cpu=x86-64
 //@ only-x86_64
 //@ ignore-sgx
 diff --git a/tests/codegen/target-feature-inline-closure.rs b/tests/codegen/target-feature-inline-closure.rs
 index 88bd413a8707..20bb4e66ff21 100644
 --- a/tests/codegen/target-feature-inline-closure.rs
 +++ b/tests/codegen/target-feature-inline-closure.rs
@@ -1,5 +1,5 @@
 //@ only-x86_64
 -//@ compile-flags: -Copt-level=3
 +//@ compile-flags: -Copt-level=3 -Ctarget-cpu=x86-64
 #![crate_type = "lib"]
 #![feature(target_feature_11)]
 diff --git a/tests/ui/asm/x86_64/target-feature-attr.rs b/tests/ui/asm/x86_64/target-feature-attr.rs
 index 820be132ef79..51829be15065 100644
 --- a/tests/ui/asm/x86_64/target-feature-attr.rs
 +++ b/tests/ui/asm/x86_64/target-feature-attr.rs
@@ -1,4 +1,5 @@
 //@ only-x86_64
 +//@ compile-flags: -C target-cpu=x86-64
 #![feature(avx512_target_feature)]
 diff --git a/tests/ui/asm/x86_64/target-feature-attr.stderr b/tests/ui/asm/x86_64/target-feature-attr.stderr
 index c852726ee7ff..1a9962732cfb 100644
 --- a/tests/ui/asm/x86_64/target-feature-attr.stderr
 +++ b/tests/ui/asm/x86_64/target-feature-attr.stderr
@@ -1,23 +1,23 @@
 error: register class `ymm_reg` requires the `avx` target feature
 -  --> $DIR/target-feature-attr.rs:18:40
 +  --> $DIR/target-feature-attr.rs:19:40
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                        ^^^^^^^^^^^^^
 error: register class `ymm_reg` requires the `avx` target feature
 -  --> $DIR/target-feature-attr.rs:18:55
 +  --> $DIR/target-feature-attr.rs:19:55
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                                       ^^^^^^^^^^^^^
 error: register class `ymm_reg` requires the `avx` target feature
 -  --> $DIR/target-feature-attr.rs:18:70
 +  --> $DIR/target-feature-attr.rs:19:70
    |
 LL |     asm!("vaddps {2:y}, {0:y}, {1:y}", in(ymm_reg) x, in(ymm_reg) y, lateout(ymm_reg) x);
    |                                                                      ^^^^^^^^^^^^^^^^^^
 error: register class `kreg` requires at least one of the following target features: avx512bw, avx512f
 -  --> $DIR/target-feature-attr.rs:33:23
 +  --> $DIR/target-feature-attr.rs:34:23
    |
 LL |     asm!("/* {0} */", in(kreg) x);
    |                       ^^^^^^^^^^
 diff --git a/tests/ui/consts/const-eval/const_fn_target_feature.rs b/tests/ui/consts/const-eval/const_fn_target_feature.rs
 index b56b68a57958..d0de9d8d7a34 100644
 --- a/tests/ui/consts/const-eval/const_fn_target_feature.rs
 +++ b/tests/ui/consts/const-eval/const_fn_target_feature.rs
@@ -1,5 +1,5 @@
 //@ only-x86_64
 -//@ compile-flags:-C target-feature=+ssse3
 +//@ compile-flags: -C target-cpu=x86-64 -C target-feature=+ssse3
 #![crate_type = "lib"]
 diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.rs b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.rs
 index c73b8d7e4d29..6fb0688008e6 100644
 --- a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.rs
 +++ b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.rs
@@ -1,4 +1,5 @@
 //@ only-x86_64
 +//@ compile-flags: -C target-cpu=x86-64
 #![feature(target_feature_11)]
 diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
 index d9d7e297f8e9..fed3da6594cb 100644
 --- a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
 +++ b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
@@ -1,5 +1,5 @@
 error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:25:5
 +  --> $DIR/safe-calls.rs:26:5
    |
 LL |     sse2();
    |     ^^^^^^ call to function with `#[target_feature]`
@@ -8,7 +8,7 @@ LL |     sse2();
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 error[E0133]: call to function `avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:27:5
 +  --> $DIR/safe-calls.rs:28:5
    |
 LL |     avx_bmi2();
    |     ^^^^^^^^^^ call to function with `#[target_feature]`
@@ -16,7 +16,7 @@ LL |     avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target features: avx and bmi2
 error[E0133]: call to function `Quux::avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:29:5
 +  --> $DIR/safe-calls.rs:30:5
    |
 LL |     Quux.avx_bmi2();
    |     ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
@@ -24,7 +24,7 @@ LL |     Quux.avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target features: avx and bmi2
 error[E0133]: call to function `avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:35:5
 +  --> $DIR/safe-calls.rs:36:5
    |
 LL |     avx_bmi2();
    |     ^^^^^^^^^^ call to function with `#[target_feature]`
@@ -32,7 +32,7 @@ LL |     avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target features: avx and bmi2
 error[E0133]: call to function `Quux::avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:37:5
 +  --> $DIR/safe-calls.rs:38:5
    |
 LL |     Quux.avx_bmi2();
    |     ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
@@ -40,7 +40,7 @@ LL |     Quux.avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target features: avx and bmi2
 error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:43:5
 +  --> $DIR/safe-calls.rs:44:5
    |
 LL |     sse2();
    |     ^^^^^^ call to function with `#[target_feature]`
@@ -49,7 +49,7 @@ LL |     sse2();
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 error[E0133]: call to function `avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:45:5
 +  --> $DIR/safe-calls.rs:46:5
    |
 LL |     avx_bmi2();
    |     ^^^^^^^^^^ call to function with `#[target_feature]`
@@ -57,7 +57,7 @@ LL |     avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target feature: bmi2
 error[E0133]: call to function `Quux::avx_bmi2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:47:5
 +  --> $DIR/safe-calls.rs:48:5
    |
 LL |     Quux.avx_bmi2();
    |     ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
@@ -65,7 +65,7 @@ LL |     Quux.avx_bmi2();
    = help: in order for the call to be safe, the context requires the following additional target feature: bmi2
 error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:54:5
 +  --> $DIR/safe-calls.rs:55:5
    |
 LL |     sse2();
    |     ^^^^^^ call to function with `#[target_feature]`
@@ -74,7 +74,7 @@ LL |     sse2();
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:58:15
 +  --> $DIR/safe-calls.rs:59:15
    |
 LL | const _: () = sse2();
    |               ^^^^^^ call to function with `#[target_feature]`
@@ -83,7 +83,7 @@ LL | const _: () = sse2();
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 error[E0133]: call to function `sse2_and_fxsr` with `#[target_feature]` is unsafe and requires unsafe function or block
 -  --> $DIR/safe-calls.rs:61:15
 +  --> $DIR/safe-calls.rs:62:15
    |
 LL | const _: () = sse2_and_fxsr();
    |               ^^^^^^^^^^^^^^^ call to function with `#[target_feature]`
@@ -92,7 +92,7 @@ LL | const _: () = sse2_and_fxsr();
    = note: the fxsr and sse2 target features being enabled in the build configuration does not remove the requirement to list them in `#[target_feature]`
 error: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe block (error E0133)
 -  --> $DIR/safe-calls.rs:68:5
 +  --> $DIR/safe-calls.rs:69:5
    |
 LL |     sse2();
    |     ^^^^^^ call to function with `#[target_feature]`
@@ -101,12 +101,12 @@ LL |     sse2();
    = help: in order for the call to be safe, the context requires the following additional target feature: sse2
    = note: the sse2 target feature being enabled in the build configuration does not remove the requirement to list it in `#[target_feature]`
 note: an unsafe function restricts its caller, but its body is safe by default
 -  --> $DIR/safe-calls.rs:67:1
 +  --> $DIR/safe-calls.rs:68:1
    |
 LL | unsafe fn needs_unsafe_block() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: the lint level is defined here
 -  --> $DIR/safe-calls.rs:64:8
 +  --> $DIR/safe-calls.rs:65:8
    |
 LL | #[deny(unsafe_op_in_unsafe_fn)]
    |        ^^^^^^^^^^^^^^^^^^^^^^
 diff --git a/tests/ui/sse2.rs b/tests/ui/sse2.rs
 index fa6d79713b4b..c203ca2716ff 100644
 --- a/tests/ui/sse2.rs
 +++ b/tests/ui/sse2.rs
@@ -20,6 +20,6 @@ fn main() {
                 "SSE2 was not detected as available on an x86 platform");
     }
     // check a negative case too -- allowed on x86, but not enabled by default
 -    assert!(cfg!(not(target_feature = "avx2")),
 -            "AVX2 shouldn't be detected as available by default on any platform");
 +    assert!(cfg!(not(target_feature = "avx512f")),
 +            "AVX512 shouldn't be detected as available by default on any platform");
 }
 -- 
 2.44.0
--- a/SOURCES/0001-Use-lld-provided-by-system-for-wasm.patch
+++ b/SOURCES/0001-Use-lld-provided-by-system-for-wasm.patch
@ -0,0 +1,26 @@
 From 37cb177eb53145103ae72b67562884782dde01c3 Mon Sep 17 00:00:00 2001
 From: Ivan Mironov <mironov.ivan@gmail.com>
 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
--- a/SOURCES/0001-Use-lld-provided-by-system.patch
+++ b/SOURCES/0001-Use-lld-provided-by-system.patch
@ -1,65 +0,0 @@
 From 61b5cc96337da2121221dd1bcdb63fd36551d065 Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 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
 diff -Naur a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs
 --- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs	2024-03-17 12:03:00.000000000 -0700
 +++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_none_softfloat.rs	2024-03-22 10:02:17.742806274 -0700
@@ -14,7 +14,7 @@
     let opts = TargetOptions {
         abi: "softfloat".into(),
         linker_flavor: LinkerFlavor::Gnu(Cc::No, Lld::Yes),
 -        linker: Some("rust-lld".into()),
 +        linker: Some("lld".into()),
         features: "+v8a,+strict-align,-neon,-fp-armv8".into(),
         relocation_model: RelocModel::Static,
         disable_redzone: true,
 -- 
 2.41.0
--- a/SOURCES/0001-bootstrap-allow-disabling-target-self-contained.patch
+++ b/SOURCES/0001-bootstrap-allow-disabling-target-self-contained.patch
@ -1,102 +0,0 @@
 From 2b99134e2884fa56bcab6d360885ec5421048e66 Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 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 f94553dd63f7..5ec969c80a37 100644
 --- a/config.example.toml
 +++ b/config.example.toml
@@ -869,6 +869,11 @@
 # argument as the test binary.
 #runner = <none> (string)
 +# 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 = <platform-specific> (bool)
 +
 # =============================================================================
 # Distribution options
 #
 diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
 index e927b491c71e..69a80d01d6b9 100644
 --- a/src/bootstrap/src/core/build_steps/compile.rs
 +++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -356,6 +356,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 3e1bc9a9acdd..5e24a9cc4f60 100644
 --- a/src/bootstrap/src/core/config/config.rs
 +++ b/src/bootstrap/src/core/config/config.rs
@@ -586,6 +586,7 @@ pub struct Target {
     pub runner: Option<String>,
     pub no_std: bool,
     pub codegen_backends: Option<Vec<String>>,
 +    pub self_contained: bool,
 }
 impl Target {
@@ -594,6 +595,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
     }
 }
@@ -1150,6 +1154,7 @@ struct TomlTarget {
         no_std: Option<bool> = "no-std",
         codegen_backends: Option<Vec<String>> = "codegen-backends",
         runner: Option<String> = "runner",
 +        self_contained: Option<bool> = "self-contained",
     }
 }
@@ -1870,6 +1875,9 @@ fn get_table(option: &str) -> Result<TomlConfig, toml::de::Error> {
                 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 5ed6b357e20a..c23b21d65713 100644
 --- a/src/bootstrap/src/lib.rs
 +++ b/src/bootstrap/src/lib.rs
@@ -1348,6 +1348,11 @@ fn no_std(&self, target: TargetSelection) -> Option<bool> {
         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<bool> {
 +        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.44.0
--- a/SOURCES/0001-compiletest-set-the-dylib-path-when-gathering-target.patch
+++ b/SOURCES/0001-compiletest-set-the-dylib-path-when-gathering-target.patch
@ -0,0 +1,185 @@
 From 2bdbc5fbf7f84c62f8c7b1007f3b6fd6d3da06f6 Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 Date: Fri, 14 Oct 2022 16:11:28 -0700
 Subject: [PATCH] compiletest: set the dylib path when gathering target cfg
 If the compiler is built with `rpath = false`, then it won't find its
 own libraries unless the library search path is set. We already do that
 while running the actual compiletests, but #100260 added another rustc
 command for getting the target cfg.
    Check compiletest suite=codegen mode=codegen (x86_64-unknown-linux-gnu -> x86_64-unknown-linux-gnu)
    thread 'main' panicked at 'error: failed to get cfg info from "[...]/build/x86_64-unknown-linux-gnu/stage1/bin/rustc"
    --- stdout
    --- stderr
    [...]/build/x86_64-unknown-linux-gnu/stage1/bin/rustc: error while loading shared libraries: librustc_driver-a2a76dc626cd02d2.so: cannot open shared object file: No such file or directory
    ', src/tools/compiletest/src/common.rs:476:13
 Now the library path is set here as well, so it works without rpath.
 (cherry picked from commit f8a0cc2ca8a644ddb63867526711ba17cb7508c8)
 ---
 src/tools/compiletest/src/common.rs  | 20 +++++++++++---------
 src/tools/compiletest/src/runtest.rs | 27 +++------------------------
 src/tools/compiletest/src/util.rs    | 23 +++++++++++++++++++++++
 3 files changed, 37 insertions(+), 33 deletions(-)
 diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
 index 0260f6848386..9a432f11f82f 100644
 --- a/src/tools/compiletest/src/common.rs
 +++ b/src/tools/compiletest/src/common.rs
@@ -2,11 +2,12 @@
 use std::ffi::OsString;
 use std::fmt;
 +use std::iter;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str::FromStr;
 -use crate::util::PathBufExt;
 +use crate::util::{add_dylib_path, PathBufExt};
 use lazycell::LazyCell;
 use test::ColorConfig;
@@ -385,8 +386,7 @@ pub fn run_enabled(&self) -> bool {
     }
     fn target_cfg(&self) -> &TargetCfg {
 -        self.target_cfg
 -            .borrow_with(|| TargetCfg::new(&self.rustc_path, &self.target, &self.target_rustcflags))
 +        self.target_cfg.borrow_with(|| TargetCfg::new(self))
     }
     pub fn matches_arch(&self, arch: &str) -> bool {
@@ -457,21 +457,23 @@ pub enum Endian {
 }
 impl TargetCfg {
 -    fn new(rustc_path: &Path, target: &str, target_rustcflags: &Vec<String>) -> TargetCfg {
 -        let output = match Command::new(rustc_path)
 +    fn new(config: &Config) -> TargetCfg {
 +        let mut command = Command::new(&config.rustc_path);
 +        add_dylib_path(&mut command, iter::once(&config.compile_lib_path));
 +        let output = match command
             .arg("--print=cfg")
             .arg("--target")
 -            .arg(target)
 -            .args(target_rustcflags)
 +            .arg(&config.target)
 +            .args(&config.target_rustcflags)
             .output()
         {
             Ok(output) => output,
 -            Err(e) => panic!("error: failed to get cfg info from {:?}: {e}", rustc_path),
 +            Err(e) => panic!("error: failed to get cfg info from {:?}: {e}", config.rustc_path),
         };
         if !output.status.success() {
             panic!(
                 "error: failed to get cfg info from {:?}\n--- stdout\n{}\n--- stderr\n{}",
 -                rustc_path,
 +                config.rustc_path,
                 String::from_utf8(output.stdout).unwrap(),
                 String::from_utf8(output.stderr).unwrap(),
             );
 diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
 index 8af5f1da694b..f8903f754f09 100644
 --- a/src/tools/compiletest/src/runtest.rs
 +++ b/src/tools/compiletest/src/runtest.rs
@@ -13,7 +13,7 @@
 use crate::header::TestProps;
 use crate::json;
 use crate::read2::read2_abbreviated;
 -use crate::util::{logv, PathBufExt};
 +use crate::util::{add_dylib_path, dylib_env_var, logv, PathBufExt};
 use crate::ColorConfig;
 use regex::{Captures, Regex};
 use rustfix::{apply_suggestions, get_suggestions_from_json, Filter};
@@ -26,6 +26,7 @@
 use std::hash::{Hash, Hasher};
 use std::io::prelude::*;
 use std::io::{self, BufReader};
 +use std::iter;
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, ExitStatus, Output, Stdio};
 use std::str;
@@ -72,19 +73,6 @@ fn disable_error_reporting<F: FnOnce() -> R, R>(f: F) -> R {
     f()
 }
 -/// The name of the environment variable that holds dynamic library locations.
 -pub fn dylib_env_var() -> &'static str {
 -    if cfg!(windows) {
 -        "PATH"
 -    } else if cfg!(target_os = "macos") {
 -        "DYLD_LIBRARY_PATH"
 -    } else if cfg!(target_os = "haiku") {
 -        "LIBRARY_PATH"
 -    } else {
 -        "LD_LIBRARY_PATH"
 -    }
 -}
 -
 /// The platform-specific library name
 pub fn get_lib_name(lib: &str, dylib: bool) -> String {
     // In some casess (e.g. MUSL), we build a static
@@ -1811,16 +1799,7 @@ fn compose_and_run(
         // Need to be sure to put both the lib_path and the aux path in the dylib
         // search path for the child.
 -        let mut path =
 -            env::split_paths(&env::var_os(dylib_env_var()).unwrap_or_default()).collect::<Vec<_>>();
 -        if let Some(p) = aux_path {
 -            path.insert(0, PathBuf::from(p))
 -        }
 -        path.insert(0, PathBuf::from(lib_path));
 -
 -        // Add the new dylib search path var
 -        let newpath = env::join_paths(&path).unwrap();
 -        command.env(dylib_env_var(), newpath);
 +        add_dylib_path(&mut command, iter::once(lib_path).chain(aux_path));
         let mut child = disable_error_reporting(|| command.spawn())
             .unwrap_or_else(|_| panic!("failed to exec `{:?}`", &command));
 diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs
 index e5ff0906be8a..ec36f1e4fb72 100644
 --- a/src/tools/compiletest/src/util.rs
 +++ b/src/tools/compiletest/src/util.rs
@@ -2,6 +2,7 @@
 use std::env;
 use std::ffi::OsStr;
 use std::path::PathBuf;
 +use std::process::Command;
 use tracing::*;
@@ -111,3 +112,25 @@ fn with_extra_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {
         }
     }
 }
 +
 +/// The name of the environment variable that holds dynamic library locations.
 +pub fn dylib_env_var() -> &'static str {
 +    if cfg!(windows) {
 +        "PATH"
 +    } else if cfg!(target_os = "macos") {
 +        "DYLD_LIBRARY_PATH"
 +    } else if cfg!(target_os = "haiku") {
 +        "LIBRARY_PATH"
 +    } else {
 +        "LD_LIBRARY_PATH"
 +    }
 +}
 +
 +/// Adds a list of lookup paths to `cmd`'s dynamic library lookup path.
 +/// If the dylib_path_var is already set for this cmd, the old value will be overwritten!
 +pub fn add_dylib_path(cmd: &mut Command, paths: impl Iterator<Item = impl Into<PathBuf>>) {
 +    let path_env = env::var_os(dylib_env_var());
 +    let old_paths = path_env.as_ref().map(env::split_paths);
 +    let new_paths = paths.map(Into::into).chain(old_paths.into_iter().flatten());
 +    cmd.env(dylib_env_var(), env::join_paths(new_paths).unwrap());
 +}
 -- 
 2.38.1
--- a/SOURCES/0002-set-an-external-library-path-for-wasm32-wasi.patch
+++ b/SOURCES/0002-set-an-external-library-path-for-wasm32-wasi.patch
@ -1,97 +0,0 @@
 From e3b7d2e3d3b4fcbc6591de606957c0fd59b5e547 Mon Sep 17 00:00:00 2001
 From: Josh Stone <jistone@redhat.com>
 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                   | 4 ++++
 compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs | 7 ++++---
 3 files changed, 17 insertions(+), 3 deletions(-)
 diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
 index f5e8d5fc92a9..f4ad3f725427 100644
 --- a/compiler/rustc_codegen_ssa/src/back/link.rs
 +++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1563,6 +1563,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() {
@@ -2049,6 +2055,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 941d767b850d..cd0a2ce51989 100644
 --- a/compiler/rustc_target/src/spec/mod.rs
 +++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1881,6 +1881,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<StaticCow<str>>,
     /// 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,
@@ -2368,6 +2369,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,
@@ -3064,6 +3066,7 @@ macro_rules! key {
         key!(linker_is_gnu_json = "linker-is-gnu", bool);
         key!(pre_link_objects = "pre-link-objects", link_objects);
         key!(post_link_objects = "post-link-objects", link_objects);
 +        key!(external_lib_path, optional);
         key!(pre_link_objects_self_contained = "pre-link-objects-fallback", link_objects);
         key!(post_link_objects_self_contained = "post-link-objects-fallback", link_objects);
         // Deserializes the backwards-compatible variants of `-Clink-self-contained`
@@ -3327,6 +3330,7 @@ macro_rules! target_option_val {
         target_option_val!(linker_is_gnu_json, "linker-is-gnu");
         target_option_val!(pre_link_objects);
         target_option_val!(post_link_objects);
 +        target_option_val!(external_lib_path);
         target_option_val!(pre_link_objects_self_contained, "pre-link-objects-fallback");
         target_option_val!(post_link_objects_self_contained, "post-link-objects-fallback");
         target_option_val!(link_args - pre_link_args_json, "pre-link-args");
 diff --git a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs
 index 7cbe9f09e6ca..b524890c2ec5 100644
 --- a/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs
 +++ b/compiler/rustc_target/src/spec/targets/wasm32_wasip1.rs
@@ -20,11 +20,12 @@ pub fn target() -> Target {
     options.os = "wasi".into();
     options.add_pre_link_args(LinkerFlavor::WasmLld(Cc::Yes), &["--target=wasm32-wasi"]);
 -    options.pre_link_objects_self_contained = crt_objects::pre_wasi_self_contained();
 -    options.post_link_objects_self_contained = crt_objects::post_wasi_self_contained();
 +    options.pre_link_objects = crt_objects::pre_wasi_self_contained();
 +    options.post_link_objects = 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.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.44.0
--- a/SOURCES/cargo_vendor.attr
+++ b/SOURCES/cargo_vendor.attr
@ -1,2 +0,0 @@
 %__cargo_vendor_path     ^%{_defaultlicensedir}(/[^/]+)+/cargo-vendor.txt$
 %__cargo_vendor_provides %{_rpmconfigdir}/cargo_vendor.prov
--- a/SOURCES/cargo_vendor.prov
+++ b/SOURCES/cargo_vendor.prov
@ -1,127 +0,0 @@
 #! /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"""
    ^
    (?P<major>0|[1-9]\d*)
    \.(?P<minor>0|[1-9]\d*)
    \.(?P<patch>0|[1-9]\d*)
    (?:-(?P<pre>(?: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<build>[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()
--- a/SOURCES/macros.rust-toolset
+++ b/SOURCES/macros.rust-toolset
@ -1,92 +1,29 @@
-# __rustc: path to the default rustc executable
+# Explicitly use bindir tools, in case others are in the PATH,
-%__rustc /usr/bin/rustc
+# 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
-# __rustdoc: path to the default rustdoc executable
+# Enable optimization, debuginfo, and link hardening.
-%__rustdoc /usr/bin/rustdoc
+%__global_rustflags -Copt-level=3 -Cdebuginfo=2 -Clink-arg=-Wl,-z,relro,-z,now
-# rustflags_opt_level: default optimization level
+%__global_rustflags_toml [%{lua:
-#
+    for arg in string.gmatch(rpm.expand("%{__global_rustflags}"), "%S+") do
-# It corresponds to the "-Copt-level" rustc command line option.
+        print('"' .. arg .. '", ')
-%rustflags_opt_level 3
+    end}]
-# rustflags_debuginfo: default verbosity of debug information
+%cargo_prep(V:) (\
-#
+%{__mkdir} -p .cargo \
-# It corresponds to the "-Cdebuginfo" rustc command line option.
+cat > .cargo/config << EOF \
 # 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)
 #
 # 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
 }
 # __cargo: cargo command with environment variables
 #
 # CARGO_HOME: This ensures cargo reads configuration file from .cargo/config.toml,
 #       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.toml"
 # - 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 <number>    - unpack and use vendored sources from Source<number> tarball
 #                    (deprecated; use -v instead)
 #   -v <directory> - use vendored sources from <directory>
 #   -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.toml << 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}"\
@ -94,154 +31,21 @@ root = "%{buildroot}%{_prefix}"\
 [term]\
 verbose = true\
 EOF\
-%{-V:%{__tar} -xoaf %{S:%{-V*}}}\
+%if 0%{-V:1}\
-%{!?-N:\
+%{__tar} -xoaf %{S:%{-V*}}\
-cat >> .cargo/config.toml << EOF\
+cat >> .cargo/config << EOF \
 [source.vendored-sources]\
 directory = "%{-v*}%{-V:./vendor}"\
 \
 [source.crates-io]\
 registry = "https://crates.io"\
 replace-with = "vendored-sources"\
-EOF}\
+\
-%{__rm} -f Cargo.toml.orig\
+[source.vendored-sources]\
 directory = "./vendor"\
 EOF\
 %endif\
 )
-# __cargo_parse_opts: function-like macro which parses common flags into the
+%cargo_build %__cargo build --release %{?_smp_mflags}
 #       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}                                                      \
 }
-# NB: cargo_build/test/install do not use the -n/-a/-f argument parsing like
+%cargo_test %__cargo test --release %{?_smp_mflags} --no-fail-fast
 # Fedora's rust-packaging, because that change would break anyone that's
 # already passing arguments directly to cargo after the macro. Instead, one can
 # explicitly use --no-default-features, --all-features, or --features XYZ.
 # cargo_build: builds the crate with cargo
 %cargo_build\
 %{shrink:                                               \
    %{__cargo} build                                    \
    %{__cargo_common_opts}                              \
    --profile rpm                                       \
 }
 # cargo_test: runs the test suite with cargo
 #
 # To pass command-line arguments to the cargo test runners directly (for
 # example, to skip certain tests during package builds), the
 # "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\
 %{shrink:                                               \
    %{__cargo} test                                     \
    %{__cargo_common_opts}                              \
    --profile rpm                                       \
    --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\
 (\
 set -euo pipefail                                                   \
  %{shrink:                                                         \
    %{__cargo} install                                              \
      %{__cargo_common_opts}                                        \
      --profile rpm                                                 \
      --no-track                                                    \
      --path .                                                      \
  }                                                                 \
 )
 # 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 .
--- a/SOURCES/rustc-1.61.0-rust-gdb-substitute-path.patch
+++ b/SOURCES/rustc-1.61.0-rust-gdb-substitute-path.patch
@ -0,0 +1,18 @@
 --- rustc-1.61.0-src/src/etc/rust-gdb.orig	2022-05-17 18:29:36.000000000 -0700
 +++ rustc-1.61.0-src/src/etc/rust-gdb	2022-05-18 11:18:13.732709661 -0700
@@ -14,6 +14,9 @@ fi
 RUSTC_SYSROOT="$("$RUSTC" --print=sysroot)"
 GDB_PYTHON_MODULE_DIRECTORY="$RUSTC_SYSROOT/lib/rustlib/etc"
 +RUST_STD_BUILD="@BUILDDIR@/library/"
 +RUST_STD_SRC="$RUSTC_SYSROOT/lib/rustlib/src/rust/library/"
 +
 # Run GDB with the additional arguments that load the pretty printers
 # Set the environment variable `RUST_GDB` to overwrite the call to a
 # different/specific command (defaults to `gdb`).
@@ -21,4 +24,5 @@ RUST_GDB="${RUST_GDB:-gdb}"
 PYTHONPATH="$PYTHONPATH:$GDB_PYTHON_MODULE_DIRECTORY" exec ${RUST_GDB} \
   --directory="$GDB_PYTHON_MODULE_DIRECTORY" \
   -iex "add-auto-load-safe-path $GDB_PYTHON_MODULE_DIRECTORY" \
 +  -iex "set substitute-path $RUST_STD_BUILD $RUST_STD_SRC" \
   "$@"
--- a/SOURCES/rustc-1.65.0-disable-http2.patch
+++ b/SOURCES/rustc-1.65.0-disable-http2.patch
@ -0,0 +1,90 @@
 --- rustc-beta-src/Cargo.lock.orig	2022-10-04 10:55:48.797517289 -0700
 +++ rustc-beta-src/Cargo.lock	2022-10-04 10:55:48.799517248 -0700
@@ -1026,7 +1026,6 @@
 dependencies = [
  "cc",
  "libc",
 - "libnghttp2-sys",
  "libz-sys",
  "openssl-sys",
  "pkg-config",
@@ -1993,16 +1992,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	2022-10-04 10:55:48.799517248 -0700
 +++ rustc-beta-src/src/tools/cargo/Cargo.toml	2022-10-04 11:00:55.057162743 -0700
@@ -21,7 +21,7 @@
 cargo-platform = { path = "crates/cargo-platform", version = "0.1.2" }
 cargo-util = { path = "crates/cargo-util", version = "0.2.1" }
 crates-io = { path = "crates/crates-io", version = "0.34.0" }
 -curl = { version = "0.4.43", features = ["http2"] }
 +curl = { version = "0.4.43", features = [] }
 curl-sys = "0.4.55"
 env_logger = "0.9.0"
 pretty_env_logger = { version = "0.4", optional = true }
 --- rustc-beta-src/src/tools/cargo/src/cargo/sources/registry/http_remote.rs.orig	2022-09-24 10:23:17.000000000 -0700
 +++ rustc-beta-src/src/tools/cargo/src/cargo/sources/registry/http_remote.rs	2022-10-04 10:55:48.799517248 -0700
@@ -192,16 +192,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/core/package.rs.orig	2022-09-24 10:23:17.000000000 -0700
 +++ rustc-beta-src/src/tools/cargo/src/cargo/core/package.rs	2022-10-04 10:55:48.800517227 -0700
@@ -403,16 +403,9 @@
         sources: SourceMap<'cfg>,
         config: &'cfg Config,
     ) -> CargoResult<PackageSet<'cfg>> {
 -        // 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
@@ -658,7 +651,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);
             }
--- a/SOURCES/rustc-1.65.0-disable-libssh2.patch
+++ b/SOURCES/rustc-1.65.0-disable-libssh2.patch
@ -0,0 +1,43 @@
 --- 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",
--- a/SOURCES/rustc-1.65.0-no-default-pie.patch
+++ b/SOURCES/rustc-1.65.0-no-default-pie.patch
@ -0,0 +1,43 @@
 --- rustc-beta-src/compiler/rustc_codegen_ssa/src/back/link.rs.orig	2022-09-24 10:20:14.000000000 -0700
 +++ rustc-beta-src/compiler/rustc_codegen_ssa/src/back/link.rs	2022-10-05 11:24:21.759564185 -0700
@@ -755,7 +755,7 @@
             && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-no-pie")
         {
             info!("linker output: {:?}", out);
 -            warn!("Linker does not support -no-pie command line option. Retrying without.");
 +            info!("Linker does not support -no-pie command line option. Retrying without.");
             for arg in cmd.take_args() {
                 if arg.to_string_lossy() != "-no-pie" {
                     cmd.arg(arg);
@@ -774,7 +774,7 @@
             && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-static-pie")
         {
             info!("linker output: {:?}", out);
 -            warn!(
 +            info!(
                 "Linker does not support -static-pie command line option. Retrying with -static instead."
             );
             // Mirror `add_(pre,post)_link_objects` to replace CRT objects.
@@ -1520,15 +1520,15 @@
 }
 fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind {
 -    let kind = match (crate_type, sess.crt_static(Some(crate_type)), sess.relocation_model()) {
 +    // Only use PIE if explicitly specified.
 +    #[allow(rustc::bad_opt_access)]
 +    let explicit_pic =
 +        matches!(sess.opts.cg.relocation_model, Some(RelocModel::Pic | RelocModel::Pie));
 +    let kind = match (crate_type, sess.crt_static(Some(crate_type)), explicit_pic) {
         (CrateType::Executable, _, _) if sess.is_wasi_reactor() => LinkOutputKind::WasiReactorExe,
 -        (CrateType::Executable, false, RelocModel::Pic | RelocModel::Pie) => {
 -            LinkOutputKind::DynamicPicExe
 -        }
 +        (CrateType::Executable, false, true) => LinkOutputKind::DynamicPicExe,
         (CrateType::Executable, false, _) => LinkOutputKind::DynamicNoPicExe,
 -        (CrateType::Executable, true, RelocModel::Pic | RelocModel::Pie) => {
 -            LinkOutputKind::StaticPicExe
 -        }
 +        (CrateType::Executable, true, true) => LinkOutputKind::StaticPicExe,
         (CrateType::Executable, true, _) => LinkOutputKind::StaticNoPicExe,
         (_, true, _) => LinkOutputKind::StaticDylib,
         (_, false, _) => LinkOutputKind::DynamicDylib,
--- a/SOURCES/rustc-1.70.0-rust-gdb-substitute-path.patch
+++ b/SOURCES/rustc-1.70.0-rust-gdb-substitute-path.patch
@ -1,21 +0,0 @@
 diff --git a/src/etc/rust-gdb b/src/etc/rust-gdb
 index 9abed30ea6f7..e4bf55df3688 100755
 --- a/src/etc/rust-gdb
 +++ b/src/etc/rust-gdb
@@ -13,8 +13,6 @@ fi
 # Find out where the pretty printer Python module is
 RUSTC_SYSROOT="$("$RUSTC" --print=sysroot)"
 GDB_PYTHON_MODULE_DIRECTORY="$RUSTC_SYSROOT/lib/rustlib/etc"
 -# Get the commit hash for path remapping
 -RUSTC_COMMIT_HASH="$("$RUSTC" -vV | sed -n 's/commit-hash: \([a-zA-Z0-9_]*\)/\1/p')"
 # Run GDB with the additional arguments that load the pretty printers
 # Set the environment variable `RUST_GDB` to overwrite the call to a
@@ -23,6 +21,6 @@ RUST_GDB="${RUST_GDB:-gdb}"
 PYTHONPATH="$PYTHONPATH:$GDB_PYTHON_MODULE_DIRECTORY" exec ${RUST_GDB} \
   --directory="$GDB_PYTHON_MODULE_DIRECTORY" \
   -iex "add-auto-load-safe-path $GDB_PYTHON_MODULE_DIRECTORY" \
 -  -iex "set substitute-path /rustc/$RUSTC_COMMIT_HASH $RUSTC_SYSROOT/lib/rustlib/src/rust" \
 +  -iex "set substitute-path @BUILDDIR@ $RUSTC_SYSROOT/lib/rustlib/src/rust" \
   "$@"
--- a/SOURCES/rustc-1.79.0-disable-libssh2.patch
+++ b/SOURCES/rustc-1.79.0-disable-libssh2.patch
@ -1,44 +0,0 @@
 diff -up rustc-1.79.0-src/src/tools/cargo/Cargo.lock.orig rustc-1.79.0-src/src/tools/cargo/Cargo.lock
 --- rustc-1.79.0-src/src/tools/cargo/Cargo.lock.orig	2024-06-13 16:37:16.640599290 -0700
 +++ rustc-1.79.0-src/src/tools/cargo/Cargo.lock	2024-06-13 16:37:16.646599231 -0700
@@ -2150,7 +2150,6 @@ checksum = "ee4126d8b4ee5c9d9ea891dd875c
 dependencies = [
  "cc",
  "libc",
 - "libssh2-sys",
  "libz-sys",
  "openssl-sys",
  "pkg-config",
@@ -2191,20 +2190,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-1.79.0-src/src/tools/cargo/Cargo.toml.orig rustc-1.79.0-src/src/tools/cargo/Cargo.toml
 --- rustc-1.79.0-src/src/tools/cargo/Cargo.toml.orig	2024-06-13 16:37:16.646599231 -0700
 +++ rustc-1.79.0-src/src/tools/cargo/Cargo.toml	2024-06-13 16:39:06.040526596 -0700
@@ -44,7 +44,7 @@ curl = "0.4.46"
 curl-sys = "0.4.72"
 filetime = "0.2.23"
 flate2 = { version = "1.0.28", default-features = false, features = ["zlib"] }
 -git2 = "0.18.3"
 +git2 = { version = "0.18.3", default-features = false, features = ["https"] }
 git2-curl = "0.19.0"
 gix = { version = "0.63.0", default-features = false, features = ["blocking-http-transport-curl", "progress-tree", "revision", "parallel", "dirwalk"] }
 glob = "0.3.1"
--- a/SOURCES/rustc-1.79.0-unbundle-sqlite.patch
+++ b/SOURCES/rustc-1.79.0-unbundle-sqlite.patch
@ -1,23 +0,0 @@
 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	2006-07-24 10:21:28.000000000 +0900
 +++ rustc-beta-src/src/tools/cargo/Cargo.lock	2024-05-06 14:13:00.172595245 +0900
@@ -2191,7 +2191,6 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
 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-05-06 14:13:00.173595257 +0900
 +++ rustc-beta-src/src/tools/cargo/Cargo.toml	2024-05-06 14:13:54.089275003 +0900
@@ -77,7 +77,7 @@ proptest = "1.4.0"
 pulldown-cmark = { version = "0.10.2", default-features = false, features = ["html"] }
 rand = "0.8.5"
 regex = "1.10.4"
 -rusqlite = { version = "0.31.0", features = ["bundled"] }
 +rusqlite = { version = "0.31.0", features = [] }
 rustfix = { version = "0.8.2", path = "crates/rustfix" }
 same-file = "1.0.6"
 security-framework = "2.10.0"
--- a/SPECS/rust.spec
+++ b/SPECS/rust.spec
`@ -1,2 +1,2 @@`
	`SOURCES/rustc-1.79.0-src.tar.xz`	`SOURCES/rustc-1.66.1-src.tar.xz`
	`SOURCES/wasi-libc-wasi-sdk-22.tar.gz`	`SOURCES/wasi-libc-wasi-sdk-17.tar.gz`
`@ -1,2 +1,2 @@`
	`fdd94a3bdb321d18a0021d4dce9b8546a1db2eec SOURCES/rustc-1.79.0-src.tar.xz`	`a8cc02cc11a942bddf67f1cfdcdd2bd867296f8e SOURCES/rustc-1.66.1-src.tar.xz`
	`13451249ddb71e69f12565ef4803b71ce4092191 SOURCES/wasi-libc-wasi-sdk-22.tar.gz`	`1f4561760c6c7e9f9f30c8cf0d156b8d551e04e2 SOURCES/wasi-libc-wasi-sdk-17.tar.gz`
		`@ -1,2 +0,0 @@`
			`%__cargo_vendor_path ^%{_defaultlicensedir}(/[^/]+)+/cargo-vendor.txt$`
			`%__cargo_vendor_provides %{_rpmconfigdir}/cargo_vendor.prov`