From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id E0D8A1580E0 for ; Sat, 31 May 2025 05:57:30 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id CDBC734323C for ; Sat, 31 May 2025 05:57:30 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 2253C1104E4; Sat, 31 May 2025 05:55:28 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 17B0E1104E2 for ; Sat, 31 May 2025 05:55:28 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id BE1883430C6 for ; Sat, 31 May 2025 05:55:27 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 0819F28FD for ; Sat, 31 May 2025 05:55:25 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.82 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.82 Date: Sat, 31 May 2025 05:55:25 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: bda79adf-db29-4f03-8892-5d0ee260dbd1 X-Archives-Hash: 41b8fea2215e152a8f105ac56e33fdbc commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 706621580E0 for ; Sat, 31 May 2025 05:57:39 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id 5C7F534320B for ; Sat, 31 May 2025 05:57:39 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 6420D1104E9; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 5B8091104E9 for ; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 0F23C3431F9 for ; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 9E88A2987 for ; Sat, 31 May 2025 05:55:25 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.83 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.83 Date: Sat, 31 May 2025 05:55:25 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 8d74ae6f-acdb-4a03-9c63-b28952d97c22 X-Archives-Hash: fb8caa44508aa90c4d0201d20c7c050e Message-ID: <20250531055525.viC0RkgAZfCkbAzTgkaUQ9EgwTOMcxSnJmZ4hT5mHwY@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id C5D841580E0 for ; Sat, 31 May 2025 05:57:51 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id B4092343223 for ; Sat, 31 May 2025 05:57:51 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 957261104F3; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 881371104E8 for ; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 3D837343230 for ; Sat, 31 May 2025 05:55:29 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 55495E9B for ; Sat, 31 May 2025 05:55:26 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.84 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.84 Date: Sat, 31 May 2025 05:55:26 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 7e2e99eb-1a42-4a51-9e6c-528362edd9be X-Archives-Hash: 34d75d51371f1d04070b21726c7a3d0e Message-ID: <20250531055526.UXg-WTmtBY1hYqrT7ooBLJPn9L_rgm0IAOyZ_jqsHTk@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 35BF01580E0 for ; Sat, 31 May 2025 05:58:08 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id 065BF343289 for ; Sat, 31 May 2025 05:58:08 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 05B471104FC; Sat, 31 May 2025 05:55:31 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id EC3EE1104FB for ; Sat, 31 May 2025 05:55:30 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id A05A4343223 for ; Sat, 31 May 2025 05:55:30 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 2F5E62935 for ; Sat, 31 May 2025 05:55:27 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.85 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.85 Date: Sat, 31 May 2025 05:55:27 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 2895ac97-7921-4d24-b798-c21a193f4636 X-Archives-Hash: 04a952d5250e4e327245aacd7590764d Message-ID: <20250531055527.djA0m97W7RCU4DVTXyqbTpTC1rh-P7U3iXrmfR-v98I@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id BCDD31580E0 for ; Sat, 31 May 2025 05:58:30 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id A74B934314C for ; Sat, 31 May 2025 05:58:30 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 4E82711051C; Sat, 31 May 2025 05:55:31 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 3A35A110518 for ; Sat, 31 May 2025 05:55:31 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id E2197343236 for ; Sat, 31 May 2025 05:55:30 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 1EE4528F8 for ; Sat, 31 May 2025 05:55:28 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.86 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.86 Date: Sat, 31 May 2025 05:55:28 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 3e48f670-d6ea-467e-b206-26c96a776eb8 X-Archives-Hash: 05bdc37f5794b777a108262214fa3ae3 Message-ID: <20250531055528.plM9KU8D1sbNmZaHVDG3Y45Nytbh2PXjbN-GltzIBNM@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id CED4F1580E0 for ; Sat, 31 May 2025 05:58:50 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id BD377343276 for ; Sat, 31 May 2025 05:58:50 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id C6B08110525; Sat, 31 May 2025 05:55:32 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id B3DCC110524 for ; Sat, 31 May 2025 05:55:32 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 5CD21343218 for ; Sat, 31 May 2025 05:55:32 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 29F262984 for ; Sat, 31 May 2025 05:55:29 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.87 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.87 Date: Sat, 31 May 2025 05:55:29 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: ca4d99fe-9415-4a54-b653-a4f34e0bc4ac X-Archives-Hash: 180c9d6ae638febc44d9c484f3d6aab1 Message-ID: <20250531055529.SDTXjAFcOOk3DIIVOxJAT0mZTJHvVNNxiwYFUtzmsCo@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id A2C0215800A for ; Sat, 31 May 2025 05:59:13 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id 910193432A2 for ; Sat, 31 May 2025 05:59:13 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 174DE110533; Sat, 31 May 2025 05:55:33 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 00597110532 for ; Sat, 31 May 2025 05:55:32 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id A9E3734323C for ; Sat, 31 May 2025 05:55:32 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 45057291F for ; Sat, 31 May 2025 05:55:30 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.88 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.88 Date: Sat, 31 May 2025 05:55:30 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 5ac21538-5608-4831-8e37-6fce87b798d1 X-Archives-Hash: 6c7325983498ac7d8d5c368d18b2c985 Message-ID: <20250531055530.rqUHfBHvVftrFQrXJqh-t0gSDfS8HxXYqWFQeGKs9qE@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id AFFF915800A for ; Sat, 31 May 2025 05:59:39 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id 956B93432F6 for ; Sat, 31 May 2025 05:59:39 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id A5BAA110544; Sat, 31 May 2025 05:55:34 +0000 (UTC) Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 8A63911053C for ; Sat, 31 May 2025 05:55:34 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 35FA434322C for ; Sat, 31 May 2025 05:55:34 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 7688328FB for ; Sat, 31 May 2025 05:55:31 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:master commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: master Date: Sat, 31 May 2025 05:55:31 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: aef280f6-39c5-4a00-b1f6-5b31b373db9b X-Archives-Hash: 115498afa039ebdaf55264f18f21d79a Message-ID: <20250531055531._JGJq6k5nHwoC2SZcFkSRJpSJoQrWwbdlJX4WVY-KhA@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (woodpecker.gentoo.org [140.211.166.183]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 7BC761580E0 for ; Sat, 31 May 2025 06:01:16 +0000 (UTC) Received: from lists.gentoo.org (bobolink.gentoo.org [140.211.166.189]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) (Authenticated sender: relay-lists.gentoo.org@gentoo.org) by smtp.gentoo.org (Postfix) with ESMTPSA id 68F9B343248 for ; Sat, 31 May 2025 06:01:16 +0000 (UTC) Received: from bobolink.gentoo.org (localhost [127.0.0.1]) by bobolink.gentoo.org (Postfix) with ESMTP id 8C508110568; Sat, 31 May 2025 05:55:59 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by bobolink.gentoo.org (Postfix) with ESMTPS id 6C46A11056B for ; Sat, 31 May 2025 05:55:59 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 1892C34325A for ; Sat, 31 May 2025 05:55:59 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 6017C28F8 for ; Sat, 31 May 2025 05:55:56 +0000 (UTC) From: "Matt Jolly" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Matt Jolly" Message-ID: <1748670886.63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2.kangie@gentoo> Subject: [gentoo-commits] proj/rust-patches:1.88.0_beta20250526 commit in: / X-VCS-Repository: proj/rust-patches X-VCS-Files: 1.79.0-revert-8c40426.patch 1.82.0-dwarf-llvm-assertion.patch X-VCS-Directories: / X-VCS-Committer: kangie X-VCS-Committer-Name: Matt Jolly X-VCS-Revision: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 X-VCS-Branch: 1.88.0_beta20250526 Date: Sat, 31 May 2025 05:55:56 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 4bd27947-4b80-4700-b4c8-0bdd069ee829 X-Archives-Hash: 35686b8620712dfb4822cc37395ddb6f Message-ID: <20250531055556.031DJ0pQY9CPG13Zc1N8hIMcUoNeKKWZhIwq527k-rY@z> commit: 63fa68b6ee50480891ec8f2d0cdf2e0084d19bf2 Author: Matt Jolly gentoo org> AuthorDate: Sat May 31 05:54:46 2025 +0000 Commit: Matt Jolly gentoo org> CommitDate: Sat May 31 05:54:46 2025 +0000 URL: https://gitweb.gentoo.org/proj/rust-patches.git/commit/?id=63fa68b6 Add patches for Rust 1.82.0-r103 Patches: - 1.78.0-musl-dynamic-linking.patch - 1.74.1-cross-compile-libz.patch - 1.67.0-doc-wasm.patch - 1.82.0-dwarf-llvm-assertion.patch Signed-off-by: Matt Jolly gentoo.org> 1.79.0-revert-8c40426.patch | 18 --- 1.82.0-dwarf-llvm-assertion.patch | 247 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 247 insertions(+), 18 deletions(-) diff --git a/1.79.0-revert-8c40426.patch b/1.79.0-revert-8c40426.patch deleted file mode 100644 index 583f400..0000000 --- a/1.79.0-revert-8c40426.patch +++ /dev/null @@ -1,18 +0,0 @@ -This reverts commit 8c40426051a667673cdac9975f84cb6acd4e245f. - -https://bugs.gentoo.org/933382 - -diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs -index d4473e24039..58f351d17fa 100644 ---- a/src/bootstrap/src/core/build_steps/llvm.rs -+++ b/src/bootstrap/src/core/build_steps/llvm.rs -@@ -724,8 +724,7 @@ fn configure_cmake( - } - } - cfg.define("CMAKE_C_COMPILER", sanitize_cc(&cc)) -- .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)) -- .define("CMAKE_ASM_COMPILER", sanitize_cc(&cc)); -+ .define("CMAKE_CXX_COMPILER", sanitize_cc(&cxx)); - } - - cfg.build_arg("-j").build_arg(builder.jobs().to_string()); diff --git a/1.82.0-dwarf-llvm-assertion.patch b/1.82.0-dwarf-llvm-assertion.patch new file mode 100644 index 0000000..8c99c9a --- /dev/null +++ b/1.82.0-dwarf-llvm-assertion.patch @@ -0,0 +1,247 @@ +https://bugs.gentoo.org/942013 +https://bugs.gentoo.org/942884 +https://github.com/rust-lang/rust/issues/131944 +https://github.com/rust-lang/rust/pull/132613 + +From 1dc106121b62562ead6e7d612fa136dc4b35cd5d Mon Sep 17 00:00:00 2001 +From: Kyle Huey +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>, + debug_context: &mut FunctionDebugContext<'tcx, &'ll DIScope, &'ll DILocation>, + instantiated: &mut BitSet, ++ discriminators: &mut FxHashMap, + 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(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}"); ++}