Unrolled build for rust-lang#136659

Rollup merge of rust-lang#136659 - wesleywiser:dwarf_version_lto_merge_behavior, r=jieyouxu

Pick the max DWARF version when LTO'ing modules with different versions

Currently, when rustc compiles code with `-Clto` enabled that was built
with different choices for `-Zdwarf-version`, a warning will be
reported. It's very easy to observe this by compiling most anything (eg,
"hello world") and specifying `-Clto -Zdwarf-version=5` since the
standard library is distributed with `-Zdwarf-version=4`.

This behavior isn't actually useful for a few reasons:
- From observation, LLVM chooses to pick the highest DWARF version
  anyway after issuing the warning.
- Clang specifies that in this case, the max version should be picked
  without a warning and as a general principle, we want to support
  x-lang LTO with Clang which implies using the same module flag merge
  behaviors.
- Debuggers need to be able to handle a variety of versions within the
  same debugging session as you can easily have some parts of a binary
  (or some dynamic libraries within an application) all compiled with
  different DWARF versions.

This commit changes the module flag merge behavior to match Clang and
use the highest version of DWARF. It also adds a test to ensure this
behavior is respected in the case of two crates being LTO'd together and
adds a test to ensure no warning is printed.

Fixes rust-lang#130041 which fails due to these warnings being printed

cc rust-lang#103057

Author: rust-timer

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -97,7 +97,11 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
                 // Android has the same issue (#22398)
                 llvm::add_module_flag_u32(
                     self.llmod,
-                    llvm::ModuleFlagMergeBehavior::Warning,
+                    // In the case where multiple CGUs with different dwarf version
+                    // values are being merged together, such as with cross-crate
+                    // LTO, then we want to use the highest version of dwarf
+                    // we can. This matches Clang's behavior as well.
+                    llvm::ModuleFlagMergeBehavior::Max,
                     "Dwarf Version",
                     sess.dwarf_version(),
                 );

tests/assembly/auxiliary/dwarf-mixed-versions-lto-aux.rs

@@ -0,0 +1,5 @@
+//@ compile-flags: -g --crate-type=rlib -Zdwarf-version=4
+
+pub fn check_is_even(number: &u64) -> bool {
+    number % 2 == 0
+}

tests/assembly/dwarf-mixed-versions-lto.rs

@@ -0,0 +1,19 @@
+// This test ensures that if LTO occurs between crates with different DWARF versions, we
+// will choose the highest DWARF version for the final binary. This matches Clang's behavior.
+
+//@ only-linux
+//@ aux-build:dwarf-mixed-versions-lto-aux.rs
+//@ compile-flags: -C lto -g -Zdwarf-version=5
+//@ assembly-output: emit-asm
+//@ no-prefer-dynamic
+
+extern crate dwarf_mixed_versions_lto_aux;
+
+fn main() {
+    dwarf_mixed_versions_lto_aux::check_is_even(&0);
+}
+
+// CHECK: .section .debug_info
+// CHECK-NOT: {{\.(short|hword)}} 2
+// CHECK-NOT: {{\.(short|hword)}} 4
+// CHECK: {{\.(short|hword)}} 5

tests/ui/lto/auxiliary/dwarf-mixed-versions-lto-aux.rs

@@ -0,0 +1,5 @@
+//@ compile-flags: -g --crate-type=rlib -Zdwarf-version=4
+
+pub fn say_hi() {
+    println!("hello there")
+}

tests/ui/lto/dwarf-mixed-versions-lto.rs

@@ -0,0 +1,15 @@
+// This test verifies that we do not produce a warning when performing LTO on a
+// crate graph that contains a mix of different DWARF version settings. This
+// matches Clang's behavior.
+
+//@ ignore-msvc Platform must use DWARF
+//@ aux-build:dwarf-mixed-versions-lto-aux.rs
+//@ compile-flags: -C lto -g -Zdwarf-version=5
+//@ no-prefer-dynamic
+//@ build-pass
+
+extern crate dwarf_mixed_versions_lto_aux;
+
+fn main() {
+    dwarf_mixed_versions_lto_aux::say_hi();
+}