From 23c4a9f42fc607b74a80898b9c2f2b9ec14a167a Mon Sep 17 00:00:00 2001 From: Jan Palus Date: Fri, 26 May 2023 14:17:09 +0200 Subject: [PATCH] upstream fix for "Cannot represent a difference across sections"; rel 3 from: https://github.com/rust-lang/rust/pull/111167 --- 111167.patch | 248 +++++++++++++++++++++++++++++++++++++++++++++++++++ rust.spec | 4 +- 2 files changed, 251 insertions(+), 1 deletion(-) create mode 100644 111167.patch diff --git a/111167.patch b/111167.patch new file mode 100644 index 0000000..3dc75ed --- /dev/null +++ b/111167.patch @@ -0,0 +1,248 @@ +From 10b69dde3fd15334ea2382d2dc9e9a261de1afaf Mon Sep 17 00:00:00 2001 +From: Josh Stone +Date: Wed, 3 May 2023 15:52:31 -0700 +Subject: [PATCH] debuginfo: split method declaration and definition + +When we're adding a method to a type DIE, we only want a DW_AT_declaration +there, because LLVM LTO can't unify type definitions when a child DIE is a +full subprogram definition. Now the subprogram definition gets added at the +CU level with a specification link back to the abstract declaration. +--- + .../rustc_codegen_llvm/src/debuginfo/mod.rs | 85 +++++++++++-------- + compiler/rustc_codegen_llvm/src/llvm/ffi.rs | 15 ++++ + .../rustc_llvm/llvm-wrapper/RustWrapper.cpp | 22 +++++ + .../issue-109934-lto-debuginfo/Makefile | 12 +++ + .../issue-109934-lto-debuginfo/lib.rs | 9 ++ + 5 files changed, 109 insertions(+), 34 deletions(-) + create mode 100644 tests/run-make/issue-109934-lto-debuginfo/Makefile + create mode 100644 tests/run-make/issue-109934-lto-debuginfo/lib.rs + +diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs +index 2e9f89f419696..b138b0c0e70a1 100644 +--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs ++++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs +@@ -322,7 +322,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> { + let tcx = self.tcx; + + let def_id = instance.def_id(); +- let containing_scope = get_containing_scope(self, instance); ++ let (containing_scope, is_method) = get_containing_scope(self, instance); + let span = tcx.def_span(def_id); + let loc = self.lookup_debug_loc(span.lo()); + let file_metadata = file_metadata(self, &loc.file); +@@ -378,8 +378,29 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> { + } + } + +- unsafe { +- return llvm::LLVMRustDIBuilderCreateFunction( ++ // When we're adding a method to a type DIE, we only want a DW_AT_declaration there, because ++ // LLVM LTO can't unify type definitions when a child DIE is a full subprogram definition. ++ // When we use this `decl` below, the subprogram definition gets created at the CU level ++ // with a DW_AT_specification pointing back to the type's declaration. ++ let decl = is_method.then(|| unsafe { ++ llvm::LLVMRustDIBuilderCreateMethod( ++ DIB(self), ++ containing_scope, ++ name.as_ptr().cast(), ++ name.len(), ++ linkage_name.as_ptr().cast(), ++ linkage_name.len(), ++ file_metadata, ++ loc.line, ++ function_type_metadata, ++ flags, ++ spflags & !DISPFlags::SPFlagDefinition, ++ template_parameters, ++ ) ++ }); ++ ++ return unsafe { ++ llvm::LLVMRustDIBuilderCreateFunction( + DIB(self), + containing_scope, + name.as_ptr().cast(), +@@ -394,9 +415,9 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> { + spflags, + maybe_definition_llfn, + template_parameters, +- None, +- ); +- } ++ decl, ++ ) ++ }; + + fn get_function_signature<'ll, 'tcx>( + cx: &CodegenCx<'ll, 'tcx>, +@@ -493,14 +514,16 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> { + names + } + ++ /// Returns a scope, plus `true` if that's a type scope for "class" methods, ++ /// otherwise `false` for plain namespace scopes. + fn get_containing_scope<'ll, 'tcx>( + cx: &CodegenCx<'ll, 'tcx>, + instance: Instance<'tcx>, +- ) -> &'ll DIScope { ++ ) -> (&'ll DIScope, bool) { + // First, let's see if this is a method within an inherent impl. Because + // if yes, we want to make the result subroutine DIE a child of the + // subroutine's self-type. +- let self_type = cx.tcx.impl_of_method(instance.def_id()).and_then(|impl_def_id| { ++ if let Some(impl_def_id) = cx.tcx.impl_of_method(instance.def_id()) { + // If the method does *not* belong to a trait, proceed + if cx.tcx.trait_id_of_impl(impl_def_id).is_none() { + let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions( +@@ -511,39 +534,33 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> { + + // Only "class" methods are generally understood by LLVM, + // so avoid methods on other types (e.g., `<*mut T>::null`). +- match impl_self_ty.kind() { +- ty::Adt(def, ..) if !def.is_box() => { +- // Again, only create type information if full debuginfo is enabled +- if cx.sess().opts.debuginfo == DebugInfo::Full +- && !impl_self_ty.needs_subst() +- { +- Some(type_di_node(cx, impl_self_ty)) +- } else { +- Some(namespace::item_namespace(cx, def.did())) +- } ++ if let ty::Adt(def, ..) = impl_self_ty.kind() && !def.is_box() { ++ // Again, only create type information if full debuginfo is enabled ++ if cx.sess().opts.debuginfo == DebugInfo::Full && !impl_self_ty.needs_subst() ++ { ++ return (type_di_node(cx, impl_self_ty), true); ++ } else { ++ return (namespace::item_namespace(cx, def.did()), false); + } +- _ => None, + } + } else { + // For trait method impls we still use the "parallel namespace" + // strategy +- None + } +- }); ++ } + +- self_type.unwrap_or_else(|| { +- namespace::item_namespace( +- cx, +- DefId { +- krate: instance.def_id().krate, +- index: cx +- .tcx +- .def_key(instance.def_id()) +- .parent +- .expect("get_containing_scope: missing parent?"), +- }, +- ) +- }) ++ let scope = namespace::item_namespace( ++ cx, ++ DefId { ++ krate: instance.def_id().krate, ++ index: cx ++ .tcx ++ .def_key(instance.def_id()) ++ .parent ++ .expect("get_containing_scope: missing parent?"), ++ }, ++ ); ++ (scope, false) + } + } + +diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs +index c95148013eb74..1f98d91c32054 100644 +--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs ++++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs +@@ -1987,6 +1987,21 @@ extern "C" { + Decl: Option<&'a DIDescriptor>, + ) -> &'a DISubprogram; + ++ pub fn LLVMRustDIBuilderCreateMethod<'a>( ++ Builder: &DIBuilder<'a>, ++ Scope: &'a DIDescriptor, ++ Name: *const c_char, ++ NameLen: size_t, ++ LinkageName: *const c_char, ++ LinkageNameLen: size_t, ++ File: &'a DIFile, ++ LineNo: c_uint, ++ Ty: &'a DIType, ++ Flags: DIFlags, ++ SPFlags: DISPFlags, ++ TParam: &'a DIArray, ++ ) -> &'a DISubprogram; ++ + pub fn LLVMRustDIBuilderCreateBasicType<'a>( + Builder: &DIBuilder<'a>, + Name: *const c_char, +diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp +index cadb6b1e23fe9..49acd71b3e106 100644 +--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp ++++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp +@@ -831,6 +831,28 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction( + return wrap(Sub); + } + ++extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod( ++ LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, ++ const char *Name, size_t NameLen, ++ const char *LinkageName, size_t LinkageNameLen, ++ LLVMMetadataRef File, unsigned LineNo, ++ LLVMMetadataRef Ty, LLVMRustDIFlags Flags, ++ LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) { ++ DITemplateParameterArray TParams = ++ DITemplateParameterArray(unwrap(TParam)); ++ DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags); ++ DINode::DIFlags llvmFlags = fromRust(Flags); ++ DISubprogram *Sub = Builder->createMethod( ++ unwrapDI(Scope), ++ StringRef(Name, NameLen), ++ StringRef(LinkageName, LinkageNameLen), ++ unwrapDI(File), LineNo, ++ unwrapDI(Ty), ++ 0, 0, nullptr, // VTable params aren't used ++ llvmFlags, llvmSPFlags, TParams); ++ return wrap(Sub); ++} ++ + extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType( + LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen, + uint64_t SizeInBits, unsigned Encoding) { +diff --git a/tests/run-make/issue-109934-lto-debuginfo/Makefile b/tests/run-make/issue-109934-lto-debuginfo/Makefile +new file mode 100644 +index 0000000000000..3b7a99d3dbc62 +--- /dev/null ++++ b/tests/run-make/issue-109934-lto-debuginfo/Makefile +@@ -0,0 +1,12 @@ ++# ignore-cross-compile ++include ../tools.mk ++ ++# With the upgrade to LLVM 16, this was getting: ++# ++# error: Cannot represent a difference across sections ++# ++# The error stemmed from DI function definitions under type scopes, fixed by ++# only declaring in type scope and defining the subprogram elsewhere. ++ ++all: ++ $(RUSTC) lib.rs --test -C lto=fat -C debuginfo=2 -C incremental=$(TMPDIR)/inc-fat +diff --git a/tests/run-make/issue-109934-lto-debuginfo/lib.rs b/tests/run-make/issue-109934-lto-debuginfo/lib.rs +new file mode 100644 +index 0000000000000..c405928bd1824 +--- /dev/null ++++ b/tests/run-make/issue-109934-lto-debuginfo/lib.rs +@@ -0,0 +1,9 @@ ++extern crate alloc; ++ ++#[cfg(test)] ++mod tests { ++ #[test] ++ fn something_alloc() { ++ assert_eq!(Vec::::new(), Vec::::new()); ++ } ++} diff --git a/rust.spec b/rust.spec index 6b3f2a9..d97bf50 100644 --- a/rust.spec +++ b/rust.spec @@ -37,7 +37,7 @@ Summary: The Rust Programming Language Summary(pl.UTF-8): Język programowania Rust Name: rust Version: 1.69.0 -Release: 2 +Release: 3 # Licenses: (rust itself) and (bundled libraries) License: (Apache v2.0 or MIT) and (BSD and ISC and MIT) Group: Development/Languages @@ -54,6 +54,7 @@ Source4: https://static.rust-lang.org/dist/%{bootstrap_date}/rust-%{bootstrap_ru Source5: https://static.rust-lang.org/dist/%{bootstrap_date}/rust-%{bootstrap_rust}-armv7-unknown-linux-gnueabihf.tar.xz # Source5-md5: 5691b194302d66b40c3e4eee0eeb1813 Patch0: llvm-tools-install.patch +Patch1: 111167.patch URL: https://www.rust-lang.org/ # for src/compiler-rt BuildRequires: cmake >= 3.4.3 @@ -333,6 +334,7 @@ Dopełnianie parametrów polecenia cargo w powłoce Zsh. %prep %setup -q -n %{rustc_package} %patch0 -p1 +%patch1 -p1 %if %{with bootstrap} %ifarch %{x8664} x32