From 5396124aa3617458a3c70f128a6a5b74e93de613 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 5 Sep 2024 09:31:17 -0700
Subject: [PATCH 1/9] Update compiler-builtins to 0.1.125
This commit updates the compiler-builtins crate from 0.1.123 to 0.1.125.
The changes in this update are:
* https://github.com/rust-lang/compiler-builtins/pull/682
* https://github.com/rust-lang/compiler-builtins/pull/678
* https://github.com/rust-lang/compiler-builtins/pull/685
---
library/Cargo.lock | 4 ++--
library/alloc/Cargo.toml | 2 +-
library/std/Cargo.toml | 2 +-
3 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/library/Cargo.lock b/library/Cargo.lock
index 54ad052c52322..ded30dd82f7b4 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -58,9 +58,9 @@ dependencies = [
[[package]]
name = "compiler_builtins"
-version = "0.1.123"
+version = "0.1.125"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b47fcbecb558bdad78c7d3a998523c60a50dd6cd046d5fe74163e309e878fff7"
+checksum = "bd02a01d7bc069bed818e956600fe437ee222dd1d6ad92bfb9db87b43b71fd87"
dependencies = [
"cc",
"rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 1bd4434d4f7e9..1da947d196fd6 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2021"
[dependencies]
core = { path = "../core" }
-compiler_builtins = { version = "0.1.123", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "0.1.125", features = ['rustc-dep-of-std'] }
[dev-dependencies]
rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index e20fe9feff114..9a31fd21dc71a 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
panic_unwind = { path = "../panic_unwind", optional = true }
panic_abort = { path = "../panic_abort" }
core = { path = "../core", public = true }
-compiler_builtins = { version = "0.1.123" }
+compiler_builtins = { version = "0.1.125" }
profiler_builtins = { path = "../profiler_builtins", optional = true }
unwind = { path = "../unwind" }
hashbrown = { version = "0.14", default-features = false, features = [
From 7ed9f945a22a6e9cfb75405698e0eaa163c12beb Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Fri, 6 Sep 2024 12:39:11 -0700
Subject: [PATCH 2/9] Don't leave debug locations for constants sitting on the
builder indefinitely.
Because constants are currently emitted *before* the prologue, leaving the
debug location on the IRBuilder spills onto other instructions in the prologue
and messes up both line numbers as well as the point LLVM chooses to be the
prologue end.
Example LLVM IR (irrelevant IR elided):
Before:
define internal { i64, i64 } @_ZN3tmp3Foo18var_return_opt_try17he02116165b0fc08cE(ptr align 8 %self) !dbg !347 {
start:
%self.dbg.spill = alloca [8 x i8], align 8
%_0 = alloca [16 x i8], align 8
%residual.dbg.spill = alloca [0 x i8], align 1
#dbg_declare(ptr %residual.dbg.spill, !353, !DIExpression(), !357)
store ptr %self, ptr %self.dbg.spill, align 8, !dbg !357
#dbg_declare(ptr %self.dbg.spill, !350, !DIExpression(), !358)
After:
define internal { i64, i64 } @_ZN3tmp3Foo18var_return_opt_try17h00b17d08874ddd90E(ptr align 8 %self) !dbg !347 {
start:
%self.dbg.spill = alloca [8 x i8], align 8
%_0 = alloca [16 x i8], align 8
%residual.dbg.spill = alloca [0 x i8], align 1
#dbg_declare(ptr %residual.dbg.spill, !353, !DIExpression(), !357)
store ptr %self, ptr %self.dbg.spill, align 8
#dbg_declare(ptr %self.dbg.spill, !350, !DIExpression(), !358)
Note in particular how !357 from %residual.dbg.spill's dbg_declare no longer
falls through onto the store to %self.dbg.spill. This fixes argument values
at entry when the constant is a ZST (e.g. <Option as Try>::Residual). This
fixes #130003 (but note that it does *not* fix issues with argument values and
non-ZST constants, which emit their own stores that have debug info on them,
like #128945).
---
compiler/rustc_codegen_gcc/src/debuginfo.rs | 4 ++
.../rustc_codegen_llvm/src/debuginfo/mod.rs | 8 ++-
compiler/rustc_codegen_llvm/src/llvm/ffi.rs | 2 +-
.../rustc_codegen_ssa/src/mir/debuginfo.rs | 1 +
.../rustc_codegen_ssa/src/traits/debuginfo.rs | 1 +
.../debuginfo/zst-interferes-with-prologue.rs | 72 +++++++++++++++++++
6 files changed, 86 insertions(+), 2 deletions(-)
create mode 100644 tests/debuginfo/zst-interferes-with-prologue.rs
diff --git a/compiler/rustc_codegen_gcc/src/debuginfo.rs b/compiler/rustc_codegen_gcc/src/debuginfo.rs
index d770da5a8c44f..f2ae9f9c8a62e 100644
--- a/compiler/rustc_codegen_gcc/src/debuginfo.rs
+++ b/compiler/rustc_codegen_gcc/src/debuginfo.rs
@@ -48,6 +48,10 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation) {
self.location = Some(dbg_loc);
}
+
+ fn clear_dbg_loc(&mut self) {
+ self.location = None;
+ }
}
/// Generate the `debug_context` in an MIR Body.
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index f5d6fc6f08073..842212ac05d4d 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -1,8 +1,8 @@
#![doc = include_str!("doc.md")]
use std::cell::{OnceCell, RefCell};
-use std::iter;
use std::ops::Range;
+use std::{iter, ptr};
use libc::c_uint;
use rustc_codegen_ssa::debuginfo::type_names;
@@ -209,6 +209,12 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
}
}
+ fn clear_dbg_loc(&mut self) {
+ unsafe {
+ llvm::LLVMSetCurrentDebugLocation2(self.llbuilder, ptr::null());
+ }
+ }
+
fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
}
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 3bf4d4964082f..e84ab0aa53889 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1041,7 +1041,7 @@ unsafe extern "C" {
pub fn LLVMDisposeBuilder<'a>(Builder: &'a mut Builder<'a>);
// Metadata
- pub fn LLVMSetCurrentDebugLocation2<'a>(Builder: &Builder<'a>, Loc: &'a Metadata);
+ pub fn LLVMSetCurrentDebugLocation2<'a>(Builder: &Builder<'a>, Loc: *const Metadata);
// Terminators
pub fn LLVMBuildRetVoid<'a>(B: &Builder<'a>) -> &'a Value;
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 75692540c0345..ab08ef72a697b 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -547,6 +547,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
self.set_debug_loc(bx, var.source_info);
let base =
Self::spill_operand_to_stack(operand, Some(var.name.to_string()), bx);
+ bx.clear_dbg_loc();
bx.dbg_var_addr(
dbg_var,
diff --git a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
index 31104e5749b30..5fbe97214fb00 100644
--- a/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/debuginfo.rs
@@ -80,6 +80,7 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
fragment: Option<Range<Size>>,
);
fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation);
+ fn clear_dbg_loc(&mut self);
fn insert_reference_to_gdb_debug_scripts_section_global(&mut self);
fn set_var_name(&mut self, value: Self::Value, name: &str);
}
diff --git a/tests/debuginfo/zst-interferes-with-prologue.rs b/tests/debuginfo/zst-interferes-with-prologue.rs
new file mode 100644
index 0000000000000..09041a3bb72c7
--- /dev/null
+++ b/tests/debuginfo/zst-interferes-with-prologue.rs
@@ -0,0 +1,72 @@
+//@ min-lldb-version: 310
+
+//@ compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:break zst_interferes_with_prologue::Foo::var_return_opt_try
+// gdb-command:run
+
+// gdb-command:print self
+// gdb-command:next
+// gdb-command:print self
+// gdb-command:print $1 == $2
+// gdb-check:true
+
+// === LLDB TESTS ==================================================================================
+
+// lldb-command:b "zst_interferes_with_prologue::Foo::var_return_opt_try"
+// lldb-command:run
+
+// lldb-command:expr self
+// lldb-command:next
+// lldb-command:expr self
+// lldb-command:print $0 == $1
+// lldb-check:true
+
+struct Foo {
+ a: usize,
+}
+
+impl Foo {
+ #[inline(never)]
+ fn get_a(&self) -> Option<usize> {
+ Some(self.a)
+ }
+
+ #[inline(never)]
+ fn var_return(&self) -> usize {
+ let r = self.get_a().unwrap();
+ r
+ }
+
+ #[inline(never)]
+ fn var_return_opt_unwrap(&self) -> Option<usize> {
+ let r = self.get_a().unwrap();
+ Some(r)
+ }
+
+ #[inline(never)]
+ fn var_return_opt_match(&self) -> Option<usize> {
+ let r = match self.get_a() {
+ None => return None,
+ Some(a) => a,
+ };
+ Some(r)
+ }
+
+ #[inline(never)]
+ fn var_return_opt_try(&self) -> Option<usize> {
+ let r = self.get_a()?;
+ Some(r)
+ }
+}
+
+fn main() {
+ let f1 = Foo{ a: 1 };
+ let f2 = Foo{ a: 1 };
+ f1.var_return();
+ f1.var_return_opt_unwrap();
+ f1.var_return_opt_match();
+ f2.var_return_opt_try();
+}
From 97df8fb7ecce4ff77d1da199742a822dfddeac2f Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Wed, 21 Aug 2024 18:21:39 +0200
Subject: [PATCH 3/9] Fix default/minimum deployment target for Aarch64
simulator targets
The minimum that `rustc` encoded did not match the version in Clang, and
that meant that that when linking, we ended up bumping the version.
Specifically, this sets the correct deployment target of the following
simulator and Mac Catalyst targets:
- `aarch64-apple-ios-sim` from 10.0 to 14.0
- `aarch64-apple-tvos-sim` from 10.0 to 14.0
- `aarch64-apple-watchos-sim` from 5.0 to 7.0
- `aarch64-apple-ios-macabi` from 13.1 to 14.0
I have chosen to not document the simulator target versions in the
platform support docs, as it is fundamentally uninteresting; the normal
targets (e.g. `aarch64-apple-ios`, `aarch64-apple-tvos`) still have the
same deployment target as before, and that's what developers should
actually target.
---
.../rustc_target/src/spec/base/apple/mod.rs | 10 +++++--
.../src/platform-support/apple-ios-macabi.md | 2 +-
.../src/platform-support/arm64e-apple-ios.md | 2 +-
.../run-make/apple-deployment-target/rmake.rs | 28 +++++++++++--------
4 files changed, 26 insertions(+), 16 deletions(-)
diff --git a/compiler/rustc_target/src/spec/base/apple/mod.rs b/compiler/rustc_target/src/spec/base/apple/mod.rs
index b1fe49f76caa3..5da47322b92a8 100644
--- a/compiler/rustc_target/src/spec/base/apple/mod.rs
+++ b/compiler/rustc_target/src/spec/base/apple/mod.rs
@@ -323,12 +323,18 @@ fn deployment_target(os: &str, arch: Arch, abi: TargetAbi) -> (u16, u8, u8) {
};
// On certain targets it makes sense to raise the minimum OS version.
+ //
+ // This matches what LLVM does, see:
+ // <https://github.com/llvm/llvm-project/blob/llvmorg-18.1.8/llvm/lib/TargetParser/Triple.cpp#L1900-L1932>
let min = match (os, arch, abi) {
- // Use 11.0 on Aarch64 as that's the earliest version with M1 support.
("macos", Arch::Arm64 | Arch::Arm64e, _) => (11, 0, 0),
- ("ios", Arch::Arm64e, _) => (14, 0, 0),
+ ("ios", Arch::Arm64 | Arch::Arm64e, TargetAbi::MacCatalyst) => (14, 0, 0),
+ ("ios", Arch::Arm64 | Arch::Arm64e, TargetAbi::Simulator) => (14, 0, 0),
+ ("ios", Arch::Arm64e, TargetAbi::Normal) => (14, 0, 0),
// Mac Catalyst defaults to 13.1 in Clang.
("ios", _, TargetAbi::MacCatalyst) => (13, 1, 0),
+ ("tvos", Arch::Arm64 | Arch::Arm64e, TargetAbi::Simulator) => (14, 0, 0),
+ ("watchos", Arch::Arm64 | Arch::Arm64e, TargetAbi::Simulator) => (7, 0, 0),
_ => os_min,
};
diff --git a/src/doc/rustc/src/platform-support/apple-ios-macabi.md b/src/doc/rustc/src/platform-support/apple-ios-macabi.md
index 678630873b135..a54656190d1f3 100644
--- a/src/doc/rustc/src/platform-support/apple-ios-macabi.md
+++ b/src/doc/rustc/src/platform-support/apple-ios-macabi.md
@@ -24,7 +24,7 @@ environment variable.
### OS version
-The minimum supported version is iOS 13.1.
+The minimum supported version is iOS 13.1 on x86 and 14.0 on Aarch64.
This can be raised per-binary by changing the deployment target. `rustc`
respects the common environment variables used by Xcode to do so, in this
diff --git a/src/doc/rustc/src/platform-support/arm64e-apple-ios.md b/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
index 3c878f7250e97..fc4ec5e373fb0 100644
--- a/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
+++ b/src/doc/rustc/src/platform-support/arm64e-apple-ios.md
@@ -2,7 +2,7 @@
**Tier: 3**
-ARM64e iOS (12.0+)
+ARM64e iOS (14.0+)
## Target maintainers
diff --git a/tests/run-make/apple-deployment-target/rmake.rs b/tests/run-make/apple-deployment-target/rmake.rs
index b2d1af65177ef..230f33a8d7867 100644
--- a/tests/run-make/apple-deployment-target/rmake.rs
+++ b/tests/run-make/apple-deployment-target/rmake.rs
@@ -55,11 +55,8 @@ fn main() {
rustc().env(env_var, example_version).run();
minos("foo.o", example_version);
- // FIXME(madsmtm): Doesn't work on Mac Catalyst and the simulator.
- if !target().contains("macabi") && !target().contains("sim") {
- rustc().env_remove(env_var).run();
- minos("foo.o", default_version);
- }
+ rustc().env_remove(env_var).run();
+ minos("foo.o", default_version);
});
// Test that version makes it to the linker when linking dylibs.
@@ -105,8 +102,18 @@ fn main() {
rustc
};
- // FIXME(madsmtm): Doesn't work on watchOS for some reason?
- if !target().contains("watchos") {
+ // FIXME(madsmtm): Xcode's version of Clang seems to require a minimum
+ // version of 9.0 on aarch64-apple-watchos for some reason? Which is
+ // odd, because the first Aarch64 watch was Apple Watch Series 4,
+ // which runs on as low as watchOS 5.0.
+ //
+ // You can see Clang's behaviour by running:
+ // ```
+ // echo "int main() { return 0; }" > main.c
+ // xcrun --sdk watchos clang --target=aarch64-apple-watchos main.c
+ // vtool -show a.out
+ // ```
+ if target() != "aarch64-apple-watchos" {
rustc().env(env_var, example_version).run();
minos("foo", example_version);
@@ -148,10 +155,7 @@ fn main() {
rustc().env(env_var, higher_example_version).run();
minos("foo.o", higher_example_version);
- // FIXME(madsmtm): Doesn't work on Mac Catalyst and the simulator.
- if !target().contains("macabi") && !target().contains("sim") {
- rustc().env_remove(env_var).run();
- minos("foo.o", default_version);
- }
+ rustc().env_remove(env_var).run();
+ minos("foo.o", default_version);
});
}
From 99cad123edfa915723a5e5c0537d43b71f2cc0c5 Mon Sep 17 00:00:00 2001
From: "James C. Wise" <jameschristopherwise@gmail.com>
Date: Mon, 9 Sep 2024 13:13:45 -0400
Subject: [PATCH 4/9] Fix slice::first_mut docs pointer -> reference
---
library/core/src/slice/mod.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 166189f4b6cf3..fb732f82989c0 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -156,7 +156,7 @@ impl<T> [T] {
if let [first, ..] = self { Some(first) } else { None }
}
- /// Returns a mutable pointer to the first element of the slice, or `None` if it is empty.
+ /// Returns a mutable reference to the first element of the slice, or `None` if it is empty.
///
/// # Examples
///
From 713828d4f430e1393535f588e73dd5d8bb5d793a Mon Sep 17 00:00:00 2001
From: Florian Schmiderer <florian.schmiderer@posteo.net>
Date: Fri, 6 Sep 2024 23:41:16 +0200
Subject: [PATCH 5/9] Add test for S_OBJNAME and update test for LF_BUILDINFO
cl and cmd for pdb files.
---
.../src/external_deps/llvm.rs | 6 +++++
.../pdb-buildinfo-cl-cmd/filecheck.txt | 4 ++++
tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs | 24 ++++---------------
tests/run-make/pdb-sobjname/main.rs | 1 +
tests/run-make/pdb-sobjname/rmake.rs | 20 ++++++++++++++++
5 files changed, 36 insertions(+), 19 deletions(-)
create mode 100644 tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
create mode 100644 tests/run-make/pdb-sobjname/main.rs
create mode 100644 tests/run-make/pdb-sobjname/rmake.rs
diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index 16c4251998fb2..38a9ac923b4dc 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -54,6 +54,12 @@ pub fn llvm_dwarfdump() -> LlvmDwarfdump {
LlvmDwarfdump::new()
}
+/// Construct a new `llvm-pdbutil` invocation. This assumes that `llvm-pdbutil` is available
+/// at `$LLVM_BIN_DIR/llvm-pdbutil`.
+pub fn llvm_pdbutil() -> LlvmPdbutil {
+ LlvmPdbutil::new()
+}
+
/// A `llvm-readobj` invocation builder.
#[derive(Debug)]
#[must_use]
diff --git a/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt b/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
new file mode 100644
index 0000000000000..a01999d5bdf76
--- /dev/null
+++ b/tests/run-make/pdb-buildinfo-cl-cmd/filecheck.txt
@@ -0,0 +1,4 @@
+CHECK: LF_BUILDINFO
+CHECK: rustc.exe
+CHECK: main.rs
+CHECK: "-g" "--crate-name" "my_crate_name" "--crate-type" "bin" "-Cmetadata=dc9ef878b0a48666"
diff --git a/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs b/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
index 2ab9057b24c1b..9418f4f8d84d3 100644
--- a/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
+++ b/tests/run-make/pdb-buildinfo-cl-cmd/rmake.rs
@@ -7,7 +7,7 @@
//@ only-windows-msvc
// Reason: pdb files are unique to this architecture
-use run_make_support::{assert_contains, bstr, env_var, rfs, rustc};
+use run_make_support::{llvm, rustc};
fn main() {
rustc()
@@ -17,23 +17,9 @@ fn main() {
.crate_type("bin")
.metadata("dc9ef878b0a48666")
.run();
- let tests = [
- &env_var("RUSTC"),
- r#""main.rs""#,
- r#""-g""#,
- r#""--crate-name""#,
- r#""my_crate_name""#,
- r#""--crate-type""#,
- r#""bin""#,
- r#""-Cmetadata=dc9ef878b0a48666""#,
- ];
- for test in tests {
- assert_pdb_contains(test);
- }
-}
-fn assert_pdb_contains(needle: &str) {
- let needle = needle.as_bytes();
- use bstr::ByteSlice;
- assert!(&rfs::read("my_crate_name.pdb").find(needle).is_some());
+ let pdbutil_result =
+ llvm::llvm_pdbutil().arg("dump").arg("-ids").input("my_crate_name.pdb").run();
+
+ llvm::llvm_filecheck().patterns("filecheck.txt").stdin_buf(pdbutil_result.stdout_utf8()).run();
}
diff --git a/tests/run-make/pdb-sobjname/main.rs b/tests/run-make/pdb-sobjname/main.rs
new file mode 100644
index 0000000000000..f328e4d9d04c3
--- /dev/null
+++ b/tests/run-make/pdb-sobjname/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/tests/run-make/pdb-sobjname/rmake.rs b/tests/run-make/pdb-sobjname/rmake.rs
new file mode 100644
index 0000000000000..83c39fdccd3c7
--- /dev/null
+++ b/tests/run-make/pdb-sobjname/rmake.rs
@@ -0,0 +1,20 @@
+// Check if the pdb file contains an S_OBJNAME entry with the name of the .o file
+
+// This is because it used to be missing in #96475.
+// See https://github.com/rust-lang/rust/pull/115704
+
+//@ only-windows-msvc
+// Reason: pdb files are unique to this architecture
+
+use run_make_support::{llvm, rustc};
+
+fn main() {
+ rustc().input("main.rs").arg("-g").crate_name("my_great_crate_name").crate_type("bin").run();
+
+ let pdbutil_result = llvm::llvm_pdbutil()
+ .arg("dump")
+ .arg("-symbols")
+ .input("my_great_crate_name.pdb")
+ .run()
+ .assert_stdout_contains_regex("S_OBJNAME.+my_great_crate_name.*\\.o");
+}
From 6d064295c8fb7413cb0500289f922f8d7feb38dc Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 11 Sep 2024 14:58:08 -0400
Subject: [PATCH 6/9] clippy::useless_conversion
---
compiler/rustc_ast/src/ast.rs | 6 ++----
.../rustc_const_eval/src/const_eval/eval_queries.rs | 7 +------
compiler/rustc_const_eval/src/interpret/call.rs | 2 +-
compiler/rustc_errors/src/diagnostic.rs | 4 ++--
compiler/rustc_hir_analysis/src/check/wfcheck.rs | 4 ++--
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs | 2 +-
compiler/rustc_middle/src/ty/consts.rs | 2 +-
compiler/rustc_middle/src/ty/print/pretty.rs | 2 +-
.../rustc_next_trait_solver/src/solve/trait_goals.rs | 1 -
compiler/rustc_parse/src/parser/attr_wrapper.rs | 2 +-
compiler/rustc_parse/src/parser/item.rs | 10 +++++-----
compiler/rustc_symbol_mangling/src/v0.rs | 2 +-
compiler/rustc_trait_selection/src/traits/project.rs | 4 ++--
13 files changed, 20 insertions(+), 28 deletions(-)
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 85d38a0e28b0f..5d353be67b5de 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -3475,7 +3475,7 @@ impl From<ForeignItemKind> for ItemKind {
fn from(foreign_item_kind: ForeignItemKind) -> ItemKind {
match foreign_item_kind {
ForeignItemKind::Static(box static_foreign_item) => {
- ItemKind::Static(Box::new(static_foreign_item.into()))
+ ItemKind::Static(Box::new(static_foreign_item))
}
ForeignItemKind::Fn(fn_kind) => ItemKind::Fn(fn_kind),
ForeignItemKind::TyAlias(ty_alias_kind) => ItemKind::TyAlias(ty_alias_kind),
@@ -3489,9 +3489,7 @@ impl TryFrom<ItemKind> for ForeignItemKind {
fn try_from(item_kind: ItemKind) -> Result<ForeignItemKind, ItemKind> {
Ok(match item_kind {
- ItemKind::Static(box static_item) => {
- ForeignItemKind::Static(Box::new(static_item.into()))
- }
+ ItemKind::Static(box static_item) => ForeignItemKind::Static(Box::new(static_item)),
ItemKind::Fn(fn_kind) => ForeignItemKind::Fn(fn_kind),
ItemKind::TyAlias(ty_alias_kind) => ForeignItemKind::TyAlias(ty_alias_kind),
ItemKind::MacCall(a) => ForeignItemKind::MacCall(a),
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 7ccebd83f24f7..da4173f903296 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -75,12 +75,7 @@ fn eval_body_using_ecx<'tcx, R: InterpretationResult<'tcx>>(
// This can't use `init_stack_frame` since `body` is not a function,
// so computing its ABI would fail. It's also not worth it since there are no arguments to pass.
- ecx.push_stack_frame_raw(
- cid.instance,
- body,
- &ret.clone().into(),
- StackPopCleanup::Root { cleanup: false },
- )?;
+ ecx.push_stack_frame_raw(cid.instance, body, &ret, StackPopCleanup::Root { cleanup: false })?;
ecx.storage_live_for_always_live_locals()?;
// The main interpreter loop.
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 568a9a3a637be..5687e72569f93 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -823,7 +823,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
(Abi::Rust, fn_abi),
&[FnArg::Copy(arg.into())],
false,
- &ret.into(),
+ &ret,
Some(target),
unwind,
)
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 412a2c17081a9..7a4d8dba179a2 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -681,10 +681,10 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
" ".repeat(expected_padding),
expected_label
))];
- msg.extend(expected.0.into_iter());
+ msg.extend(expected.0);
msg.push(StringPart::normal(format!("`{expected_extra}\n")));
msg.push(StringPart::normal(format!("{}{} `", " ".repeat(found_padding), found_label)));
- msg.extend(found.0.into_iter());
+ msg.extend(found.0);
msg.push(StringPart::normal(format!("`{found_extra}")));
// For now, just attach these as notes.
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 3627faf8dfc57..10b3fe380ab69 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1602,7 +1602,7 @@ fn check_fn_or_method<'tcx>(
function: def_id,
// Note that the `param_idx` of the output type is
// one greater than the index of the last input type.
- param_idx: idx.try_into().unwrap(),
+ param_idx: idx,
}),
ty,
)
@@ -1611,7 +1611,7 @@ fn check_fn_or_method<'tcx>(
for (idx, ty) in sig.inputs_and_output.iter().enumerate() {
wfcx.register_wf_obligation(
arg_span(idx),
- Some(WellFormedLoc::Param { function: def_id, param_idx: idx.try_into().unwrap() }),
+ Some(WellFormedLoc::Param { function: def_id, param_idx: idx }),
ty.into(),
);
}
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index bdf84f332166d..a18ce73a8aad0 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -2565,7 +2565,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
other_generic_param.name.ident() == generic_param.name.ident()
},
) {
- idxs_matched.push(other_idx.into());
+ idxs_matched.push(other_idx);
}
if idxs_matched.is_empty() {
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index 362ff8e988d36..a5952c65692c1 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -396,7 +396,7 @@ impl<'tcx> Const<'tcx> {
Ok((tcx.type_of(unevaluated.def).instantiate(tcx, unevaluated.args), c))
}
Ok(Err(bad_ty)) => Err(Either::Left(bad_ty)),
- Err(err) => Err(Either::Right(err.into())),
+ Err(err) => Err(Either::Right(err)),
}
}
ConstKind::Value(ty, val) => Ok((ty, val)),
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index f1ff90831b04f..819c7d3c5b49f 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1526,7 +1526,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
let precedence = |binop: rustc_middle::mir::BinOp| {
use rustc_ast::util::parser::AssocOp;
- AssocOp::from_ast_binop(binop.to_hir_binop().into()).precedence()
+ AssocOp::from_ast_binop(binop.to_hir_binop()).precedence()
};
let op_precedence = precedence(op);
let formatted_op = op.to_hir_binop().as_str();
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 683d8dab3b2a8..73d9b5e8a4ee7 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -883,7 +883,6 @@ where
.into_iter()
.chain(a_data.principal_def_id().into_iter().flat_map(|principal_def_id| {
elaborate::supertrait_def_ids(self.cx(), principal_def_id)
- .into_iter()
.filter(|def_id| self.cx().trait_is_auto(*def_id))
}))
.collect();
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 205cca830b2e0..6a241be0a1560 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -383,7 +383,7 @@ impl<'a> Parser<'a> {
self.capture_state
.parser_replacements
.drain(parser_replacements_start..parser_replacements_end)
- .chain(inner_attr_parser_replacements.into_iter())
+ .chain(inner_attr_parser_replacements)
.map(|(parser_range, data)| {
(NodeRange::new(parser_range, collect_pos.start_pos), data)
})
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index c6a5e1908f704..98ec09356d3dc 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1588,7 +1588,7 @@ impl<'a> Parser<'a> {
(thin_vec![], Recovered::Yes(guar))
}
};
- VariantData::Struct { fields, recovered: recovered.into() }
+ VariantData::Struct { fields, recovered }
} else if this.check(&token::OpenDelim(Delimiter::Parenthesis)) {
let body = match this.parse_tuple_struct_body() {
Ok(body) => body,
@@ -1672,7 +1672,7 @@ impl<'a> Parser<'a> {
class_name.span,
generics.where_clause.has_where_token,
)?;
- VariantData::Struct { fields, recovered: recovered.into() }
+ VariantData::Struct { fields, recovered }
}
// No `where` so: `struct Foo<T>;`
} else if self.eat(&token::Semi) {
@@ -1684,7 +1684,7 @@ impl<'a> Parser<'a> {
class_name.span,
generics.where_clause.has_where_token,
)?;
- VariantData::Struct { fields, recovered: recovered.into() }
+ VariantData::Struct { fields, recovered }
// Tuple-style struct definition with optional where-clause.
} else if self.token == token::OpenDelim(Delimiter::Parenthesis) {
let body = VariantData::Tuple(self.parse_tuple_struct_body()?, DUMMY_NODE_ID);
@@ -1713,14 +1713,14 @@ impl<'a> Parser<'a> {
class_name.span,
generics.where_clause.has_where_token,
)?;
- VariantData::Struct { fields, recovered: recovered.into() }
+ VariantData::Struct { fields, recovered }
} else if self.token == token::OpenDelim(Delimiter::Brace) {
let (fields, recovered) = self.parse_record_struct_body(
"union",
class_name.span,
generics.where_clause.has_where_token,
)?;
- VariantData::Struct { fields, recovered: recovered.into() }
+ VariantData::Struct { fields, recovered }
} else {
let token_str = super::token_descr(&self.token);
let msg = format!("expected `where` or `{{` after union name, found {token_str}");
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 75f4499352b99..ba35a37c32ce1 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -381,7 +381,7 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
let consts = [
start.unwrap_or(self.tcx.consts.unit),
end.unwrap_or(self.tcx.consts.unit),
- ty::Const::from_bool(self.tcx, include_end).into(),
+ ty::Const::from_bool(self.tcx, include_end),
];
// HACK: Represent as tuple until we have something better.
// HACK: constants are used in arrays, even if the types don't match.
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 630acc91fbedc..c27a9285b3abe 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -408,7 +408,7 @@ pub(super) fn opt_normalize_projection_term<'a, 'b, 'tcx>(
debug!("opt_normalize_projection_type: found error");
let result = normalize_to_error(selcx, param_env, projection_term, cause, depth);
obligations.extend(result.obligations);
- return Ok(Some(result.value.into()));
+ return Ok(Some(result.value));
}
}
@@ -478,7 +478,7 @@ pub(super) fn opt_normalize_projection_term<'a, 'b, 'tcx>(
}
let result = normalize_to_error(selcx, param_env, projection_term, cause, depth);
obligations.extend(result.obligations);
- Ok(Some(result.value.into()))
+ Ok(Some(result.value))
}
}
}
From 594de02cbacccd3a220c69971e085bfd76a84eac Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 11 Sep 2024 18:22:37 -0400
Subject: [PATCH 7/9] Properly deny const gen/async gen fns
---
compiler/rustc_ast/src/ast.rs | 8 ++++++++
compiler/rustc_ast_passes/messages.ftl | 10 +++++-----
.../rustc_ast_passes/src/ast_validation.rs | 17 ++++++----------
compiler/rustc_ast_passes/src/errors.rs | 11 +++++-----
tests/ui/coroutine/const_gen_fn.rs | 12 +++++++++++
tests/ui/coroutine/const_gen_fn.stderr | 20 +++++++++++++++++++
6 files changed, 57 insertions(+), 21 deletions(-)
create mode 100644 tests/ui/coroutine/const_gen_fn.rs
create mode 100644 tests/ui/coroutine/const_gen_fn.stderr
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 42741bdca2295..1fb85abcbfaa2 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2602,6 +2602,14 @@ impl CoroutineKind {
}
}
+ pub fn as_str(self) -> &'static str {
+ match self {
+ CoroutineKind::Async { .. } => "async",
+ CoroutineKind::Gen { .. } => "gen",
+ CoroutineKind::AsyncGen { .. } => "async gen",
+ }
+ }
+
pub fn is_async(self) -> bool {
matches!(self, CoroutineKind::Async { .. })
}
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index df5c639382f04..c361c35b723d8 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -40,15 +40,15 @@ ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block
ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect
-ast_passes_const_and_async = functions cannot be both `const` and `async`
- .const = `const` because of this
- .async = `async` because of this
- .label = {""}
-
ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic
.const = `const` because of this
.variadic = C-variadic because of this
+ast_passes_const_and_coroutine = functions cannot be both `const` and `{$coroutine_kind}`
+ .const = `const` because of this
+ .coroutine = `{$coroutine_kind}` because of this
+ .label = {""}
+
ast_passes_const_bound_trait_object = const trait bounds are not allowed in trait object types
ast_passes_const_without_body =
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index ed9672a9e79b3..f6731c6bd541c 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1418,21 +1418,16 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
// Functions cannot both be `const async` or `const gen`
if let Some(&FnHeader {
- constness: Const::Yes(cspan),
+ constness: Const::Yes(const_span),
coroutine_kind: Some(coroutine_kind),
..
}) = fk.header()
{
- let aspan = match coroutine_kind {
- CoroutineKind::Async { span: aspan, .. }
- | CoroutineKind::Gen { span: aspan, .. }
- | CoroutineKind::AsyncGen { span: aspan, .. } => aspan,
- };
- // FIXME(gen_blocks): Report a different error for `const gen`
- self.dcx().emit_err(errors::ConstAndAsync {
- spans: vec![cspan, aspan],
- cspan,
- aspan,
+ self.dcx().emit_err(errors::ConstAndCoroutine {
+ spans: vec![coroutine_kind.span(), const_span],
+ const_span,
+ coroutine_span: coroutine_kind.span(),
+ coroutine_kind: coroutine_kind.as_str(),
span,
});
}
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 67c0396333c4b..5cce47ce7bd21 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -657,16 +657,17 @@ pub(crate) enum TildeConstReason {
}
#[derive(Diagnostic)]
-#[diag(ast_passes_const_and_async)]
-pub(crate) struct ConstAndAsync {
+#[diag(ast_passes_const_and_coroutine)]
+pub(crate) struct ConstAndCoroutine {
#[primary_span]
pub spans: Vec<Span>,
#[label(ast_passes_const)]
- pub cspan: Span,
- #[label(ast_passes_async)]
- pub aspan: Span,
+ pub const_span: Span,
+ #[label(ast_passes_coroutine)]
+ pub coroutine_span: Span,
#[label]
pub span: Span,
+ pub coroutine_kind: &'static str,
}
#[derive(Diagnostic)]
diff --git a/tests/ui/coroutine/const_gen_fn.rs b/tests/ui/coroutine/const_gen_fn.rs
new file mode 100644
index 0000000000000..986693f33ab1b
--- /dev/null
+++ b/tests/ui/coroutine/const_gen_fn.rs
@@ -0,0 +1,12 @@
+//@ edition:2024
+//@ compile-flags: -Zunstable-options
+
+#![feature(gen_blocks)]
+
+const gen fn a() {}
+//~^ ERROR functions cannot be both `const` and `gen`
+
+const async gen fn b() {}
+//~^ ERROR functions cannot be both `const` and `async gen`
+
+fn main() {}
diff --git a/tests/ui/coroutine/const_gen_fn.stderr b/tests/ui/coroutine/const_gen_fn.stderr
new file mode 100644
index 0000000000000..b58446ac88fd1
--- /dev/null
+++ b/tests/ui/coroutine/const_gen_fn.stderr
@@ -0,0 +1,20 @@
+error: functions cannot be both `const` and `gen`
+ --> $DIR/const_gen_fn.rs:6:1
+ |
+LL | const gen fn a() {}
+ | ^^^^^-^^^----------
+ | | |
+ | | `gen` because of this
+ | `const` because of this
+
+error: functions cannot be both `const` and `async gen`
+ --> $DIR/const_gen_fn.rs:9:1
+ |
+LL | const async gen fn b() {}
+ | ^^^^^-^^^^^^^^^----------
+ | | |
+ | | `async gen` because of this
+ | `const` because of this
+
+error: aborting due to 2 previous errors
+
From 8dc227866fe12879e6a6b518c7a2ad6dbe395ac9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 11 Sep 2024 18:52:36 -0400
Subject: [PATCH 8/9] Remove unused functions from ast CoroutineKind
---
compiler/rustc_ast/src/ast.rs | 8 --------
src/tools/clippy/clippy_utils/src/ast_utils.rs | 12 +++++++++++-
2 files changed, 11 insertions(+), 9 deletions(-)
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 1fb85abcbfaa2..b7a6746267f53 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2610,14 +2610,6 @@ impl CoroutineKind {
}
}
- pub fn is_async(self) -> bool {
- matches!(self, CoroutineKind::Async { .. })
- }
-
- pub fn is_gen(self) -> bool {
- matches!(self, CoroutineKind::Gen { .. })
- }
-
pub fn closure_id(self) -> NodeId {
match self {
CoroutineKind::Async { closure_id, .. }
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils.rs b/src/tools/clippy/clippy_utils/src/ast_utils.rs
index 181bbdde8e5f1..de8bbb619f8e4 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils.rs
@@ -221,7 +221,7 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
) => {
eq_closure_binder(lb, rb)
&& lc == rc
- && la.map_or(false, CoroutineKind::is_async) == ra.map_or(false, CoroutineKind::is_async)
+ && eq_coroutine_kind(*la, *ra)
&& lm == rm
&& eq_fn_decl(lf, rf)
&& eq_expr(le, re)
@@ -241,6 +241,16 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
}
}
+fn eq_coroutine_kind(a: Option<CoroutineKind>, b: Option<CoroutineKind>) -> bool {
+ match (a, b) {
+ (Some(CoroutineKind::Async { .. }), Some(CoroutineKind::Async { .. }))
+ | (Some(CoroutineKind::Gen { .. }), Some(CoroutineKind::Gen { .. }))
+ | (Some(CoroutineKind::AsyncGen { .. }), Some(CoroutineKind::AsyncGen { .. }))
+ | (None, None) => true,
+ _ => false,
+ }
+}
+
pub fn eq_field(l: &ExprField, r: &ExprField) -> bool {
l.is_placeholder == r.is_placeholder
&& eq_id(l.ident, r.ident)
From ed9b2bac36d93cdc8532f6bb86b9b8591f0a79e1 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 12 Sep 2024 12:42:23 +1000
Subject: [PATCH 9/9] Re-run coverage tests if `coverage-dump` was modified
---
src/tools/compiletest/src/lib.rs | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 5fe73a0e29729..250b5084d1362 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -647,6 +647,12 @@ fn common_inputs_stamp(config: &Config) -> Stamp {
stamp.add_path(&rust_src_dir.join("src/etc/htmldocck.py"));
}
+ // Re-run coverage tests if the `coverage-dump` tool was modified,
+ // because its output format might have changed.
+ if let Some(coverage_dump_path) = &config.coverage_dump_path {
+ stamp.add_path(coverage_dump_path)
+ }
+
stamp.add_dir(&rust_src_dir.join("src/tools/run-make-support"));
// Compiletest itself.