rust: 1.83.0

extra/rust/build

@@ -21,6 +21,7 @@ mv -f _ vendor/curl-sys-0.4.74+curl-8.9.0/.cargo-checksum.json
 cat > config.toml <<EOF
 [llvm]
 link-shared = true
+download-ci-llvm = false
 
 [build]
 build     = "x86_64-unknown-linux-musl"
@@ -65,7 +66,7 @@ EOF
         # This mimics the download process of rust's 'x.py'
         # bootstrap library to allow for the removal of the internet
         # connection requirement per build.
-        mkdir -p "${cache_dir:=build/cache/2024-09-05}"
+        mkdir -p "${cache_dir:=build/cache/2024-10-17}"
 
         for tarball in *.tar.xz\?no-extract; do
             mv -f "$tarball" "$cache_dir/${tarball%%\?no-extract}"

extra/rust/checksums

@@ -1,7 +1,6 @@
-42ffc0235c648e5559c4e99029aaeee1ba7d76392c27594bf1c3cc9570c8a50f4d
+4e6212077b9a4760b75d4d87392e1d7ccc0099a47698bacbd6b5377d1d5254841b
-bfe3cbea8ad275258a7a9d0bd46f9dc7a6d8adbaabe6257507e47c1dd4c129a52e
+b2f385e30700a6c30e0c598bedd1663935b4aa1436e2e322efe3cec457cfe258ff
-c5bc0fed9d73f8f5e3fddc7d0366b067e7c3ffce0df5ceb8c80d77537b929e9e86
+0ad6e2174f42dde6da3117027c226447b35116b9444b424ebceb41861cd1af9a0f
-ea13ff0a3533fc726daf004852371bff500ef1464617078ef04a0d63302532bf50
+1248a728a0ad46a2bf3e24a91489ec5eed0ca08f18e67a5bc3825e213fc62d63ba
 c03ac16dbb7aecb143e7cd701feb480862af63dbb044e0f0637eaff93758937fca
-90e39b7bc45b0d389a211a857374b121f52a173ceeecb48df345c77ce0c18a4f66
+fb0fef39b363d51813605394a68ba775dc6c9cc295bd9f9e718d0e13376bbdfcea
-891504d6dd8b3d7f463df9140850cd982a263ab485faf171496d3862c76b00bec2

extra/rust/patches/fix-linux_musl_base.patch

@@ -7,10 +7,10 @@ See https://github.com/rust-lang/rust/pull/40113
 --- a/compiler/rustc_target/src/spec/base/linux_musl.rs
 +++ b/compiler/rustc_target/src/spec/base/linux_musl.rs
 @@ -1,15 +1,12 @@
--use crate::spec::{base, crt_objects, LinkSelfContainedDefault, TargetOptions};
+-use crate::spec::{LinkSelfContainedDefault, TargetOptions, base, crt_objects};
 +use crate::spec::{base, TargetOptions};
  
- pub fn opts() -> TargetOptions {
+ pub(crate) fn opts() -> TargetOptions {
      let mut base = base::linux::opts();
  
      base.env = "musl".into();

extra/rust/patches/fix-llvm19.patch

@@ -1,242 +0,0 @@
-From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001
-From: Kyle Huey <khuey@kylehuey.com>
-Date: Mon, 4 Nov 2024 11:38:14 -0800
-Subject: [PATCH] Add discriminators to DILocations when multiple functions are
- inlined into a single point.
-
-LLVM does not expect to ever see multiple dbg_declares for the same variable at the same
-location with different values. proc-macros make it possible for arbitrary code,
-including multiple calls that get inlined, to happen at any given location in the source
-code. Add discriminators when that happens so these locations are different to LLVM.
-
-This may interfere with the AddDiscriminators pass in LLVM, which is added by the
-unstable flag -Zdebug-info-for-profiling.
-
-Fixes #131944
----
- .../src/debuginfo/create_scope_map.rs         | 60 ++++++++++++++++++-
- compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  4 ++
- .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  8 +++
- .../auxiliary/macro_def.rs                    | 11 ++++
- .../mir_inlined_twice_var_locs.rs             | 53 ++++++++++++++++
- 5 files changed, 133 insertions(+), 3 deletions(-)
- create mode 100644 tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
- create mode 100644 tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
-
-diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
-index ac6c2fb1b83a6..0f1909486ec7e 100644
---- a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
-+++ b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
-@@ -1,11 +1,15 @@
-+use std::collections::hash_map::Entry;
-+
- use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext};
- use rustc_codegen_ssa::traits::*;
-+use rustc_data_structures::fx::FxHashMap;
- use rustc_index::bit_set::BitSet;
- use rustc_index::Idx;
- use rustc_middle::mir::{Body, SourceScope};
- use rustc_middle::ty::layout::FnAbiOf;
- use rustc_middle::ty::{self, Instance};
- use rustc_session::config::DebugInfo;
-+use rustc_span::BytePos;
- 
- use super::metadata::file_metadata;
- use super::utils::DIB;
-@@ -37,10 +41,20 @@ pub(crate) fn compute_mir_scopes<'ll, 'tcx>(
-         None
-     };
-     let mut instantiated = BitSet::new_empty(mir.source_scopes.len());
-+    let mut discriminators = FxHashMap::default();
-     // Instantiate all scopes.
-     for idx in 0..mir.source_scopes.len() {
-         let scope = SourceScope::new(idx);
--        make_mir_scope(cx, instance, mir, &variables, debug_context, &mut instantiated, scope);
-+        make_mir_scope(
-+            cx,
-+            instance,
-+            mir,
-+            &variables,
-+            debug_context,
-+            &mut instantiated,
-+            &mut discriminators,
-+            scope,
-+        );
-     }
-     assert!(instantiated.count() == mir.source_scopes.len());
- }
-@@ -52,6 +66,7 @@ fn make_mir_scope<'ll, 'tcx>(
-     variables: &Option<BitSet<SourceScope>>,
-     debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>,
-     instantiated: &mut BitSet<SourceScope>,
-+    discriminators: &mut FxHashMap<BytePos, u32>,
-     scope: SourceScope,
- ) {
-     if instantiated.contains(scope) {
-@@ -60,7 +75,16 @@ fn make_mir_scope<'ll, 'tcx>(
- 
-     let scope_data = &mir.source_scopes[scope];
-     let parent_scope = if let Some(parent) = scope_data.parent_scope {
--        make_mir_scope(cx, instance, mir, variables, debug_context, instantiated, parent);
-+        make_mir_scope(
-+            cx,
-+            instance,
-+            mir,
-+            variables,
-+            debug_context,
-+            instantiated,
-+            discriminators,
-+            parent,
-+        );
-         debug_context.scopes[parent]
-     } else {
-         // The root is the function itself.
-@@ -117,7 +141,37 @@ fn make_mir_scope<'ll, 'tcx>(
-         // FIXME(eddyb) this doesn't account for the macro-related
-         // `Span` fixups that `rustc_codegen_ssa::mir::debuginfo` does.
-         let callsite_scope = parent_scope.adjust_dbg_scope_for_span(cx, callsite_span);
--        cx.dbg_loc(callsite_scope, parent_scope.inlined_at, callsite_span)
-+        let loc = cx.dbg_loc(callsite_scope, parent_scope.inlined_at, callsite_span);
-+
-+        // NB: In order to produce proper debug info for variables (particularly
-+        // arguments) in multiply-inline functions, LLVM expects to see a single
-+        // DILocalVariable with multiple different DILocations in the IR. While
-+        // the source information for each DILocation would be identical, their
-+        // inlinedAt attributes will be unique to the particular callsite.
-+        //
-+        // We generate DILocations here based on the callsite's location in the
-+        // source code. A single location in the source code usually can't
-+        // produce multiple distinct calls so this mostly works, until
-+        // proc-macros get involved. A proc-macro can generate multiple calls
-+        // at the same span, which breaks the assumption that we're going to
-+        // produce a unique DILocation for every scope we process here. We
-+        // have to explicitly add discriminators if we see inlines into the
-+        // same source code location.
-+        //
-+        // Note further that we can't key this hashtable on the span itself,
-+        // because these spans could have distinct SyntaxContexts. We have
-+        // to key on exactly what we're giving to LLVM.
-+        match discriminators.entry(callsite_span.lo()) {
-+            Entry::Occupied(mut o) => {
-+                *o.get_mut() += 1;
-+                unsafe { llvm::LLVMRustDILocationCloneWithBaseDiscriminator(loc, *o.get()) }
-+                    .expect("Failed to encode discriminator in DILocation")
-+            }
-+            Entry::Vacant(v) => {
-+                v.insert(0);
-+                loc
-+            }
-+        }
-     });
- 
-     debug_context.scopes[scope] = DebugScope {
-diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
-index 3d2e270a3868e..75a5ec44c2285 100644
---- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
-+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
-@@ -2174,6 +2174,10 @@ unsafe extern "C" {
-         Scope: &'a DIScope,
-         InlinedAt: Option<&'a DILocation>,
-     ) -> &'a DILocation;
-+    pub fn LLVMRustDILocationCloneWithBaseDiscriminator<'a>(
-+        Location: &'a DILocation,
-+        BD: c_uint,
-+    ) -> Option<&'a DILocation>;
-     pub fn LLVMRustDIBuilderCreateOpDeref() -> u64;
-     pub fn LLVMRustDIBuilderCreateOpPlusUconst() -> u64;
-     pub fn LLVMRustDIBuilderCreateOpLLVMFragment() -> u64;
-diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
-index 9330c83b7f230..cd70c3f266920 100644
---- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
-+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
-@@ -1305,6 +1305,14 @@ LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column,
-   return wrap(Loc);
- }
- 
-+extern "C" LLVMMetadataRef
-+LLVMRustDILocationCloneWithBaseDiscriminator(LLVMMetadataRef Location,
-+                                             unsigned BD) {
-+  DILocation *Loc = unwrapDIPtr<DILocation>(Location);
-+  auto NewLoc = Loc->cloneWithBaseDiscriminator(BD);
-+  return wrap(NewLoc.has_value() ? NewLoc.value() : nullptr);
-+}
-+
- extern "C" uint64_t LLVMRustDIBuilderCreateOpDeref() {
-   return dwarf::DW_OP_deref;
- }
-diff --git a/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs b/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
-new file mode 100644
-index 0000000000000..159ecfd09743d
---- /dev/null
-+++ b/tests/codegen/debuginfo-proc-macro/auxiliary/macro_def.rs
-@@ -0,0 +1,11 @@
-+//@ force-host
-+//@ no-prefer-dynamic
-+#![crate_type = "proc-macro"]
-+
-+extern crate proc_macro;
-+use proc_macro::*;
-+
-+#[proc_macro]
-+pub fn square_twice(_item: TokenStream) -> TokenStream {
-+    "(square(env::vars().count() as i32), square(env::vars().count() as i32))".parse().unwrap()
-+}
-diff --git a/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs b/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
-new file mode 100644
-index 0000000000000..c3858044c0c9f
---- /dev/null
-+++ b/tests/codegen/debuginfo-proc-macro/mir_inlined_twice_var_locs.rs
-@@ -0,0 +1,53 @@
-+//@ min-llvm-version: 19
-+//@ compile-flags: -Cdebuginfo=2 -Copt-level=0 -Zmir-enable-passes=+Inline
-+// MSVC is different because of the individual allocas.
-+//@ ignore-msvc
-+
-+//@ aux-build:macro_def.rs
-+
-+// Find the variable.
-+// CHECK-DAG: ![[#var_dbg:]] = !DILocalVariable(name: "n",{{( arg: 1,)?}} scope: ![[#var_scope:]]
-+
-+// Find both dbg_declares. These will proceed the variable metadata, of course, so we're looking
-+// backwards.
-+// CHECK-DAG: dbg_declare(ptr %n.dbg.spill{{[0-9]}}, ![[#var_dbg]], !DIExpression(), ![[#var_loc2:]])
-+// CHECK-DAG: dbg_declare(ptr %n.dbg.spill, ![[#var_dbg]], !DIExpression(), ![[#var_loc1:]])
-+
-+// Find the first location definition, looking forwards again.
-+// CHECK: ![[#var_loc1]] = !DILocation
-+// CHECK-SAME: scope: ![[#var_scope:]], inlinedAt: ![[#var_inlinedAt1:]]
-+
-+// Find the first location's inlinedAt
-+// NB: If we fail here it's *probably* because we failed to produce two
-+// different locations and ended up reusing an earlier one.
-+// CHECK: ![[#var_inlinedAt1]] = !DILocation
-+// CHECK-SAME: scope: ![[var_inlinedAt1_scope:]]
-+
-+// Find the second location definition, still looking forwards.
-+// NB: If we failed to produce two different locations, the test will
-+// definitely fail by this point (if it hasn't already) because we won't
-+// be able to find the same line again.
-+// CHECK: ![[#var_loc2]] = !DILocation
-+// CHECK-SAME: scope: ![[#var_scope]], inlinedAt: ![[#var_inlinedAt2:]]
-+
-+// Find the second location's inlinedAt.
-+// CHECK: ![[#var_inlinedAt2]] = !DILocation
-+// CHECK-SAME: scope: ![[#var_inlinedAt2_scope:]]
-+
-+// Finally, check that a discriminator was emitted for the second scope.
-+// FIXMEkhuey ideally we would check that *either* scope has a discriminator
-+// but I don't know that it's possible to check that with FileCheck.
-+// CHECK: ![[#var_inlinedAt2_scope]] = !DILexicalBlockFile
-+// CHECK-SAME: discriminator: [[#]]
-+extern crate macro_def;
-+
-+use std::env;
-+
-+fn square(n: i32) -> i32 {
-+    n * n
-+}
-+
-+fn main() {
-+    let (z1, z2) = macro_def::square_twice!();
-+    println!("{z1} == {z2}");
-+}

extra/rust/sources

@@ -1,7 +1,6 @@
-https://static.rust-lang.org/dist/rustc-1.82.0-src.tar.xz
+https://static.rust-lang.org/dist/rustc-1.83.0-src.tar.xz
-https://static.rust-lang.org/dist/2024-09-05/rust-std-1.81.0-x86_64-unknown-linux-musl.tar.xz?no-extract
+https://static.rust-lang.org/dist/2024-10-17/rust-std-1.82.0-x86_64-unknown-linux-musl.tar.xz?no-extract
-https://static.rust-lang.org/dist/2024-09-05/rustc-1.81.0-x86_64-unknown-linux-musl.tar.xz?no-extract
+https://static.rust-lang.org/dist/2024-10-17/rustc-1.82.0-x86_64-unknown-linux-musl.tar.xz?no-extract
-https://static.rust-lang.org/dist/2024-09-05/cargo-1.81.0-x86_64-unknown-linux-musl.tar.xz?no-extract
+https://static.rust-lang.org/dist/2024-10-17/cargo-1.82.0-x86_64-unknown-linux-musl.tar.xz?no-extract
 patches/fix-curl.patch
 patches/fix-linux_musl_base.patch
-patches/fix-llvm19.patch

extra/rust/version

@@ -1 +1 @@
-1.82.0 1
+1.83.0 1