206 files changed, 435 insertions, 2385 deletions

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e2b515a3086..39667d16b7b 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1305,6 +1305,47 @@ macro_rules! test_definitions {
     };
 }
 
+/// Declares an alias for running the [`Coverage`] tests in only one mode.
+/// Adapted from [`test_definitions`].
+macro_rules! coverage_test_alias {
+    ($name:ident {
+        alias_and_mode: $alias_and_mode:expr,
+        default: $default:expr,
+        only_hosts: $only_hosts:expr $(,)?
+    }) => {
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub struct $name {
+            pub compiler: Compiler,
+            pub target: TargetSelection,
+        }
+
+        impl $name {
+            const MODE: &'static str = $alias_and_mode;
+        }
+
+        impl Step for $name {
+            type Output = ();
+            const DEFAULT: bool = $default;
+            const ONLY_HOSTS: bool = $only_hosts;
+
+            fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+                run.alias($alias_and_mode)
+            }
+
+            fn make_run(run: RunConfig<'_>) {
+                let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+
+                run.builder.ensure($name { compiler, target: run.target });
+            }
+
+            fn run(self, builder: &Builder<'_>) {
+                Coverage { compiler: self.compiler, target: self.target }
+                    .run_unified_suite(builder, Self::MODE)
+            }
+        }
+    };
+}
+
 default_test!(Ui { path: "tests/ui", mode: "ui", suite: "ui" });
 
 default_test!(RunPassValgrind {
@@ -1349,13 +1390,66 @@ host_test!(RunMakeFullDeps {
 
 default_test!(Assembly { path: "tests/assembly", mode: "assembly", suite: "assembly" });
 
-default_test!(CoverageMap {
-    path: "tests/coverage-map",
-    mode: "coverage-map",
-    suite: "coverage-map"
+/// Custom test step that is responsible for running the coverage tests
+/// in multiple different modes.
+///
+/// Each individual mode also has its own alias that will run the tests in
+/// just that mode.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Coverage {
+    pub compiler: Compiler,
+    pub target: TargetSelection,
+}
+
+impl Coverage {
+    const PATH: &'static str = "tests/coverage";
+    const SUITE: &'static str = "coverage";
+
+    fn run_unified_suite(&self, builder: &Builder<'_>, mode: &'static str) {
+        builder.ensure(Compiletest {
+            compiler: self.compiler,
+            target: self.target,
+            mode,
+            suite: Self::SUITE,
+            path: Self::PATH,
+            compare_mode: None,
+        })
+    }
+}
+
+impl Step for Coverage {
+    type Output = ();
+    const DEFAULT: bool = false;
+    const ONLY_HOSTS: bool = false;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.suite_path(Self::PATH)
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+
+        run.builder.ensure(Coverage { compiler, target: run.target });
+    }
+
+    fn run(self, builder: &Builder<'_>) {
+        self.run_unified_suite(builder, CoverageMap::MODE);
+        self.run_unified_suite(builder, RunCoverage::MODE);
+    }
+}
+
+// Aliases for running the coverage tests in only one mode.
+coverage_test_alias!(CoverageMap {
+    alias_and_mode: "coverage-map",
+    default: true,
+    only_hosts: false,
+});
+coverage_test_alias!(RunCoverage {
+    alias_and_mode: "run-coverage",
+    default: true,
+    only_hosts: true,
 });
 
-host_test!(RunCoverage { path: "tests/run-coverage", mode: "run-coverage", suite: "run-coverage" });
 host_test!(RunCoverageRustdoc {
     path: "tests/run-coverage-rustdoc",
     mode: "run-coverage",
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 44cdbe38de3..38eb4633273 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -727,6 +727,7 @@ impl<'a> Builder<'a> {
                 test::Tidy,
                 test::Ui,
                 test::RunPassValgrind,
+                test::Coverage,
                 test::CoverageMap,
                 test::RunCoverage,
                 test::MirOpt,
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 0e1bf0c6c2d..a908218fff1 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -78,7 +78,7 @@ impl Default for Mode {
 }
 
 impl Mode {
-    pub fn disambiguator(self) -> &'static str {
+    pub fn aux_dir_disambiguator(self) -> &'static str {
         // Pretty-printing tests could run concurrently, and if they do,
         // they need to keep their output segregated.
         match self {
@@ -86,6 +86,15 @@ impl Mode {
             _ => "",
         }
     }
+
+    pub fn output_dir_disambiguator(self) -> &'static str {
+        // Coverage tests use the same test files for multiple test modes,
+        // so each mode should have a separate output directory.
+        match self {
+            CoverageMap | RunCoverage => self.to_str(),
+            _ => "",
+        }
+    }
 }
 
 string_enum! {
@@ -699,6 +708,7 @@ pub fn output_testname_unique(
     let mode = config.compare_mode.as_ref().map_or("", |m| m.to_str());
     let debugger = config.debugger.as_ref().map_or("", |m| m.to_str());
     PathBuf::from(&testpaths.file.file_stem().unwrap())
+        .with_extra_extension(config.mode.output_dir_disambiguator())
         .with_extra_extension(revision.unwrap_or(""))
         .with_extra_extension(mode)
         .with_extra_extension(debugger)
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 620844f6f09..cbcd3dc2fde 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2193,7 +2193,7 @@ impl<'test> TestCx<'test> {
             || self.is_vxworks_pure_static()
             || self.config.target.contains("bpf")
             || !self.config.target_cfg().dynamic_linking
-            || self.config.mode == RunCoverage
+            || matches!(self.config.mode, CoverageMap | RunCoverage)
         {
             // We primarily compile all auxiliary libraries as dynamic libraries
             // to avoid code size bloat and large binaries as much as possible
@@ -2481,9 +2481,9 @@ impl<'test> TestCx<'test> {
             RunCoverage => {
                 rustc.arg("-Cinstrument-coverage");
                 // Coverage reports are sometimes sensitive to optimizations,
-                // and the current snapshots assume no optimization unless
+                // and the current snapshots assume `opt-level=2` unless
                 // overridden by `compile-flags`.
-                rustc.arg("-Copt-level=0");
+                rustc.arg("-Copt-level=2");
             }
             RunPassValgrind | Pretty | DebugInfo | Codegen | Rustdoc | RustdocJson | RunMake
             | CodegenUnits | JsDocTest | Assembly => {
@@ -2720,7 +2720,7 @@ impl<'test> TestCx<'test> {
     fn aux_output_dir_name(&self) -> PathBuf {
         self.output_base_dir()
             .join("auxiliary")
-            .with_extra_extension(self.config.mode.disambiguator())
+            .with_extra_extension(self.config.mode.aux_dir_disambiguator())
     }
 
     /// Generates a unique name for the test, such as `testname.revision.mode`.
diff --git a/tests/coverage-map/README.md b/tests/coverage-map/README.md
deleted file mode 100644
index 60d1352cd64..00000000000
--- a/tests/coverage-map/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-The tests in `./status-quo` were copied from `tests/run-coverage` in order to
-capture the current behavior of the instrumentor on non-trivial programs.
-The actual mappings have not been closely inspected.
-
-## Maintenance note
-
-These tests can be sensitive to small changes in MIR spans or MIR control flow,
-especially in HIR-to-MIR lowering or MIR optimizations.
-
-If you haven't touched the coverage code directly, and the `run-coverage` test
-suite still works, then it should usually be OK to just `--bless` these
-coverage mapping tests as necessary, without worrying too much about the exact
-changes.
diff --git a/tests/coverage-map/if.cov-map b/tests/coverage-map/if.cov-map
deleted file mode 100644
index 3cedb5ffbec..00000000000
--- a/tests/coverage-map/if.cov-map
+++ /dev/null
@@ -1,15 +0,0 @@
-Function name: if::main
-Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 01, 02]
-Number of files: 1
-- file 0 => global file 1
-Number of expressions: 2
-- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
-Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 3, 1) to (start + 2, 12)
-- Code(Counter(1)) at (prev + 2, 13) to (start + 2, 6)
-- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
-    = (c0 - c1)
-- Code(Expression(1, Add)) at (prev + 1, 5) to (start + 1, 2)
-    = (c1 + (c0 - c1))
-
diff --git a/tests/coverage-map/if.rs b/tests/coverage-map/if.rs
deleted file mode 100644
index ed3f69bdc98..00000000000
--- a/tests/coverage-map/if.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// compile-flags: --edition=2021
-
-fn main() {
-    let cond = std::env::args().len() == 1;
-    if cond {
-        println!("true");
-    }
-    println!("done");
-}
diff --git a/tests/coverage-map/status-quo/overflow.rs b/tests/coverage-map/status-quo/overflow.rs
deleted file mode 100644
index bbb65c1b35d..00000000000
--- a/tests/coverage-map/status-quo/overflow.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_overflow(to_add: u32) -> u32 {
-    if to_add > 5 {
-        println!("this will probably overflow");
-    }
-    let add_to = u32::MAX - 5;
-    println!("does {} + {} overflow?", add_to, to_add);
-    let result = to_add + add_to;
-    println!("continuing after overflow check");
-    result
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            let result = might_overflow(10);
-            println!("Result: {}", result);
-        } else if countdown < 5 {
-            let result = might_overflow(1);
-            println!("Result: {}", result);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the very similar test `assert.rs`,
-//      and similar tests `panic_unwind.rs`, abort.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program passes or fails a
-//      compiler-generated `TerminatorKind::Assert` (based on an overflow check, in this case).
-//   3. Similar to how the coverage instrumentation handles `TerminatorKind::Call`,
-//      compiler-generated assertion failures are assumed to be a symptom of a program bug, not
-//      expected behavior. To simplify the coverage graphs and keep instrumented programs as
-//      small and fast as possible, `Assert` terminators are assumed to always succeed, and
-//      therefore are considered "non-branching" terminators. So, an `Assert` terminator does not
-//      get its own coverage counter.
-//   4. After an unhandled panic or failed Assert, coverage results may not always be intuitive.
-//      In this test, the final count for the statements after the `if` block in `might_overflow()`
-//      is 4, even though the lines after `to_add + add_to` were executed only 3 times. Depending
-//      on the MIR graph and the structure of the code, this count could have been 3 (which might
-//      have been valid for the overflowed add `+`, but should have been 4 for the lines before
-//      the overflow. The reason for this potential uncertainty is, a `CounterKind` is incremented
-//      via StatementKind::Counter at the end of the block, but (as in the case in this test),
-//      a CounterKind::Expression is always evaluated. In this case, the expression was based on
-//      a `Counter` incremented as part of the evaluation of the `if` expression, which was
-//      executed, and counted, 4 times, before reaching the overflow add.
-
-// If the program did not overflow, the coverage for `might_overflow()` would look like this:
-//
-//     4|       |fn might_overflow(to_add: u32) -> u32 {
-//     5|      4|    if to_add > 5 {
-//     6|      0|        println!("this will probably overflow");
-//     7|      4|    }
-//     8|      4|    let add_to = u32::MAX - 5;
-//     9|      4|    println!("does {} + {} overflow?", add_to, to_add);
-//    10|      4|    let result = to_add + add_to;
-//    11|      4|    println!("continuing after overflow check");
-//    12|      4|    result
-//    13|      4|}
diff --git a/tests/coverage-map/status-quo/sort_groups.rs b/tests/coverage-map/status-quo/sort_groups.rs
deleted file mode 100644
index f89f9f3ec61..00000000000
--- a/tests/coverage-map/status-quo/sort_groups.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// compile-flags: --edition=2021
-
-// Demonstrate that `sort_subviews.py` can sort instantiation groups into a
-// predictable order, while preserving their heterogeneous contents.
-
-fn main() {
-    let cond = std::env::args().len() > 1;
-    generic_fn::<()>(cond);
-    generic_fn::<&'static str>(!cond);
-    if false {
-        generic_fn::<char>(cond);
-    }
-    generic_fn::<i32>(cond);
-    other_fn();
-}
-
-fn generic_fn<T>(cond: bool) {
-    if cond {
-        println!("{}", std::any::type_name::<T>());
-    }
-}
-
-fn other_fn() {}
diff --git a/tests/coverage/README.md b/tests/coverage/README.md
new file mode 100644
index 00000000000..f1e403c65e3
--- /dev/null
+++ b/tests/coverage/README.md
@@ -0,0 +1,16 @@
+The tests in this directory are shared by two different test modes, and can be
+run in multiple different ways:
+
+- `./x.py test coverage-map` (compiles to LLVM IR and checks coverage mappings)
+- `./x.py test run-coverage` (runs a test binary and checks its coverage report)
+- `./x.py test coverage` (runs both `coverage-map` and `run-coverage`)
+
+## Maintenance note
+
+These tests can be sensitive to small changes in MIR spans or MIR control flow,
+especially in HIR-to-MIR lowering or MIR optimizations.
+
+If you haven't touched the coverage code directly, and the tests still pass in
+`run-coverage` mode, then it should usually be OK to just re-bless the mappings
+as necessary with `./x.py test coverage-map --bless`, without worrying too much
+about the exact changes.
diff --git a/tests/coverage-map/status-quo/abort.cov-map b/tests/coverage/abort.cov-map
index 45d3795eff8..45d3795eff8 100644
--- a/tests/coverage-map/status-quo/abort.cov-map
+++ b/tests/coverage/abort.cov-map
diff --git a/tests/run-coverage/abort.coverage b/tests/coverage/abort.coverage
index ceef6386780..ceef6386780 100644
--- a/tests/run-coverage/abort.coverage
+++ b/tests/coverage/abort.coverage
diff --git a/tests/coverage-map/status-quo/abort.rs b/tests/coverage/abort.rs
index 98264bdc1af..98264bdc1af 100644
--- a/tests/coverage-map/status-quo/abort.rs
+++ b/tests/coverage/abort.rs
diff --git a/tests/coverage-map/status-quo/assert.cov-map b/tests/coverage/assert.cov-map
index dd413123de7..dd413123de7 100644
--- a/tests/coverage-map/status-quo/assert.cov-map
+++ b/tests/coverage/assert.cov-map
diff --git a/tests/run-coverage/assert.coverage b/tests/coverage/assert.coverage
index 8b997724c4a..8b997724c4a 100644
--- a/tests/run-coverage/assert.coverage
+++ b/tests/coverage/assert.coverage
diff --git a/tests/coverage-map/status-quo/assert.rs b/tests/coverage/assert.rs
index 85e6662a6ad..85e6662a6ad 100644
--- a/tests/coverage-map/status-quo/assert.rs
+++ b/tests/coverage/assert.rs
diff --git a/tests/coverage-map/status-quo/async.cov-map b/tests/coverage/async.cov-map
index 598791537ad..598791537ad 100644
--- a/tests/coverage-map/status-quo/async.cov-map
+++ b/tests/coverage/async.cov-map
diff --git a/tests/run-coverage/async.coverage b/tests/coverage/async.coverage
index 07bc16c2d92..07bc16c2d92 100644
--- a/tests/run-coverage/async.coverage
+++ b/tests/coverage/async.coverage
diff --git a/tests/coverage-map/status-quo/async.rs b/tests/coverage/async.rs
index efd9e62d64e..efd9e62d64e 100644
--- a/tests/coverage-map/status-quo/async.rs
+++ b/tests/coverage/async.rs
diff --git a/tests/coverage-map/status-quo/async2.cov-map b/tests/coverage/async2.cov-map
index cc7aed9aee3..cc7aed9aee3 100644
--- a/tests/coverage-map/status-quo/async2.cov-map
+++ b/tests/coverage/async2.cov-map
diff --git a/tests/run-coverage/async2.coverage b/tests/coverage/async2.coverage
index fcb0a3aed64..fcb0a3aed64 100644
--- a/tests/run-coverage/async2.coverage
+++ b/tests/coverage/async2.coverage
diff --git a/tests/coverage-map/status-quo/async2.rs b/tests/coverage/async2.rs
index 2884ff297af..2884ff297af 100644
--- a/tests/coverage-map/status-quo/async2.rs
+++ b/tests/coverage/async2.rs
diff --git a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs b/tests/coverage/auxiliary/inline_always_with_dead_code.rs
index 9dc50dae25a..9dc50dae25a 100644
--- a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs
+++ b/tests/coverage/auxiliary/inline_always_with_dead_code.rs
diff --git a/tests/run-coverage/auxiliary/unused_mod_helper.rs b/tests/coverage/auxiliary/unused_mod_helper.rs
index 88c5dac65cb..88c5dac65cb 100644
--- a/tests/run-coverage/auxiliary/unused_mod_helper.rs
+++ b/tests/coverage/auxiliary/unused_mod_helper.rs
diff --git a/tests/run-coverage/auxiliary/used_crate.rs b/tests/coverage/auxiliary/used_crate.rs
index c086ef21e1a..c086ef21e1a 100644
--- a/tests/run-coverage/auxiliary/used_crate.rs
+++ b/tests/coverage/auxiliary/used_crate.rs
diff --git a/tests/run-coverage/auxiliary/used_inline_crate.rs b/tests/coverage/auxiliary/used_inline_crate.rs
index e8929de6b36..e8929de6b36 100644
--- a/tests/run-coverage/auxiliary/used_inline_crate.rs
+++ b/tests/coverage/auxiliary/used_inline_crate.rs
diff --git a/tests/coverage-map/status-quo/bad_counter_ids.cov-map b/tests/coverage/bad_counter_ids.cov-map
index 0b8081acfa6..0b8081acfa6 100644
--- a/tests/coverage-map/status-quo/bad_counter_ids.cov-map
+++ b/tests/coverage/bad_counter_ids.cov-map
diff --git a/tests/run-coverage/bad_counter_ids.coverage b/tests/coverage/bad_counter_ids.coverage
index d69ebf160ea..d69ebf160ea 100644
--- a/tests/run-coverage/bad_counter_ids.coverage
+++ b/tests/coverage/bad_counter_ids.coverage
diff --git a/tests/coverage-map/status-quo/bad_counter_ids.rs b/tests/coverage/bad_counter_ids.rs
index ef5460102b7..ef5460102b7 100644
--- a/tests/coverage-map/status-quo/bad_counter_ids.rs
+++ b/tests/coverage/bad_counter_ids.rs
diff --git a/tests/coverage-map/status-quo/closure.cov-map b/tests/coverage/closure.cov-map
index 522c1e73afe..522c1e73afe 100644
--- a/tests/coverage-map/status-quo/closure.cov-map
+++ b/tests/coverage/closure.cov-map
diff --git a/tests/run-coverage/closure.coverage b/tests/coverage/closure.coverage
index 67014f792c8..67014f792c8 100644
--- a/tests/run-coverage/closure.coverage
+++ b/tests/coverage/closure.coverage
diff --git a/tests/coverage-map/status-quo/closure.rs b/tests/coverage/closure.rs
index 16a2c4e33bd..16a2c4e33bd 100644
--- a/tests/coverage-map/status-quo/closure.rs
+++ b/tests/coverage/closure.rs
diff --git a/tests/coverage-map/status-quo/closure_bug.cov-map b/tests/coverage/closure_bug.cov-map
index 90eeb1a6686..90eeb1a6686 100644
--- a/tests/coverage-map/status-quo/closure_bug.cov-map
+++ b/tests/coverage/closure_bug.cov-map
diff --git a/tests/run-coverage/closure_bug.coverage b/tests/coverage/closure_bug.coverage
index f3299834bce..f3299834bce 100644
--- a/tests/run-coverage/closure_bug.coverage
+++ b/tests/coverage/closure_bug.coverage
diff --git a/tests/coverage-map/status-quo/closure_bug.rs b/tests/coverage/closure_bug.rs
index 739bc5f0b51..739bc5f0b51 100644
--- a/tests/coverage-map/status-quo/closure_bug.rs
+++ b/tests/coverage/closure_bug.rs
diff --git a/tests/coverage-map/status-quo/closure_macro.cov-map b/tests/coverage/closure_macro.cov-map
index b02c7e2e4c6..b02c7e2e4c6 100644
--- a/tests/coverage-map/status-quo/closure_macro.cov-map
+++ b/tests/coverage/closure_macro.cov-map
diff --git a/tests/run-coverage/closure_macro.coverage b/tests/coverage/closure_macro.coverage
index 0f2c917e090..0f2c917e090 100644
--- a/tests/run-coverage/closure_macro.coverage
+++ b/tests/coverage/closure_macro.coverage
diff --git a/tests/coverage-map/status-quo/closure_macro.rs b/tests/coverage/closure_macro.rs
index 9b289141c2e..9b289141c2e 100644
--- a/tests/coverage-map/status-quo/closure_macro.rs
+++ b/tests/coverage/closure_macro.rs
diff --git a/tests/coverage-map/status-quo/closure_macro_async.cov-map b/tests/coverage/closure_macro_async.cov-map
index 7f8666948d9..7f8666948d9 100644
--- a/tests/coverage-map/status-quo/closure_macro_async.cov-map
+++ b/tests/coverage/closure_macro_async.cov-map
diff --git a/tests/run-coverage/closure_macro_async.coverage b/tests/coverage/closure_macro_async.coverage
index 74247f1bc6f..74247f1bc6f 100644
--- a/tests/run-coverage/closure_macro_async.coverage
+++ b/tests/coverage/closure_macro_async.coverage
diff --git a/tests/coverage-map/status-quo/closure_macro_async.rs b/tests/coverage/closure_macro_async.rs
index b4275599e59..b4275599e59 100644
--- a/tests/coverage-map/status-quo/closure_macro_async.rs
+++ b/tests/coverage/closure_macro_async.rs
diff --git a/tests/coverage-map/status-quo/conditions.cov-map b/tests/coverage/conditions.cov-map
index 7600d2d96bd..7600d2d96bd 100644
--- a/tests/coverage-map/status-quo/conditions.cov-map
+++ b/tests/coverage/conditions.cov-map
diff --git a/tests/run-coverage/conditions.coverage b/tests/coverage/conditions.coverage
index 473335ff641..473335ff641 100644
--- a/tests/run-coverage/conditions.coverage
+++ b/tests/coverage/conditions.coverage
diff --git a/tests/coverage-map/status-quo/conditions.rs b/tests/coverage/conditions.rs
index fa7f2a116c2..fa7f2a116c2 100644
--- a/tests/coverage-map/status-quo/conditions.rs
+++ b/tests/coverage/conditions.rs
diff --git a/tests/coverage-map/status-quo/continue.cov-map b/tests/coverage/continue.cov-map
index 82f3d7c6095..82f3d7c6095 100644
--- a/tests/coverage-map/status-quo/continue.cov-map
+++ b/tests/coverage/continue.cov-map
diff --git a/tests/run-coverage/continue.coverage b/tests/coverage/continue.coverage
index 4916cac0038..4916cac0038 100644
--- a/tests/run-coverage/continue.coverage
+++ b/tests/coverage/continue.coverage
diff --git a/tests/coverage-map/status-quo/continue.rs b/tests/coverage/continue.rs
index 624aa98341b..624aa98341b 100644
--- a/tests/coverage-map/status-quo/continue.rs
+++ b/tests/coverage/continue.rs
diff --git a/tests/coverage-map/status-quo/coroutine.cov-map b/tests/coverage/coroutine.cov-map
index 2f4936d9ab8..2f4936d9ab8 100644
--- a/tests/coverage-map/status-quo/coroutine.cov-map
+++ b/tests/coverage/coroutine.cov-map
diff --git a/tests/run-coverage/coroutine.coverage b/tests/coverage/coroutine.coverage
index 3a9791a0dbd..3a9791a0dbd 100644
--- a/tests/run-coverage/coroutine.coverage
+++ b/tests/coverage/coroutine.coverage
diff --git a/tests/coverage-map/status-quo/coroutine.rs b/tests/coverage/coroutine.rs
index 86d19af6f4f..86d19af6f4f 100644
--- a/tests/coverage-map/status-quo/coroutine.rs
+++ b/tests/coverage/coroutine.rs
diff --git a/tests/coverage-map/status-quo/dead_code.cov-map b/tests/coverage/dead_code.cov-map
index 0b8a40a8cde..0b8a40a8cde 100644
--- a/tests/coverage-map/status-quo/dead_code.cov-map
+++ b/tests/coverage/dead_code.cov-map
diff --git a/tests/run-coverage/dead_code.coverage b/tests/coverage/dead_code.coverage
index c4ee9f23f08..c4ee9f23f08 100644
--- a/tests/run-coverage/dead_code.coverage
+++ b/tests/coverage/dead_code.coverage
diff --git a/tests/coverage-map/status-quo/dead_code.rs b/tests/coverage/dead_code.rs
index 3492712a6f9..3492712a6f9 100644
--- a/tests/coverage-map/status-quo/dead_code.rs
+++ b/tests/coverage/dead_code.rs
diff --git a/tests/coverage-map/status-quo/drop_trait.cov-map b/tests/coverage/drop_trait.cov-map
index 203d1048b05..203d1048b05 100644
--- a/tests/coverage-map/status-quo/drop_trait.cov-map
+++ b/tests/coverage/drop_trait.cov-map
diff --git a/tests/run-coverage/drop_trait.coverage b/tests/coverage/drop_trait.coverage
index 2c9439a93b1..2c9439a93b1 100644
--- a/tests/run-coverage/drop_trait.coverage
+++ b/tests/coverage/drop_trait.coverage
diff --git a/tests/coverage-map/status-quo/drop_trait.rs b/tests/coverage/drop_trait.rs
index 7b062719c6b..7b062719c6b 100644
--- a/tests/coverage-map/status-quo/drop_trait.rs
+++ b/tests/coverage/drop_trait.rs
diff --git a/tests/coverage-map/fn_sig_into_try.cov-map b/tests/coverage/fn_sig_into_try.cov-map
index 6e26c61aac9..6e26c61aac9 100644
--- a/tests/coverage-map/fn_sig_into_try.cov-map
+++ b/tests/coverage/fn_sig_into_try.cov-map
diff --git a/tests/run-coverage/fn_sig_into_try.coverage b/tests/coverage/fn_sig_into_try.coverage
index f1ddb1da780..f1ddb1da780 100644
--- a/tests/run-coverage/fn_sig_into_try.coverage
+++ b/tests/coverage/fn_sig_into_try.coverage
diff --git a/tests/coverage-map/fn_sig_into_try.rs b/tests/coverage/fn_sig_into_try.rs
index 92850c8a188..92850c8a188 100644
--- a/tests/coverage-map/fn_sig_into_try.rs
+++ b/tests/coverage/fn_sig_into_try.rs
diff --git a/tests/coverage-map/status-quo/generics.cov-map b/tests/coverage/generics.cov-map
index 6079a433cd0..6079a433cd0 100644
--- a/tests/coverage-map/status-quo/generics.cov-map
+++ b/tests/coverage/generics.cov-map
diff --git a/tests/run-coverage/generics.coverage b/tests/coverage/generics.coverage
index 09839183566..09839183566 100644
--- a/tests/run-coverage/generics.coverage
+++ b/tests/coverage/generics.coverage
diff --git a/tests/coverage-map/status-quo/generics.rs b/tests/coverage/generics.rs
index bf4c2d8d685..bf4c2d8d685 100644
--- a/tests/coverage-map/status-quo/generics.rs
+++ b/tests/coverage/generics.rs
diff --git a/tests/coverage-map/status-quo/if.cov-map b/tests/coverage/if.cov-map
index 391a69e0e82..391a69e0e82 100644
--- a/tests/coverage-map/status-quo/if.cov-map
+++ b/tests/coverage/if.cov-map
diff --git a/tests/run-coverage/if.coverage b/tests/coverage/if.coverage
index 2e6845190aa..2e6845190aa 100644
--- a/tests/run-coverage/if.coverage
+++ b/tests/coverage/if.coverage
diff --git a/tests/coverage-map/status-quo/if.rs b/tests/coverage/if.rs
index 8ad5042ff7b..8ad5042ff7b 100644
--- a/tests/coverage-map/status-quo/if.rs
+++ b/tests/coverage/if.rs
diff --git a/tests/coverage-map/status-quo/if_else.cov-map b/tests/coverage/if_else.cov-map
index da692ca3aa2..da692ca3aa2 100644
--- a/tests/coverage-map/status-quo/if_else.cov-map
+++ b/tests/coverage/if_else.cov-map
diff --git a/tests/run-coverage/if_else.coverage b/tests/coverage/if_else.coverage
index 0274401f004..0274401f004 100644
--- a/tests/run-coverage/if_else.coverage
+++ b/tests/coverage/if_else.coverage
diff --git a/tests/coverage-map/status-quo/if_else.rs b/tests/coverage/if_else.rs
index 3244e1e3afd..3244e1e3afd 100644
--- a/tests/coverage-map/status-quo/if_else.rs
+++ b/tests/coverage/if_else.rs
diff --git a/tests/coverage-map/status-quo/inline-dead.cov-map b/tests/coverage/inline-dead.cov-map
index 958b423f24c..958b423f24c 100644
--- a/tests/coverage-map/status-quo/inline-dead.cov-map
+++ b/tests/coverage/inline-dead.cov-map
diff --git a/tests/run-coverage/inline-dead.coverage b/tests/coverage/inline-dead.coverage
index de96aa17acd..de96aa17acd 100644
--- a/tests/run-coverage/inline-dead.coverage
+++ b/tests/coverage/inline-dead.coverage
diff --git a/tests/coverage-map/status-quo/inline-dead.rs b/tests/coverage/inline-dead.rs
index 854fa062967..854fa062967 100644
--- a/tests/coverage-map/status-quo/inline-dead.rs
+++ b/tests/coverage/inline-dead.rs
diff --git a/tests/coverage-map/status-quo/inline.cov-map b/tests/coverage/inline.cov-map
index 72b10fd0cc2..72b10fd0cc2 100644
--- a/tests/coverage-map/status-quo/inline.cov-map
+++ b/tests/coverage/inline.cov-map
diff --git a/tests/run-coverage/inline.coverage b/tests/coverage/inline.coverage
index 6efd9a0830b..6efd9a0830b 100644
--- a/tests/run-coverage/inline.coverage
+++ b/tests/coverage/inline.coverage
diff --git a/tests/coverage-map/status-quo/inline.rs b/tests/coverage/inline.rs
index 9cfab9ddbad..9cfab9ddbad 100644
--- a/tests/coverage-map/status-quo/inline.rs
+++ b/tests/coverage/inline.rs
diff --git a/tests/coverage-map/status-quo/inner_items.cov-map b/tests/coverage/inner_items.cov-map
index 3f39d74efba..3f39d74efba 100644
--- a/tests/coverage-map/status-quo/inner_items.cov-map
+++ b/tests/coverage/inner_items.cov-map
diff --git a/tests/run-coverage/inner_items.coverage b/tests/coverage/inner_items.coverage
index 65493bcd9db..65493bcd9db 100644
--- a/tests/run-coverage/inner_items.coverage
+++ b/tests/coverage/inner_items.coverage
diff --git a/tests/coverage-map/status-quo/inner_items.rs b/tests/coverage/inner_items.rs
index bcb62b3031c..bcb62b3031c 100644
--- a/tests/coverage-map/status-quo/inner_items.rs
+++ b/tests/coverage/inner_items.rs
diff --git a/tests/coverage-map/status-quo/issue-83601.cov-map b/tests/coverage/issue-83601.cov-map
index f5db3a89750..f5db3a89750 100644
--- a/tests/coverage-map/status-quo/issue-83601.cov-map
+++ b/tests/coverage/issue-83601.cov-map
diff --git a/tests/run-coverage/issue-83601.coverage b/tests/coverage/issue-83601.coverage
index 7995332cad3..7995332cad3 100644
--- a/tests/run-coverage/issue-83601.coverage
+++ b/tests/coverage/issue-83601.coverage
diff --git a/tests/coverage-map/status-quo/issue-83601.rs b/tests/coverage/issue-83601.rs
index 0b72a81947c..0b72a81947c 100644
--- a/tests/coverage-map/status-quo/issue-83601.rs
+++ b/tests/coverage/issue-83601.rs
diff --git a/tests/coverage-map/status-quo/issue-84561.cov-map b/tests/coverage/issue-84561.cov-map
index 82582b309bf..82582b309bf 100644
--- a/tests/coverage-map/status-quo/issue-84561.cov-map
+++ b/tests/coverage/issue-84561.cov-map
diff --git a/tests/run-coverage/issue-84561.coverage b/tests/coverage/issue-84561.coverage
index e693866e277..e693866e277 100644
--- a/tests/run-coverage/issue-84561.coverage
+++ b/tests/coverage/issue-84561.coverage
diff --git a/tests/coverage-map/status-quo/issue-84561.rs b/tests/coverage/issue-84561.rs
index facf5b5b4cf..facf5b5b4cf 100644
--- a/tests/coverage-map/status-quo/issue-84561.rs
+++ b/tests/coverage/issue-84561.rs
diff --git a/tests/coverage/issue-85461.cov-map b/tests/coverage/issue-85461.cov-map
new file mode 100644
index 00000000000..d1c449b9a35
--- /dev/null
+++ b/tests/coverage/issue-85461.cov-map
@@ -0,0 +1,8 @@
+Function name: issue_85461::main
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 08, 01, 03, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 8, 1) to (start + 3, 2)
+
diff --git a/tests/run-coverage/issue-85461.coverage b/tests/coverage/issue-85461.coverage
index cbc910664d0..cbc910664d0 100644
--- a/tests/run-coverage/issue-85461.coverage
+++ b/tests/coverage/issue-85461.coverage
diff --git a/tests/run-coverage/issue-85461.rs b/tests/coverage/issue-85461.rs
index 9d4c90a827e..9d4c90a827e 100644
--- a/tests/run-coverage/issue-85461.rs
+++ b/tests/coverage/issue-85461.rs
diff --git a/tests/coverage-map/status-quo/issue-93054.cov-map b/tests/coverage/issue-93054.cov-map
index c2c6e9a6516..c2c6e9a6516 100644
--- a/tests/coverage-map/status-quo/issue-93054.cov-map
+++ b/tests/coverage/issue-93054.cov-map
diff --git a/tests/run-coverage/issue-93054.coverage b/tests/coverage/issue-93054.coverage
index 15f225326a4..15f225326a4 100644
--- a/tests/run-coverage/issue-93054.coverage
+++ b/tests/coverage/issue-93054.coverage
diff --git a/tests/coverage-map/status-quo/issue-93054.rs b/tests/coverage/issue-93054.rs
index da546cfeef8..da546cfeef8 100644
--- a/tests/coverage-map/status-quo/issue-93054.rs
+++ b/tests/coverage/issue-93054.rs
diff --git a/tests/coverage-map/status-quo/lazy_boolean.cov-map b/tests/coverage/lazy_boolean.cov-map
index 0ad393c40fa..0ad393c40fa 100644
--- a/tests/coverage-map/status-quo/lazy_boolean.cov-map
+++ b/tests/coverage/lazy_boolean.cov-map
diff --git a/tests/run-coverage/lazy_boolean.coverage b/tests/coverage/lazy_boolean.coverage
index 8f14082ef68..8f14082ef68 100644
--- a/tests/run-coverage/lazy_boolean.coverage
+++ b/tests/coverage/lazy_boolean.coverage
diff --git a/tests/coverage-map/status-quo/lazy_boolean.rs b/tests/coverage/lazy_boolean.rs
index bb6219e851c..bb6219e851c 100644
--- a/tests/coverage-map/status-quo/lazy_boolean.rs
+++ b/tests/coverage/lazy_boolean.rs
diff --git a/tests/coverage-map/long_and_wide.cov-map b/tests/coverage/long_and_wide.cov-map
index 97aebf9b18a..97aebf9b18a 100644
--- a/tests/coverage-map/long_and_wide.cov-map
+++ b/tests/coverage/long_and_wide.cov-map
diff --git a/tests/coverage/long_and_wide.coverage b/tests/coverage/long_and_wide.coverage
new file mode 100644
index 00000000000..d7d29ca40cd
--- /dev/null
+++ b/tests/coverage/long_and_wide.coverage
@@ -0,0 +1,151 @@
+   LL|       |// compile-flags: --edition=2021
+   LL|       |// ignore-tidy-linelength
+   LL|       |
+   LL|       |// This file deliberately contains line and column numbers larger than 127,
+   LL|       |// to verify that `coverage-dump`'s ULEB128 parser can handle them.
+   LL|       |
+   LL|      1|fn main() {
+   LL|      1|    wide_function();
+   LL|      1|    long_function();
+   LL|      1|    far_function();
+   LL|      1|}
+   LL|       |
+   LL|       |#[rustfmt::skip]
+   LL|      1|fn wide_function() { /*                                                                                                           */ (); }
+   LL|       |
+   LL|      1|fn long_function() {
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|}
+   LL|       |
+   LL|      1|fn far_function() {}
+
diff --git a/tests/coverage-map/long_and_wide.rs b/tests/coverage/long_and_wide.rs
index a7cbcd48027..a7cbcd48027 100644
--- a/tests/coverage-map/long_and_wide.rs
+++ b/tests/coverage/long_and_wide.rs
diff --git a/tests/coverage-map/status-quo/loop_break_value.cov-map b/tests/coverage/loop_break_value.cov-map
index 75018442d07..75018442d07 100644
--- a/tests/coverage-map/status-quo/loop_break_value.cov-map
+++ b/tests/coverage/loop_break_value.cov-map
diff --git a/tests/run-coverage/loop_break_value.coverage b/tests/coverage/loop_break_value.coverage
index 1f0630636dd..1f0630636dd 100644
--- a/tests/run-coverage/loop_break_value.coverage
+++ b/tests/coverage/loop_break_value.coverage
diff --git a/tests/coverage-map/status-quo/loop_break_value.rs b/tests/coverage/loop_break_value.rs
index dbc4fad7a23..dbc4fad7a23 100644
--- a/tests/coverage-map/status-quo/loop_break_value.rs
+++ b/tests/coverage/loop_break_value.rs
diff --git a/tests/coverage-map/status-quo/loops_branches.cov-map b/tests/coverage/loops_branches.cov-map
index 813583a9de7..813583a9de7 100644
--- a/tests/coverage-map/status-quo/loops_branches.cov-map
+++ b/tests/coverage/loops_branches.cov-map
diff --git a/tests/run-coverage/loops_branches.coverage b/tests/coverage/loops_branches.coverage
index 8cd6f1be3f7..8cd6f1be3f7 100644
--- a/tests/run-coverage/loops_branches.coverage
+++ b/tests/coverage/loops_branches.coverage
diff --git a/tests/coverage-map/status-quo/loops_branches.rs b/tests/coverage/loops_branches.rs
index f3a343bcc1f..f3a343bcc1f 100644
--- a/tests/coverage-map/status-quo/loops_branches.rs
+++ b/tests/coverage/loops_branches.rs
diff --git a/tests/coverage-map/status-quo/match_or_pattern.cov-map b/tests/coverage/match_or_pattern.cov-map
index d63407a99c3..d63407a99c3 100644
--- a/tests/coverage-map/status-quo/match_or_pattern.cov-map
+++ b/tests/coverage/match_or_pattern.cov-map
diff --git a/tests/run-coverage/match_or_pattern.coverage b/tests/coverage/match_or_pattern.coverage
index 94c7967215c..94c7967215c 100644
--- a/tests/run-coverage/match_or_pattern.coverage
+++ b/tests/coverage/match_or_pattern.coverage
diff --git a/tests/coverage-map/status-quo/match_or_pattern.rs b/tests/coverage/match_or_pattern.rs
index ab7aee51d1b..ab7aee51d1b 100644
--- a/tests/coverage-map/status-quo/match_or_pattern.rs
+++ b/tests/coverage/match_or_pattern.rs
diff --git a/tests/coverage-map/status-quo/nested_loops.cov-map b/tests/coverage/nested_loops.cov-map
index 35d92594e75..35d92594e75 100644
--- a/tests/coverage-map/status-quo/nested_loops.cov-map
+++ b/tests/coverage/nested_loops.cov-map
diff --git a/tests/run-coverage/nested_loops.coverage b/tests/coverage/nested_loops.coverage
index 143d0d26aa7..143d0d26aa7 100644
--- a/tests/run-coverage/nested_loops.coverage
+++ b/tests/coverage/nested_loops.coverage
diff --git a/tests/coverage-map/status-quo/nested_loops.rs b/tests/coverage/nested_loops.rs
index 4c7c7842796..4c7c7842796 100644
--- a/tests/coverage-map/status-quo/nested_loops.rs
+++ b/tests/coverage/nested_loops.rs
diff --git a/tests/coverage-map/status-quo/no_cov_crate.cov-map b/tests/coverage/no_cov_crate.cov-map
index 05b6448bbd2..05b6448bbd2 100644
--- a/tests/coverage-map/status-quo/no_cov_crate.cov-map
+++ b/tests/coverage/no_cov_crate.cov-map
diff --git a/tests/run-coverage/no_cov_crate.coverage b/tests/coverage/no_cov_crate.coverage
index f5a0322bf3e..f5a0322bf3e 100644
--- a/tests/run-coverage/no_cov_crate.coverage
+++ b/tests/coverage/no_cov_crate.coverage
diff --git a/tests/coverage-map/status-quo/no_cov_crate.rs b/tests/coverage/no_cov_crate.rs
index e12e4bc55e3..e12e4bc55e3 100644
--- a/tests/coverage-map/status-quo/no_cov_crate.rs
+++ b/tests/coverage/no_cov_crate.rs
diff --git a/tests/coverage-map/status-quo/overflow.cov-map b/tests/coverage/overflow.cov-map
index bfffd9b2ab5..39a5c05f879 100644
--- a/tests/coverage-map/status-quo/overflow.cov-map
+++ b/tests/coverage/overflow.cov-map
@@ -1,5 +1,5 @@
 Function name: overflow::main
-Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 0f, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 0a, 00, 0b, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
+Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 10, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 0a, 00, 0b, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -12,7 +12,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
 - expression 7 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 9
-- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 27)
+- Code(Counter(0)) at (prev + 16, 1) to (start + 1, 27)
 - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
     = (c0 + (c1 + (c2 + c3)))
 - Code(Expression(5, Sub)) at (prev + 1, 12) to (start + 0, 26)
@@ -27,14 +27,14 @@ Number of file 0 mappings: 9
 - Code(Counter(4)) at (prev + 2, 5) to (start + 1, 2)
 
 Function name: overflow::might_overflow
-Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 04, 01, 01, 12, 05, 01, 13, 02, 06, 02, 02, 06, 00, 07, 07, 01, 09, 05, 02]
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 05, 01, 01, 12, 05, 01, 13, 02, 06, 02, 02, 06, 00, 07, 07, 01, 09, 05, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 4, 1) to (start + 1, 18)
+- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 18)
 - Code(Counter(1)) at (prev + 1, 19) to (start + 2, 6)
 - Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
     = (c0 - c1)
diff --git a/tests/run-coverage/overflow.coverage b/tests/coverage/overflow.coverage
index cee076e88cd..4f8dffc0c48 100644
--- a/tests/run-coverage/overflow.coverage
+++ b/tests/coverage/overflow.coverage
@@ -1,4 +1,5 @@
    LL|       |#![allow(unused_assignments)]
+   LL|       |// compile-flags: -Coverflow-checks=yes
    LL|       |// failure-status: 101
    LL|       |
    LL|      4|fn might_overflow(to_add: u32) -> u32 {
diff --git a/tests/run-coverage/overflow.rs b/tests/coverage/overflow.rs
index bbb65c1b35d..1c40771b274 100644
--- a/tests/run-coverage/overflow.rs
+++ b/tests/coverage/overflow.rs
@@ -1,4 +1,5 @@
 #![allow(unused_assignments)]
+// compile-flags: -Coverflow-checks=yes
 // failure-status: 101
 
 fn might_overflow(to_add: u32) -> u32 {
diff --git a/tests/coverage-map/status-quo/panic_unwind.cov-map b/tests/coverage/panic_unwind.cov-map
index f6089ce55ae..f6089ce55ae 100644
--- a/tests/coverage-map/status-quo/panic_unwind.cov-map
+++ b/tests/coverage/panic_unwind.cov-map
diff --git a/tests/run-coverage/panic_unwind.coverage b/tests/coverage/panic_unwind.coverage
index 2b0777ef215..2b0777ef215 100644
--- a/tests/run-coverage/panic_unwind.coverage
+++ b/tests/coverage/panic_unwind.coverage
diff --git a/tests/coverage-map/status-quo/panic_unwind.rs b/tests/coverage/panic_unwind.rs
index 638d2eb6aaa..638d2eb6aaa 100644
--- a/tests/coverage-map/status-quo/panic_unwind.rs
+++ b/tests/coverage/panic_unwind.rs
diff --git a/tests/coverage-map/status-quo/partial_eq.cov-map b/tests/coverage/partial_eq.cov-map
index 3549116db7a..3549116db7a 100644
--- a/tests/coverage-map/status-quo/partial_eq.cov-map
+++ b/tests/coverage/partial_eq.cov-map
diff --git a/tests/run-coverage/partial_eq.coverage b/tests/coverage/partial_eq.coverage
index c6d9ad6cf27..c6d9ad6cf27 100644
--- a/tests/run-coverage/partial_eq.coverage
+++ b/tests/coverage/partial_eq.coverage
diff --git a/tests/coverage-map/status-quo/partial_eq.rs b/tests/coverage/partial_eq.rs
index dd8b42c18ce..dd8b42c18ce 100644
--- a/tests/coverage-map/status-quo/partial_eq.rs
+++ b/tests/coverage/partial_eq.rs
diff --git a/tests/coverage-map/status-quo/simple_loop.cov-map b/tests/coverage/simple_loop.cov-map
index f1691ffc5e6..f1691ffc5e6 100644
--- a/tests/coverage-map/status-quo/simple_loop.cov-map
+++ b/tests/coverage/simple_loop.cov-map
diff --git a/tests/run-coverage/simple_loop.coverage b/tests/coverage/simple_loop.coverage
index 691c6cd1e7d..691c6cd1e7d 100644
--- a/tests/run-coverage/simple_loop.coverage
+++ b/tests/coverage/simple_loop.coverage
diff --git a/tests/coverage-map/status-quo/simple_loop.rs b/tests/coverage/simple_loop.rs
index 6f7f23475b8..6f7f23475b8 100644
--- a/tests/coverage-map/status-quo/simple_loop.rs
+++ b/tests/coverage/simple_loop.rs
diff --git a/tests/coverage-map/status-quo/simple_match.cov-map b/tests/coverage/simple_match.cov-map
index 4a32745d292..4a32745d292 100644
--- a/tests/coverage-map/status-quo/simple_match.cov-map
+++ b/tests/coverage/simple_match.cov-map
diff --git a/tests/run-coverage/simple_match.coverage b/tests/coverage/simple_match.coverage
index 7f5dd3bb646..7f5dd3bb646 100644
--- a/tests/run-coverage/simple_match.coverage
+++ b/tests/coverage/simple_match.coverage
diff --git a/tests/coverage-map/status-quo/simple_match.rs b/tests/coverage/simple_match.rs
index be99e59a826..be99e59a826 100644
--- a/tests/coverage-map/status-quo/simple_match.rs
+++ b/tests/coverage/simple_match.rs
diff --git a/tests/coverage-map/status-quo/sort_groups.cov-map b/tests/coverage/sort_groups.cov-map
index db027f3dc32..3cbda6fbe1a 100644
--- a/tests/coverage-map/status-quo/sort_groups.cov-map
+++ b/tests/coverage/sort_groups.cov-map
@@ -28,6 +28,21 @@ Number of file 0 mappings: 4
 - Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
     = (c1 + (c0 - c1))
 
+Function name: sort_groups::generic_fn::<char>
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 11, 01, 01, 0c, 05, 01, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 01, 00, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
+Number of file 0 mappings: 4
+- Code(Counter(0)) at (prev + 17, 1) to (start + 1, 12)
+- Code(Counter(1)) at (prev + 1, 13) to (start + 2, 6)
+- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
+    = (c0 - c1)
+- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
+    = (c1 + (c0 - c1))
+
 Function name: sort_groups::generic_fn::<i32>
 Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 11, 01, 01, 0c, 05, 01, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 01, 00, 02]
 Number of files: 1
@@ -44,19 +59,19 @@ Number of file 0 mappings: 4
     = (c1 + (c0 - c1))
 
 Function name: sort_groups::main
-Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 06, 01, 04, 0d, 00, 04, 0e, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 02, 02]
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 06, 01, 04, 23, 05, 04, 24, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
-- expression 0 operands: lhs = Counter(0), rhs = Zero
-- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 6, 1) to (start + 4, 13)
-- Code(Zero) at (prev + 4, 14) to (start + 2, 6)
+- Code(Counter(0)) at (prev + 6, 1) to (start + 4, 35)
+- Code(Counter(1)) at (prev + 4, 36) to (start + 2, 6)
 - Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
-    = (c0 - Zero)
+    = (c0 - c1)
 - Code(Expression(1, Add)) at (prev + 1, 5) to (start + 2, 2)
-    = (Zero + (c0 - Zero))
+    = (c1 + (c0 - c1))
 
 Function name: sort_groups::other_fn
 Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 01, 00, 11]
diff --git a/tests/run-coverage/sort_groups.coverage b/tests/coverage/sort_groups.coverage
index 8733bf48a9c..c70d7b3b282 100644
--- a/tests/run-coverage/sort_groups.coverage
+++ b/tests/coverage/sort_groups.coverage
@@ -7,7 +7,7 @@
    LL|      1|    let cond = std::env::args().len() > 1;
    LL|      1|    generic_fn::<()>(cond);
    LL|      1|    generic_fn::<&'static str>(!cond);
-   LL|      1|    if false {
+   LL|      1|    if std::hint::black_box(false) {
    LL|      0|        generic_fn::<char>(cond);
    LL|      1|    }
    LL|      1|    generic_fn::<i32>(cond);
diff --git a/tests/run-coverage/sort_groups.rs b/tests/coverage/sort_groups.rs
index f89f9f3ec61..5adbbc6a87d 100644
--- a/tests/run-coverage/sort_groups.rs
+++ b/tests/coverage/sort_groups.rs
@@ -7,7 +7,7 @@ fn main() {
     let cond = std::env::args().len() > 1;
     generic_fn::<()>(cond);
     generic_fn::<&'static str>(!cond);
-    if false {
+    if std::hint::black_box(false) {
         generic_fn::<char>(cond);
     }
     generic_fn::<i32>(cond);
diff --git a/tests/coverage-map/status-quo/test_harness.cov-map b/tests/coverage/test_harness.cov-map
index 6940d2e2824..6940d2e2824 100644
--- a/tests/coverage-map/status-quo/test_harness.cov-map
+++ b/tests/coverage/test_harness.cov-map
diff --git a/tests/run-coverage/test_harness.coverage b/tests/coverage/test_harness.coverage
index ff6009f6fce..ff6009f6fce 100644
--- a/tests/run-coverage/test_harness.coverage
+++ b/tests/coverage/test_harness.coverage
diff --git a/tests/coverage-map/status-quo/test_harness.rs b/tests/coverage/test_harness.rs
index 12a755734c1..12a755734c1 100644
--- a/tests/coverage-map/status-quo/test_harness.rs
+++ b/tests/coverage/test_harness.rs
diff --git a/tests/coverage-map/status-quo/tight_inf_loop.cov-map b/tests/coverage/tight_inf_loop.cov-map
index 7fe3146b080..7fe3146b080 100644
--- a/tests/coverage-map/status-quo/tight_inf_loop.cov-map
+++ b/tests/coverage/tight_inf_loop.cov-map
diff --git a/tests/run-coverage/tight_inf_loop.coverage b/tests/coverage/tight_inf_loop.coverage
index c15c76b3aba..c15c76b3aba 100644
--- a/tests/run-coverage/tight_inf_loop.coverage
+++ b/tests/coverage/tight_inf_loop.coverage
diff --git a/tests/coverage-map/status-quo/tight_inf_loop.rs b/tests/coverage/tight_inf_loop.rs
index cef99027aaa..cef99027aaa 100644
--- a/tests/coverage-map/status-quo/tight_inf_loop.rs
+++ b/tests/coverage/tight_inf_loop.rs
diff --git a/tests/coverage-map/trivial.cov-map b/tests/coverage/trivial.cov-map
index 874e294a1c4..874e294a1c4 100644
--- a/tests/coverage-map/trivial.cov-map
+++ b/tests/coverage/trivial.cov-map
diff --git a/tests/coverage/trivial.coverage b/tests/coverage/trivial.coverage
new file mode 100644
index 00000000000..4f417979ef9
--- /dev/null
+++ b/tests/coverage/trivial.coverage
@@ -0,0 +1,4 @@
+   LL|       |// compile-flags: --edition=2021
+   LL|       |
+   LL|      1|fn main() {}
+
diff --git a/tests/coverage-map/trivial.rs b/tests/coverage/trivial.rs
index d0a9b44fb36..d0a9b44fb36 100644
--- a/tests/coverage-map/trivial.rs
+++ b/tests/coverage/trivial.rs
diff --git a/tests/coverage-map/status-quo/try_error_result.cov-map b/tests/coverage/try_error_result.cov-map
index 8367103a21a..8367103a21a 100644
--- a/tests/coverage-map/status-quo/try_error_result.cov-map
+++ b/tests/coverage/try_error_result.cov-map
diff --git a/tests/run-coverage/try_error_result.coverage b/tests/coverage/try_error_result.coverage
index 5d48cbd62f2..5d48cbd62f2 100644
--- a/tests/run-coverage/try_error_result.coverage
+++ b/tests/coverage/try_error_result.coverage
diff --git a/tests/coverage-map/status-quo/try_error_result.rs b/tests/coverage/try_error_result.rs
index 557cbf22bfa..557cbf22bfa 100644
--- a/tests/coverage-map/status-quo/try_error_result.rs
+++ b/tests/coverage/try_error_result.rs
diff --git a/tests/coverage-map/unreachable.cov-map b/tests/coverage/unreachable.cov-map
index 495419820c1..495419820c1 100644
--- a/tests/coverage-map/unreachable.cov-map
+++ b/tests/coverage/unreachable.cov-map
diff --git a/tests/run-coverage/unreachable.coverage b/tests/coverage/unreachable.coverage
index fa0ac9ccfa1..fa0ac9ccfa1 100644
--- a/tests/run-coverage/unreachable.coverage
+++ b/tests/coverage/unreachable.coverage
diff --git a/tests/coverage-map/unreachable.rs b/tests/coverage/unreachable.rs
index 6385bfa160d..6385bfa160d 100644
--- a/tests/coverage-map/unreachable.rs
+++ b/tests/coverage/unreachable.rs
diff --git a/tests/coverage-map/status-quo/unused.cov-map b/tests/coverage/unused.cov-map
index 9383d1e90ac..9383d1e90ac 100644
--- a/tests/coverage-map/status-quo/unused.cov-map
+++ b/tests/coverage/unused.cov-map
diff --git a/tests/run-coverage/unused.coverage b/tests/coverage/unused.coverage
index 056ffeb021a..056ffeb021a 100644
--- a/tests/run-coverage/unused.coverage
+++ b/tests/coverage/unused.coverage
diff --git a/tests/coverage-map/status-quo/unused.rs b/tests/coverage/unused.rs
index d985af13547..d985af13547 100644
--- a/tests/coverage-map/status-quo/unused.rs
+++ b/tests/coverage/unused.rs
diff --git a/tests/coverage/unused_mod.cov-map b/tests/coverage/unused_mod.cov-map
new file mode 100644
index 00000000000..241cb2610ff
--- /dev/null
+++ b/tests/coverage/unused_mod.cov-map
@@ -0,0 +1,16 @@
+Function name: unused_mod::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 04, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 4, 1) to (start + 2, 2)
+
+Function name: unused_mod::unused_module::never_called_function (unused)
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 02, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Zero) at (prev + 2, 1) to (start + 2, 2)
+
diff --git a/tests/run-coverage/unused_mod.coverage b/tests/coverage/unused_mod.coverage
index a8fa24ac6a7..a8fa24ac6a7 100644
--- a/tests/run-coverage/unused_mod.coverage
+++ b/tests/coverage/unused_mod.coverage
diff --git a/tests/run-coverage/unused_mod.rs b/tests/coverage/unused_mod.rs
index 6e62839c998..6e62839c998 100644
--- a/tests/run-coverage/unused_mod.rs
+++ b/tests/coverage/unused_mod.rs
diff --git a/tests/coverage/uses_crate.cov-map b/tests/coverage/uses_crate.cov-map
new file mode 100644
index 00000000000..9c06eab7005
--- /dev/null
+++ b/tests/coverage/uses_crate.cov-map
@@ -0,0 +1,40 @@
+Function name: used_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1b, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 27, 1) to (start + 2, 2)
+
+Function name: used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 19, 1) to (start + 2, 2)
+
+Function name: used_crate::used_only_from_bin_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 19, 1) to (start + 2, 2)
+
+Function name: used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1f, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 31, 1) to (start + 2, 2)
+
+Function name: uses_crate::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 0c, 01, 07, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 12, 1) to (start + 7, 2)
+
diff --git a/tests/run-coverage/uses_crate.coverage b/tests/coverage/uses_crate.coverage
index 50d92102a10..50d92102a10 100644
--- a/tests/run-coverage/uses_crate.coverage
+++ b/tests/coverage/uses_crate.coverage
diff --git a/tests/run-coverage/uses_crate.rs b/tests/coverage/uses_crate.rs
index ab203ad781d..ab203ad781d 100644
--- a/tests/run-coverage/uses_crate.rs
+++ b/tests/coverage/uses_crate.rs
diff --git a/tests/coverage/uses_inline_crate.cov-map b/tests/coverage/uses_inline_crate.cov-map
new file mode 100644
index 00000000000..6b621825c88
--- /dev/null
+++ b/tests/coverage/uses_inline_crate.cov-map
@@ -0,0 +1,55 @@
+Function name: used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 2c, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 44, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_inline_function
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 14, 01, 06, 0f, 05, 06, 10, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 01, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
+Number of file 0 mappings: 4
+- Code(Counter(0)) at (prev + 20, 1) to (start + 6, 15)
+- Code(Counter(1)) at (prev + 6, 16) to (start + 2, 6)
+- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
+    = (c0 - c1)
+- Code(Expression(1, Add)) at (prev + 1, 5) to (start + 1, 2)
+    = (c1 + (c0 - c1))
+
+Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 31, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 49, 1) to (start + 2, 2)
+
+Function name: uses_inline_crate::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 0c, 01, 0a, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 12, 1) to (start + 10, 2)
+
diff --git a/tests/run-coverage/uses_inline_crate.coverage b/tests/coverage/uses_inline_crate.coverage
index cc0e01ffde1..cc0e01ffde1 100644
--- a/tests/run-coverage/uses_inline_crate.coverage
+++ b/tests/coverage/uses_inline_crate.coverage
diff --git a/tests/run-coverage/uses_inline_crate.rs b/tests/coverage/uses_inline_crate.rs
index d7b4c3c057f..d7b4c3c057f 100644
--- a/tests/run-coverage/uses_inline_crate.rs
+++ b/tests/coverage/uses_inline_crate.rs
diff --git a/tests/coverage-map/status-quo/while.cov-map b/tests/coverage/while.cov-map
index af250f3fb71..af250f3fb71 100644
--- a/tests/coverage-map/status-quo/while.cov-map
+++ b/tests/coverage/while.cov-map
diff --git a/tests/run-coverage/while.coverage b/tests/coverage/while.coverage
index c9d497651c9..c9d497651c9 100644
--- a/tests/run-coverage/while.coverage
+++ b/tests/coverage/while.coverage
diff --git a/tests/coverage-map/status-quo/while.rs b/tests/coverage/while.rs
index 781b90b3566..781b90b3566 100644
--- a/tests/coverage-map/status-quo/while.rs
+++ b/tests/coverage/while.rs
diff --git a/tests/coverage-map/status-quo/while_early_ret.cov-map b/tests/coverage/while_early_ret.cov-map
index 369ebe891f1..369ebe891f1 100644
--- a/tests/coverage-map/status-quo/while_early_ret.cov-map
+++ b/tests/coverage/while_early_ret.cov-map
diff --git a/tests/run-coverage/while_early_ret.coverage b/tests/coverage/while_early_ret.coverage
index 49d39d36603..49d39d36603 100644
--- a/tests/run-coverage/while_early_ret.coverage
+++ b/tests/coverage/while_early_ret.coverage
diff --git a/tests/coverage-map/status-quo/while_early_ret.rs b/tests/coverage/while_early_ret.rs
index b2f0eee2cc0..b2f0eee2cc0 100644
--- a/tests/coverage-map/status-quo/while_early_ret.rs
+++ b/tests/coverage/while_early_ret.rs
diff --git a/tests/coverage-map/status-quo/yield.cov-map b/tests/coverage/yield.cov-map
index c9c9709fa4f..c9c9709fa4f 100644
--- a/tests/coverage-map/status-quo/yield.cov-map
+++ b/tests/coverage/yield.cov-map
diff --git a/tests/run-coverage/yield.coverage b/tests/coverage/yield.coverage
index d7e455f211e..d7e455f211e 100644
--- a/tests/run-coverage/yield.coverage
+++ b/tests/coverage/yield.coverage
diff --git a/tests/coverage-map/status-quo/yield.rs b/tests/coverage/yield.rs
index b7e2ba31b59..b7e2ba31b59 100644
--- a/tests/coverage-map/status-quo/yield.rs
+++ b/tests/coverage/yield.rs
diff --git a/tests/run-coverage/abort.rs b/tests/run-coverage/abort.rs
deleted file mode 100644
index 98264bdc1af..00000000000
--- a/tests/run-coverage/abort.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![feature(c_unwind)]
-#![allow(unused_assignments)]
-
-extern "C" fn might_abort(should_abort: bool) {
-    if should_abort {
-        println!("aborting...");
-        panic!("panics and aborts");
-    } else {
-        println!("Don't Panic");
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown < 5 {
-            might_abort(false);
-        }
-        // See discussion (below the `Notes` section) on coverage results for the closing brace.
-        if countdown < 5 { might_abort(false); } // Counts for different regions on one line.
-        // For the following example, the closing brace is the last character on the line.
-        // This shows the character after the closing brace is highlighted, even if that next
-        // character is a newline.
-        if countdown < 5 { might_abort(false); }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the similar tests
-//      `panic_unwind.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program includes `UnwindAction::Terminate`.
-//   3. The test does not invoke the abort. By executing to a successful completion, the coverage
-//      results show where the program did and did not execute.
-//   4. If the program actually aborted, the coverage counters would not be saved (which "works as
-//      intended"). Coverage results would show no executed coverage regions.
-//   6. If `should_abort` is `true` and the program aborts, the program exits with a `132` status
-//      (on Linux at least).
-
-/*
-
-Expect the following coverage results:
-
-```text
-    16|     11|    while countdown > 0 {
-    17|     10|        if countdown < 5 {
-    18|      4|            might_abort(false);
-    19|      6|        }
-```
-
-This is actually correct.
-
-The condition `countdown < 5` executed 10 times (10 loop iterations).
-
-It evaluated to `true` 4 times, and executed the `might_abort()` call.
-
-It skipped the body of the `might_abort()` call 6 times. If an `if` does not include an explicit
-`else`, the coverage implementation injects a counter, at the character immediately after the `if`s
-closing brace, to count the "implicit" `else`. This is the only way to capture the coverage of the
-non-true condition.
-
-As another example of why this is important, say the condition was `countdown < 50`, which is always
-`true`. In that case, we wouldn't have a test for what happens if `might_abort()` is not called.
-The closing brace would have a count of `0`, highlighting the missed coverage.
-*/
diff --git a/tests/run-coverage/assert.rs b/tests/run-coverage/assert.rs
deleted file mode 100644
index 85e6662a6ad..00000000000
--- a/tests/run-coverage/assert.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_fail_assert(one_plus_one: u32) {
-    println!("does 1 + 1 = {}?", one_plus_one);
-    assert_eq!(1 + 1, one_plus_one, "the argument was wrong");
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            might_fail_assert(3);
-        } else if countdown < 5 {
-            might_fail_assert(2);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the very similar test
-//      `panic_unwind.rs`, and similar tests `abort.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program passes or fails an `assert!()` or
-//      related `assert_*!()` macro.
-//   3. Notably, the `assert` macros *do not* generate `TerminatorKind::Assert`. The macros produce
-//      conditional expressions, `TerminatorKind::SwitchInt` branches, and a possible call to
-//      `begin_panic_fmt()` (that begins a panic unwind, if the assertion test fails).
-//   4. `TerminatoKind::Assert` is, however, also present in the MIR generated for this test
-//      (and in many other coverage tests). The `Assert` terminator is typically generated by the
-//      Rust compiler to check for runtime failures, such as numeric overflows.
diff --git a/tests/run-coverage/async.rs b/tests/run-coverage/async.rs
deleted file mode 100644
index efd9e62d64e..00000000000
--- a/tests/run-coverage/async.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#![allow(unused_assignments, dead_code)]
-
-// compile-flags: --edition=2018 -C opt-level=1
-
-async fn c(x: u8) -> u8 {
-    if x == 8 {
-        1
-    } else {
-        0
-    }
-}
-
-async fn d() -> u8 { 1 }
-
-async fn e() -> u8 { 1 } // unused function; executor does not block on `g()`
-
-async fn f() -> u8 { 1 }
-
-async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()`
-
-pub async fn g(x: u8) {
-    match x {
-        y if e().await == y => (),
-        y if f().await == y => (),
-        _ => (),
-    }
-}
-
-async fn h(x: usize) { // The function signature is counted when called, but the body is not
-                       // executed (not awaited) so the open brace has a `0` count (at least when
-                       // displayed with `llvm-cov show` in color-mode).
-    match x {
-        y if foo().await[y] => (),
-        _ => (),
-    }
-}
-
-async fn i(x: u8) { // line coverage is 1, but there are 2 regions:
-                    // (a) the function signature, counted when the function is called; and
-                    // (b) the open brace for the function body, counted once when the body is
-                    // executed asynchronously.
-    match x {
-        y if c(x).await == y + 1 => { d().await; }
-        y if f().await == y + 1 => (),
-        _ => (),
-    }
-}
-
-fn j(x: u8) {
-    // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.
-    fn c(x: u8) -> u8 {
-        if x == 8 {
-            1 // This line appears covered, but the 1-character expression span covering the `1`
-              // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because
-              // `fn j()` executes the open brace for the function body, followed by the function's
-              // first executable statement, `match x`. Inner function declarations are not
-              // "visible" to the MIR for `j()`, so the code region counts all lines between the
-              // open brace and the first statement as executed, which is, in a sense, true.
-              // `llvm-cov show` overcomes this kind of situation by showing the actual counts
-              // of the enclosed coverages, (that is, the `1` expression was not executed, and
-              // accurately displays a `0`).
-        } else {
-            0
-        }
-    }
-    fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed
-    fn f() -> u8 { 1 }
-    match x {
-        y if c(x) == y + 1 => { d(); }
-        y if f() == y + 1 => (),
-        _ => (),
-    }
-}
-
-fn k(x: u8) { // unused function
-    match x {
-        1 => (),
-        2 => (),
-        _ => (),
-    }
-}
-
-fn l(x: u8) {
-    match x {
-        1 => (),
-        2 => (),
-        _ => (),
-    }
-}
-
-async fn m(x: u8) -> u8 { x - 1 }
-
-fn main() {
-    let _ = g(10);
-    let _ = h(9);
-    let mut future = Box::pin(i(8));
-    j(7);
-    l(6);
-    let _ = m(5);
-    executor::block_on(future.as_mut());
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            |_| unsafe { unreachable_unchecked() }, // clone
-            |_| unsafe { unreachable_unchecked() }, // wake
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/async2.rs b/tests/run-coverage/async2.rs
deleted file mode 100644
index 2884ff297af..00000000000
--- a/tests/run-coverage/async2.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// compile-flags: --edition=2018
-
-fn non_async_func() {
-    println!("non_async_func was covered");
-    let b = true;
-    if b {
-        println!("non_async_func println in block");
-    }
-}
-
-async fn async_func() {
-    println!("async_func was covered");
-    let b = true;
-    if b {
-        println!("async_func println in block");
-    }
-}
-
-async fn async_func_just_println() {
-    println!("async_func_just_println was covered");
-}
-
-fn main() {
-    println!("codecovsample::main");
-
-    non_async_func();
-
-    executor::block_on(async_func());
-    executor::block_on(async_func_just_println());
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            |_| unsafe { unreachable_unchecked() }, // clone
-            |_| unsafe { unreachable_unchecked() }, // wake
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/bad_counter_ids.rs b/tests/run-coverage/bad_counter_ids.rs
deleted file mode 100644
index ef5460102b7..00000000000
--- a/tests/run-coverage/bad_counter_ids.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021 -Copt-level=0 -Zmir-opt-level=3
-
-// Regression test for <https://github.com/rust-lang/rust/issues/117012>.
-//
-// If some coverage counters were removed by MIR optimizations, we need to take
-// care not to refer to those counter IDs in coverage mappings, and instead
-// replace them with a constant zero value. If we don't, `llvm-cov` might see
-// a too-large counter ID and silently discard the entire function from its
-// coverage reports.
-
-#[derive(Debug, PartialEq, Eq)]
-struct Foo(u32);
-
-fn eq_good() {
-    println!("a");
-    assert_eq!(Foo(1), Foo(1));
-}
-
-fn eq_good_message() {
-    println!("b");
-    assert_eq!(Foo(1), Foo(1), "message b");
-}
-
-fn ne_good() {
-    println!("c");
-    assert_ne!(Foo(1), Foo(3));
-}
-
-fn ne_good_message() {
-    println!("d");
-    assert_ne!(Foo(1), Foo(3), "message d");
-}
-
-fn eq_bad() {
-    println!("e");
-    assert_eq!(Foo(1), Foo(3));
-}
-
-fn eq_bad_message() {
-    println!("f");
-    assert_eq!(Foo(1), Foo(3), "message f");
-}
-
-fn ne_bad() {
-    println!("g");
-    assert_ne!(Foo(1), Foo(1));
-}
-
-fn ne_bad_message() {
-    println!("h");
-    assert_ne!(Foo(1), Foo(1), "message h");
-}
-
-#[coverage(off)]
-fn main() {
-    eq_good();
-    eq_good_message();
-    ne_good();
-    ne_good_message();
-
-    assert!(std::panic::catch_unwind(eq_bad).is_err());
-    assert!(std::panic::catch_unwind(eq_bad_message).is_err());
-    assert!(std::panic::catch_unwind(ne_bad).is_err());
-    assert!(std::panic::catch_unwind(ne_bad_message).is_err());
-}
diff --git a/tests/run-coverage/closure.rs b/tests/run-coverage/closure.rs
deleted file mode 100644
index 16a2c4e33bd..00000000000
--- a/tests/run-coverage/closure.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-// compile-flags: -C opt-level=2
-
-// This test used to be sensitive to certain coverage-specific hacks in
-// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by
-// <https://github.com/rust-lang/rust/pull/83666>.
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-    let is_false = !is_true;
-
-    let mut some_string = Some(String::from("the string content"));
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            ||
-            {
-                let mut countdown = 0;
-                if is_false {
-                    countdown = 10;
-                }
-                "alt string 1".to_owned()
-            }
-        )
-    );
-
-    some_string = Some(String::from("the string content"));
-    let
-        a
-    =
-        ||
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        "alt string 2".to_owned()
-    };
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            a
-        )
-    );
-
-    some_string = None;
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            ||
-            {
-                let mut countdown = 0;
-                if is_false {
-                    countdown = 10;
-                }
-                "alt string 3".to_owned()
-            }
-        )
-    );
-
-    some_string = None;
-    let
-        a
-    =
-        ||
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        "alt string 4".to_owned()
-    };
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            a
-        )
-    );
-
-    let
-        quote_closure
-    =
-        |val|
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        format!("'{}'", val)
-    };
-    println!(
-        "Repeated, quoted string: {:?}"
-        ,
-        std::iter::repeat("repeat me")
-            .take(5)
-            .map
-        (
-            quote_closure
-        )
-            .collect::<Vec<_>>()
-    );
-
-    let
-        _unused_closure
-    =
-        |
-            mut countdown
-        |
-    {
-        if is_false {
-            countdown = 10;
-        }
-        "closure should be unused".to_owned()
-    };
-
-    let mut countdown = 10;
-    let _short_unused_closure = | _unused_arg: u8 | countdown += 1;
-
-
-    let short_used_covered_closure_macro = | used_arg: u8 | println!("called");
-    let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called");
-    let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called");
-
-
-
-
-    let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") };
-
-    let _shortish_unused_closure = | _unused_arg: u8 | {
-        println!("not called")
-    };
-
-    let _as_short_unused_closure = |
-        _unused_arg: u8
-    | { println!("not called") };
-
-    let _almost_as_short_unused_closure = |
-        _unused_arg: u8
-    | { println!("not called") }
-    ;
-
-
-
-
-
-    let _short_unused_closure_line_break_no_block = | _unused_arg: u8 |
-println!("not called")
-    ;
-
-    let _short_unused_closure_line_break_no_block2 =
-        | _unused_arg: u8 |
-            println!(
-                "not called"
-            )
-    ;
-
-    let short_used_not_covered_closure_line_break_no_block_embedded_branch =
-        | _unused_arg: u8 |
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-    ;
-
-    let short_used_not_covered_closure_line_break_block_embedded_branch =
-        | _unused_arg: u8 |
-        {
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-        }
-    ;
-
-    let short_used_covered_closure_line_break_no_block_embedded_branch =
-        | _unused_arg: u8 |
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-    ;
-
-    let short_used_covered_closure_line_break_block_embedded_branch =
-        | _unused_arg: u8 |
-        {
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-        }
-    ;
-
-    if is_false {
-        short_used_not_covered_closure_macro(0);
-        short_used_not_covered_closure_line_break_no_block_embedded_branch(0);
-        short_used_not_covered_closure_line_break_block_embedded_branch(0);
-    }
-    short_used_covered_closure_macro(0);
-    short_used_covered_closure_line_break_no_block_embedded_branch(0);
-    short_used_covered_closure_line_break_block_embedded_branch(0);
-}
diff --git a/tests/run-coverage/closure_bug.rs b/tests/run-coverage/closure_bug.rs
deleted file mode 100644
index 739bc5f0b51..00000000000
--- a/tests/run-coverage/closure_bug.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Regression test for #115930.
-// All of these closures are identical, and should produce identical output in
-// the coverage report. However, an unstable sort was causing them to be treated
-// inconsistently when preparing coverage spans.
-
-fn main() {
-    let truthy = std::env::args().len() == 1;
-
-    let a
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    a();
-    if truthy { a(); }
-
-    let b
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    b();
-    if truthy { b(); }
-
-    let c
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    c();
-    if truthy { c(); }
-
-    let d
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    d();
-    if truthy { d(); }
-}
diff --git a/tests/run-coverage/closure_macro.rs b/tests/run-coverage/closure_macro.rs
deleted file mode 100644
index 9b289141c2e..00000000000
--- a/tests/run-coverage/closure_macro.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// compile-flags: --edition=2018
-#![feature(coverage_attribute)]
-
-macro_rules! bail {
-    ($msg:literal $(,)?) => {
-        if $msg.len() > 0 {
-            println!("no msg");
-        } else {
-            println!($msg);
-        }
-        return Err(String::from($msg));
-    };
-}
-
-macro_rules! on_error {
-    ($value:expr, $error_message:expr) => {
-        $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
-            let message = format!($error_message, e);
-            if message.len() > 0 {
-                println!("{}", message);
-                Ok(String::from("ok"))
-            } else {
-                bail!("error");
-            }
-        })
-    };
-}
-
-fn load_configuration_files() -> Result<String, String> {
-    Ok(String::from("config"))
-}
-
-pub fn main() -> Result<(), String> {
-    println!("Starting service");
-    let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
-
-    let startup_delay_duration = String::from("arg");
-    let _ = (config, startup_delay_duration);
-    Ok(())
-}
diff --git a/tests/run-coverage/closure_macro_async.rs b/tests/run-coverage/closure_macro_async.rs
deleted file mode 100644
index b4275599e59..00000000000
--- a/tests/run-coverage/closure_macro_async.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-// compile-flags: --edition=2018
-#![feature(coverage_attribute)]
-
-macro_rules! bail {
-    ($msg:literal $(,)?) => {
-        if $msg.len() > 0 {
-            println!("no msg");
-        } else {
-            println!($msg);
-        }
-        return Err(String::from($msg));
-    };
-}
-
-macro_rules! on_error {
-    ($value:expr, $error_message:expr) => {
-        $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
-            let message = format!($error_message, e);
-            if message.len() > 0 {
-                println!("{}", message);
-                Ok(String::from("ok"))
-            } else {
-                bail!("error");
-            }
-        })
-    };
-}
-
-fn load_configuration_files() -> Result<String, String> {
-    Ok(String::from("config"))
-}
-
-pub async fn test() -> Result<(), String> {
-    println!("Starting service");
-    let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
-
-    let startup_delay_duration = String::from("arg");
-    let _ = (config, startup_delay_duration);
-    Ok(())
-}
-
-#[coverage(off)]
-fn main() {
-    executor::block_on(test()).unwrap();
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    #[coverage(off)]
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // clone
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // wake
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            #[coverage(off)]
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/conditions.rs b/tests/run-coverage/conditions.rs
deleted file mode 100644
index fa7f2a116c2..00000000000
--- a/tests/run-coverage/conditions.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let mut countdown = 0;
-    if true {
-        countdown = 10;
-    }
-
-    const B: u32 = 100;
-    let x = if countdown > 7 {
-        countdown -= 4;
-        B
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-        countdown
-    } else {
-        return;
-    };
-
-    let mut countdown = 0;
-    if true {
-        countdown = 10;
-    }
-
-    if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        return;
-    }
-
-    if true {
-        let mut countdown = 0;
-        if true {
-            countdown = 10;
-        }
-
-        if countdown > 7 {
-            countdown -= 4;
-        }
-        else if countdown > 2 {
-            if countdown < 1 || countdown > 5 || countdown != 9 {
-                countdown = 0;
-            }
-            countdown -= 5;
-        } else {
-            return;
-        }
-    }
-
-    let mut countdown = 0;
-    if true {
-        countdown = 1;
-    }
-
-    let z = if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        let should_be_reachable = countdown;
-        println!("reached");
-        return;
-    };
-
-    let w = if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        return;
-    };
-}
diff --git a/tests/run-coverage/continue.rs b/tests/run-coverage/continue.rs
deleted file mode 100644
index 624aa98341b..00000000000
--- a/tests/run-coverage/continue.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-
-    let mut x = 0;
-    for _ in 0..10 {
-        match is_true {
-            true => {
-                continue;
-            }
-            _ => {
-                x = 1;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                continue;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            true => {
-                x = 1;
-            }
-            _ => {
-                continue;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        if is_true {
-            continue;
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                let _ = x;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                break;
-            }
-        }
-        x = 3;
-    }
-    let _ = x;
-}
diff --git a/tests/run-coverage/coroutine.rs b/tests/run-coverage/coroutine.rs
deleted file mode 100644
index 86d19af6f4f..00000000000
--- a/tests/run-coverage/coroutine.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![feature(coroutines, coroutine_trait)]
-
-use std::ops::{Coroutine, CoroutineState};
-use std::pin::Pin;
-
-// The following implementation of a function called from a `yield` statement
-// (apparently requiring the Result and the `String` type or constructor)
-// creates conditions where the `coroutine::StateTransform` MIR transform will
-// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic
-// to handle this condition, and still report dead block coverage.
-fn get_u32(val: bool) -> Result<u32, String> {
-    if val { Ok(1) } else { Err(String::from("some error")) }
-}
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-    let mut coroutine = || {
-        yield get_u32(is_true);
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(Ok(1)) => {}
-        _ => panic!("unexpected return from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Complete("foo") => {}
-        _ => panic!("unexpected return from resume"),
-    }
-}
diff --git a/tests/run-coverage/dead_code.rs b/tests/run-coverage/dead_code.rs
deleted file mode 100644
index 3492712a6f9..00000000000
--- a/tests/run-coverage/dead_code.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(dead_code, unused_assignments, unused_variables)]
-
-pub fn unused_pub_fn_not_in_library() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
-
-fn unused_fn() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
diff --git a/tests/run-coverage/drop_trait.rs b/tests/run-coverage/drop_trait.rs
deleted file mode 100644
index 7b062719c6b..00000000000
--- a/tests/run-coverage/drop_trait.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-struct Firework {
-    strength: i32,
-}
-
-impl Drop for Firework {
-    fn drop(&mut self) {
-        println!("BOOM times {}!!!", self.strength);
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let _firecracker = Firework { strength: 1 };
-
-    let _tnt = Firework { strength: 100 };
-
-    if true {
-        println!("Exiting with error...");
-        return Err(1);
-    }
-
-    let _ = Firework { strength: 1000 };
-
-    Ok(())
-}
-
-// Expected program output:
-//   Exiting with error...
-//   BOOM times 100!!!
-//   BOOM times 1!!!
-//   Error: 1
diff --git a/tests/run-coverage/fn_sig_into_try.rs b/tests/run-coverage/fn_sig_into_try.rs
deleted file mode 100644
index 92850c8a188..00000000000
--- a/tests/run-coverage/fn_sig_into_try.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021
-
-// Regression test for inconsistent handling of function signature spans that
-// are followed by code using the `?` operator.
-//
-// For each of these similar functions, the line containing the function
-// signature should be handled in the same way.
-
-fn a() -> Option<i32>
-{
-    Some(7i32);
-    Some(0)
-}
-
-fn b() -> Option<i32>
-{
-    Some(7i32)?;
-    Some(0)
-}
-
-fn c() -> Option<i32>
-{
-    let _ = Some(7i32)?;
-    Some(0)
-}
-
-fn d() -> Option<i32>
-{
-    let _: () = ();
-    Some(7i32)?;
-    Some(0)
-}
-
-#[coverage(off)]
-fn main() {
-    a();
-    b();
-    c();
-    d();
-}
diff --git a/tests/run-coverage/generics.rs b/tests/run-coverage/generics.rs
deleted file mode 100644
index bf4c2d8d685..00000000000
--- a/tests/run-coverage/generics.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-struct Firework<T> where T: Copy + std::fmt::Display {
-    strength: T,
-}
-
-impl<T> Firework<T> where T: Copy + std::fmt::Display {
-    #[inline(always)]
-    fn set_strength(&mut self, new_strength: T) {
-        self.strength = new_strength;
-    }
-}
-
-impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
-    #[inline(always)]
-    fn drop(&mut self) {
-        println!("BOOM times {}!!!", self.strength);
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut firecracker = Firework { strength: 1 };
-    firecracker.set_strength(2);
-
-    let mut tnt = Firework { strength: 100.1 };
-    tnt.set_strength(200.1);
-    tnt.set_strength(300.3);
-
-    if true {
-        println!("Exiting with error...");
-        return Err(1);
-    }
-
-    let _ = Firework { strength: 1000 };
-
-    Ok(())
-}
-
-// Expected program output:
-//   Exiting with error...
-//   BOOM times 100!!!
-//   BOOM times 1!!!
-//   Error: 1
diff --git a/tests/run-coverage/if.rs b/tests/run-coverage/if.rs
deleted file mode 100644
index 8ad5042ff7b..00000000000
--- a/tests/run-coverage/if.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let
-    is_true
-    =
-        std::env::args().len()
-    ==
-        1
-    ;
-    let
-        mut
-    countdown
-    =
-        0
-    ;
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-}
diff --git a/tests/run-coverage/if_else.rs b/tests/run-coverage/if_else.rs
deleted file mode 100644
index 3244e1e3afd..00000000000
--- a/tests/run-coverage/if_else.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-    else // Note coverage region difference without semicolon
-    {
-        countdown
-        =
-            100
-    }
-
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-    else
-    {
-        countdown
-        =
-            100
-        ;
-    }
-}
diff --git a/tests/run-coverage/inline-dead.rs b/tests/run-coverage/inline-dead.rs
deleted file mode 100644
index 854fa062967..00000000000
--- a/tests/run-coverage/inline-dead.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Regression test for issue #98833.
-// compile-flags: -Zinline-mir -Cdebug-assertions=off
-
-fn main() {
-    println!("{}", live::<false>());
-
-    let f = |x: bool| {
-        debug_assert!(
-            x
-        );
-    };
-    f(false);
-}
-
-#[inline]
-fn live<const B: bool>() -> u32 {
-    if B {
-        dead()
-    } else {
-        0
-    }
-}
-
-#[inline]
-fn dead() -> u32 {
-    42
-}
diff --git a/tests/run-coverage/inline.rs b/tests/run-coverage/inline.rs
deleted file mode 100644
index 9cfab9ddbad..00000000000
--- a/tests/run-coverage/inline.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// compile-flags: -Zinline-mir
-
-use std::fmt::Display;
-
-fn main() {
-    permutations(&['a', 'b', 'c']);
-}
-
-#[inline(always)]
-fn permutations<T: Copy + Display>(xs: &[T]) {
-    let mut ys = xs.to_owned();
-    permutate(&mut ys, 0);
-}
-
-fn permutate<T: Copy + Display>(xs: &mut [T], k: usize) {
-    let n = length(xs);
-    if k == n {
-        display(xs);
-    } else if k < n {
-        for i in k..n {
-            swap(xs, i, k);
-            permutate(xs, k + 1);
-            swap(xs, i, k);
-        }
-    } else {
-        error();
-    }
-}
-
-fn length<T>(xs: &[T]) -> usize {
-    xs.len()
-}
-
-#[inline]
-fn swap<T: Copy>(xs: &mut [T], i: usize, j: usize) {
-    let t = xs[i];
-    xs[i] = xs[j];
-    xs[j] = t;
-}
-
-fn display<T: Display>(xs: &[T]) {
-    for x in xs {
-        print!("{}", x);
-    }
-    println!();
-}
-
-#[inline(always)]
-fn error() {
-    panic!("error");
-}
diff --git a/tests/run-coverage/inner_items.rs b/tests/run-coverage/inner_items.rs
deleted file mode 100644
index bcb62b3031c..00000000000
--- a/tests/run-coverage/inner_items.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(unused_assignments, unused_variables, dead_code)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-
-    mod in_mod {
-        const IN_MOD_CONST: u32 = 1000;
-    }
-
-    fn in_func(a: u32) {
-        let b = 1;
-        let c = a + b;
-        println!("c = {}", c)
-    }
-
-    struct InStruct {
-        in_struct_field: u32,
-    }
-
-    const IN_CONST: u32 = 1234;
-
-    trait InTrait {
-        fn trait_func(&mut self, incr: u32);
-
-        fn default_trait_func(&mut self) {
-            in_func(IN_CONST);
-            self.trait_func(IN_CONST);
-        }
-    }
-
-    impl InTrait for InStruct {
-        fn trait_func(&mut self, incr: u32) {
-            self.in_struct_field += incr;
-            in_func(self.in_struct_field);
-        }
-    }
-
-    type InType = String;
-
-    if is_true {
-        in_func(countdown);
-    }
-
-    let mut val = InStruct {
-        in_struct_field: 101,
-    };
-
-    val.default_trait_func();
-}
diff --git a/tests/run-coverage/issue-83601.rs b/tests/run-coverage/issue-83601.rs
deleted file mode 100644
index 0b72a81947c..00000000000
--- a/tests/run-coverage/issue-83601.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Shows that rust-lang/rust/83601 is resolved
-
-#[derive(Debug, PartialEq, Eq)]
-struct Foo(u32);
-
-fn main() {
-    let bar = Foo(1);
-    assert_eq!(bar, Foo(1));
-    let baz = Foo(0);
-    assert_ne!(baz, Foo(1));
-    println!("{:?}", Foo(1));
-    println!("{:?}", bar);
-    println!("{:?}", baz);
-}
diff --git a/tests/run-coverage/issue-84561.rs b/tests/run-coverage/issue-84561.rs
deleted file mode 100644
index facf5b5b4cf..00000000000
--- a/tests/run-coverage/issue-84561.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results.
-
-// failure-status: 101
-#[derive(PartialEq, Eq)]
-struct Foo(u32);
-fn test3() {
-    let is_true = std::env::args().len() == 1;
-    let bar = Foo(1);
-    assert_eq!(bar, Foo(1));
-    let baz = Foo(0);
-    assert_ne!(baz, Foo(1));
-    println!("{:?}", Foo(1));
-    println!("{:?}", bar);
-    println!("{:?}", baz);
-
-    assert_eq!(Foo(1), Foo(1));
-    assert_ne!(Foo(0), Foo(1));
-    assert_eq!(Foo(2), Foo(2));
-    let bar = Foo(0);
-    assert_ne!(bar, Foo(3));
-    assert_ne!(Foo(0), Foo(4));
-    assert_eq!(Foo(3), Foo(3), "with a message");
-    println!("{:?}", bar);
-    println!("{:?}", Foo(1));
-
-    assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" });
-    assert_ne!(
-        Foo(0)
-        ,
-        Foo(5)
-        ,
-        "{}"
-        ,
-        if
-        is_true
-        {
-            "true message"
-        } else {
-            "false message"
-        }
-    );
-
-    let is_true = std::env::args().len() == 1;
-
-    assert_eq!(
-        Foo(1),
-        Foo(1)
-    );
-    assert_ne!(
-        Foo(0),
-        Foo(1)
-    );
-    assert_eq!(
-        Foo(2),
-        Foo(2)
-    );
-    let bar = Foo(1);
-    assert_ne!(
-        bar,
-        Foo(3)
-    );
-    if is_true {
-        assert_ne!(
-            Foo(0),
-            Foo(4)
-        );
-    } else {
-        assert_eq!(
-            Foo(3),
-            Foo(3)
-        );
-    }
-    if is_true {
-        assert_ne!(
-            Foo(0),
-            Foo(4),
-            "with a message"
-        );
-    } else {
-        assert_eq!(
-            Foo(3),
-            Foo(3),
-            "with a message"
-        );
-    }
-    assert_ne!(
-        if is_true {
-            Foo(0)
-        } else {
-            Foo(1)
-        },
-        Foo(5)
-    );
-    assert_ne!(
-        Foo(5),
-        if is_true {
-            Foo(0)
-        } else {
-            Foo(1)
-        }
-    );
-    assert_ne!(
-        if is_true {
-            assert_eq!(
-                Foo(3),
-                Foo(3)
-            );
-            Foo(0)
-        } else {
-            assert_ne!(
-                if is_true {
-                    Foo(0)
-                } else {
-                    Foo(1)
-                },
-                Foo(5)
-            );
-            Foo(1)
-        },
-        Foo(5),
-        "with a message"
-    );
-    assert_eq!(
-        Foo(1),
-        Foo(3),
-        "this assert should fail"
-    );
-    assert_eq!(
-        Foo(3),
-        Foo(3),
-        "this assert should not be reached"
-    );
-}
-
-impl std::fmt::Debug for Foo {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "try and succeed")?;
-        Ok(())
-    }
-}
-
-static mut DEBUG_LEVEL_ENABLED: bool = false;
-
-macro_rules! debug {
-    ($($arg:tt)+) => (
-        if unsafe { DEBUG_LEVEL_ENABLED } {
-            println!($($arg)+);
-        }
-    );
-}
-
-fn test1() {
-    debug!("debug is enabled");
-    debug!("debug is enabled");
-    let _ = 0;
-    debug!("debug is enabled");
-    unsafe {
-        DEBUG_LEVEL_ENABLED = true;
-    }
-    debug!("debug is enabled");
-}
-
-macro_rules! call_debug {
-    ($($arg:tt)+) => (
-        fn call_print(s: &str) {
-            print!("{}", s);
-        }
-
-        call_print("called from call_debug: ");
-        debug!($($arg)+);
-    );
-}
-
-fn test2() {
-    call_debug!("debug is enabled");
-}
-
-fn main() {
-    test1();
-    test2();
-    test3();
-}
diff --git a/tests/run-coverage/issue-93054.rs b/tests/run-coverage/issue-93054.rs
deleted file mode 100644
index da546cfeef8..00000000000
--- a/tests/run-coverage/issue-93054.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(dead_code, unreachable_code)]
-
-// Regression test for #93054: Functions using uninhabited types often only have a single,
-// unreachable basic block which doesn't get instrumented. This should not cause llvm-cov to fail.
-// Since these kinds functions can't be invoked anyway, it's ok to not have coverage data for them.
-
-// compile-flags: --edition=2021
-
-enum Never {}
-
-impl Never {
-    fn foo(self) {
-        match self {}
-        make().map(|never| match never {});
-    }
-
-    fn bar(&self) {
-        match *self {}
-    }
-}
-
-async fn foo2(never: Never) {
-    match never {}
-}
-
-fn make() -> Option<Never> {
-    None
-}
-
-fn main() {}
diff --git a/tests/run-coverage/lazy_boolean.rs b/tests/run-coverage/lazy_boolean.rs
deleted file mode 100644
index bb6219e851c..00000000000
--- a/tests/run-coverage/lazy_boolean.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let (mut a, mut b, mut c) = (0, 0, 0);
-    if is_true {
-        a = 1;
-        b = 10;
-        c = 100;
-    }
-    let
-        somebool
-        =
-            a < b
-        ||
-            b < c
-    ;
-    let
-        somebool
-        =
-            b < a
-        ||
-            b < c
-    ;
-    let somebool = a < b && b < c;
-    let somebool = b < a && b < c;
-
-    if
-        !
-        is_true
-    {
-        a = 2
-        ;
-    }
-
-    if
-        is_true
-    {
-        b = 30
-        ;
-    }
-    else
-    {
-        c = 400
-        ;
-    }
-
-    if !is_true {
-        a = 2;
-    }
-
-    if is_true {
-        b = 30;
-    } else {
-        c = 400;
-    }
-}
diff --git a/tests/run-coverage/loop_break_value.rs b/tests/run-coverage/loop_break_value.rs
deleted file mode 100644
index dbc4fad7a23..00000000000
--- a/tests/run-coverage/loop_break_value.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let result
-        =
-            loop
-        {
-            break
-            10
-            ;
-        }
-    ;
-}
diff --git a/tests/run-coverage/loops_branches.rs b/tests/run-coverage/loops_branches.rs
deleted file mode 100644
index f3a343bcc1f..00000000000
--- a/tests/run-coverage/loops_branches.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-#![allow(unused_assignments, unused_variables, while_true)]
-
-// This test confirms that (1) unexecuted infinite loops are handled correctly by the
-// InstrumentCoverage MIR pass; and (2) Counter Expressions that subtract from zero can be dropped.
-
-struct DebugTest;
-
-impl std::fmt::Debug for DebugTest {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if true {
-            if false {
-                while true {}
-            }
-            write!(f, "cool")?;
-        } else {
-        }
-
-        for i in 0..10 {
-            if true {
-                if false {
-                    while true {}
-                }
-                write!(f, "cool")?;
-            } else {
-            }
-        }
-        Ok(())
-    }
-}
-
-struct DisplayTest;
-
-impl std::fmt::Display for DisplayTest {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if false {
-        } else {
-            if false {
-                while true {}
-            }
-            write!(f, "cool")?;
-        }
-        for i in 0..10 {
-            if false {
-            } else {
-                if false {
-                    while true {}
-                }
-                write!(f, "cool")?;
-            }
-        }
-        Ok(())
-    }
-}
-
-fn main() {
-    let debug_test = DebugTest;
-    println!("{:?}", debug_test);
-    let display_test = DisplayTest;
-    println!("{}", display_test);
-}
diff --git a/tests/run-coverage/match_or_pattern.rs b/tests/run-coverage/match_or_pattern.rs
deleted file mode 100644
index ab7aee51d1b..00000000000
--- a/tests/run-coverage/match_or_pattern.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut a: u8 = 0;
-    let mut b: u8 = 0;
-    if is_true {
-        a = 2;
-        b = 0;
-    }
-    match (a, b) {
-        // Or patterns generate MIR `SwitchInt` with multiple targets to the same `BasicBlock`.
-        // This test confirms a fix for Issue #79569.
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 0;
-        b = 0;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 2;
-        b = 2;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 0;
-        b = 2;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-}
diff --git a/tests/run-coverage/nested_loops.rs b/tests/run-coverage/nested_loops.rs
deleted file mode 100644
index 4c7c7842796..00000000000
--- a/tests/run-coverage/nested_loops.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-fn main() {
-    let is_true = std::env::args().len() == 1;
-    let mut countdown = 10;
-
-    'outer: while countdown > 0 {
-        let mut a = 100;
-        let mut b = 100;
-        for _ in 0..50 {
-            if a < 30 {
-                break;
-            }
-            a -= 5;
-            b -= 5;
-            if b < 90 {
-                a -= 10;
-                if is_true {
-                    break 'outer;
-                } else {
-                    a -= 2;
-                }
-            }
-        }
-        countdown -= 1;
-    }
-}
diff --git a/tests/run-coverage/no_cov_crate.rs b/tests/run-coverage/no_cov_crate.rs
deleted file mode 100644
index e12e4bc55e3..00000000000
--- a/tests/run-coverage/no_cov_crate.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Enables `coverage(off)` on the entire crate
-#![feature(coverage_attribute)]
-
-#[coverage(off)]
-fn do_not_add_coverage_1() {
-    println!("called but not covered");
-}
-
-fn do_not_add_coverage_2() {
-    #![coverage(off)]
-    println!("called but not covered");
-}
-
-#[coverage(off)]
-#[allow(dead_code)]
-fn do_not_add_coverage_not_called() {
-    println!("not called and not covered");
-}
-
-fn add_coverage_1() {
-    println!("called and covered");
-}
-
-fn add_coverage_2() {
-    println!("called and covered");
-}
-
-#[allow(dead_code)]
-fn add_coverage_not_called() {
-    println!("not called but covered");
-}
-
-// FIXME: These test-cases illustrate confusing results of nested functions.
-// See https://github.com/rust-lang/rust/issues/93319
-mod nested_fns {
-    #[coverage(off)]
-    pub fn outer_not_covered(is_true: bool) {
-        fn inner(is_true: bool) {
-            if is_true {
-                println!("called and covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-        println!("called but not covered");
-        inner(is_true);
-    }
-
-    pub fn outer(is_true: bool) {
-        println!("called and covered");
-        inner_not_covered(is_true);
-
-        #[coverage(off)]
-        fn inner_not_covered(is_true: bool) {
-            if is_true {
-                println!("called but not covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-    }
-
-    pub fn outer_both_covered(is_true: bool) {
-        println!("called and covered");
-        inner(is_true);
-
-        fn inner(is_true: bool) {
-            if is_true {
-                println!("called and covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-    }
-}
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-
-    do_not_add_coverage_1();
-    do_not_add_coverage_2();
-    add_coverage_1();
-    add_coverage_2();
-
-    nested_fns::outer_not_covered(is_true);
-    nested_fns::outer(is_true);
-    nested_fns::outer_both_covered(is_true);
-}
diff --git a/tests/run-coverage/panic_unwind.rs b/tests/run-coverage/panic_unwind.rs
deleted file mode 100644
index 638d2eb6aaa..00000000000
--- a/tests/run-coverage/panic_unwind.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_panic(should_panic: bool) {
-    if should_panic {
-        println!("panicking...");
-        panic!("panics");
-    } else {
-        println!("Don't Panic");
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            might_panic(true);
-        } else if countdown < 5 {
-            might_panic(false);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the similar tests `abort.rs` and
-//      `try_error_result.rs`.
-//   2. Since the `panic_unwind.rs` test is allowed to unwind, it is also allowed to execute the
-//      normal program exit cleanup, including writing out the current values of the coverage
-//      counters.
diff --git a/tests/run-coverage/partial_eq.rs b/tests/run-coverage/partial_eq.rs
deleted file mode 100644
index dd8b42c18ce..00000000000
--- a/tests/run-coverage/partial_eq.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
-// structure of this test.
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Version {
-    major: usize,
-    minor: usize,
-    patch: usize,
-}
-
-impl Version {
-    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
-        Self {
-            major,
-            minor,
-            patch,
-        }
-    }
-}
-
-fn main() {
-    let version_3_2_1 = Version::new(3, 2, 1);
-    let version_3_3_0 = Version::new(3, 3, 0);
-
-    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);
-}
-
-/*
-
-This test verifies a bug was fixed that otherwise generated this error:
-
-thread 'rustc' panicked at 'No counters provided the source_hash for function:
-    Instance {
-        def: Item(WithOptConstParam {
-            did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp),
-            const_param_did: None
-        }),
-        args: []
-    }'
-The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage
-without a code region associated with any `Counter`. Code regions were associated with at least
-one expression, which is allowed, but the `function_source_hash` was only passed to the codegen
-(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the
-`function_source_hash` without a code region, if necessary.
-
-*/
diff --git a/tests/run-coverage/simple_loop.rs b/tests/run-coverage/simple_loop.rs
deleted file mode 100644
index 6f7f23475b8..00000000000
--- a/tests/run-coverage/simple_loop.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(unused_assignments)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-
-    loop
-    {
-        if
-            countdown
-                ==
-            0
-        {
-            break
-            ;
-        }
-        countdown
-        -=
-        1
-        ;
-    }
-}
diff --git a/tests/run-coverage/simple_match.rs b/tests/run-coverage/simple_match.rs
deleted file mode 100644
index be99e59a826..00000000000
--- a/tests/run-coverage/simple_match.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 1;
-    if is_true {
-        countdown = 0;
-    }
-
-    for
-        _
-    in
-        0..2
-    {
-        let z
-        ;
-        match
-            countdown
-        {
-            x
-            if
-                x
-                    <
-                1
-            =>
-            {
-                z = countdown
-                ;
-                let y = countdown
-                ;
-                countdown = 10
-                ;
-            }
-            _
-            =>
-            {}
-        }
-    }
-}
diff --git a/tests/run-coverage/test_harness.rs b/tests/run-coverage/test_harness.rs
deleted file mode 100644
index 12a755734c1..00000000000
--- a/tests/run-coverage/test_harness.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verify that the entry point injected by the test harness doesn't cause
-// weird artifacts in the coverage report (e.g. issue #10749).
-
-// compile-flags: --test
-
-#[allow(dead_code)]
-fn unused() {}
-
-#[test]
-fn my_test() {}
diff --git a/tests/run-coverage/tight_inf_loop.rs b/tests/run-coverage/tight_inf_loop.rs
deleted file mode 100644
index cef99027aaa..00000000000
--- a/tests/run-coverage/tight_inf_loop.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    if false {
-        loop {}
-    }
-}
diff --git a/tests/run-coverage/try_error_result.rs b/tests/run-coverage/try_error_result.rs
deleted file mode 100644
index 557cbf22bfa..00000000000
--- a/tests/run-coverage/try_error_result.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-fn call(return_error: bool) -> Result<(), ()> {
-    if return_error {
-        Err(())
-    } else {
-        Ok(())
-    }
-}
-
-fn test1() -> Result<(), ()> {
-    let mut
-        countdown = 10
-    ;
-    for
-        _
-    in
-        0..10
-    {
-        countdown
-            -= 1
-        ;
-        if
-            countdown < 5
-        {
-            call(/*return_error=*/ true)?;
-            call(/*return_error=*/ false)?;
-        }
-        else
-        {
-            call(/*return_error=*/ false)?;
-        }
-    }
-    Ok(())
-}
-
-struct Thing1;
-impl Thing1 {
-    fn get_thing_2(&self, return_error: bool) -> Result<Thing2, ()> {
-        if return_error {
-            Err(())
-        } else {
-            Ok(Thing2 {})
-        }
-    }
-}
-
-struct Thing2;
-impl Thing2 {
-    fn call(&self, return_error: bool) -> Result<u32, ()> {
-        if return_error {
-            Err(())
-        } else {
-            Ok(57)
-        }
-    }
-}
-
-fn test2() -> Result<(), ()> {
-    let thing1 = Thing1{};
-    let mut
-        countdown = 10
-    ;
-    for
-        _
-    in
-        0..10
-    {
-        countdown
-            -= 1
-        ;
-        if
-            countdown < 5
-        {
-            thing1.get_thing_2(/*err=*/ false)?.call(/*err=*/ true).expect_err("call should fail");
-            thing1
-                .
-                get_thing_2(/*return_error=*/ false)
-                ?
-                .
-                call(/*return_error=*/ true)
-                .
-                expect_err(
-                    "call should fail"
-                );
-            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ true)?;
-            assert_eq!(val, 57);
-            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-        }
-        else
-        {
-            let val = thing1.get_thing_2(/*return_error=*/ false)?.call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-            let val = thing1
-                .get_thing_2(/*return_error=*/ false)?
-                .call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-            let val = thing1
-                .get_thing_2(/*return_error=*/ false)
-                ?
-                .call(/*return_error=*/ false)
-                ?
-                ;
-            assert_eq!(val, 57);
-        }
-    }
-    Ok(())
-}
-
-fn main() -> Result<(), ()> {
-    test1().expect_err("test1 should fail");
-    test2()
-    ?
-    ;
-    Ok(())
-}
diff --git a/tests/run-coverage/unreachable.rs b/tests/run-coverage/unreachable.rs
deleted file mode 100644
index 6385bfa160d..00000000000
--- a/tests/run-coverage/unreachable.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![feature(core_intrinsics)]
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021
-
-// <https://github.com/rust-lang/rust/issues/116171>
-// If we instrument a function for coverage, but all of its counter-increment
-// statements are removed by MIR optimizations, LLVM will think it isn't
-// instrumented and it will disappear from coverage maps and coverage reports.
-// Most MIR opts won't cause this because they tend not to remove statements
-// from bb0, but `UnreachablePropagation` can do so if it sees that bb0 ends
-// with `TerminatorKind::Unreachable`.
-
-use std::hint::{black_box, unreachable_unchecked};
-
-static UNREACHABLE_CLOSURE: fn() = || unsafe { unreachable_unchecked() };
-
-fn unreachable_function() {
-    unsafe { unreachable_unchecked() }
-}
-
-// Use an intrinsic to more reliably trigger unreachable-propagation.
-fn unreachable_intrinsic() {
-    unsafe { std::intrinsics::unreachable() }
-}
-
-#[coverage(off)]
-fn main() {
-    if black_box(false) {
-        UNREACHABLE_CLOSURE();
-    }
-    if black_box(false) {
-        unreachable_function();
-    }
-    if black_box(false) {
-        unreachable_intrinsic();
-    }
-}
diff --git a/tests/run-coverage/unused.rs b/tests/run-coverage/unused.rs
deleted file mode 100644
index d985af13547..00000000000
--- a/tests/run-coverage/unused.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(dead_code, unused_assignments, unused_must_use, unused_variables)]
-
-fn foo<T>(x: T) {
-    let mut i = 0;
-    while i < 10 {
-        i != 0 || i != 0;
-        i += 1;
-    }
-}
-
-fn unused_template_func<T>(x: T) {
-    let mut i = 0;
-    while i < 10 {
-        i != 0 || i != 0;
-        i += 1;
-    }
-}
-
-fn unused_func(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn unused_func2(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn unused_func3(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn main() -> Result<(), u8> {
-    foo::<u32>(0);
-    foo::<f32>(0.0);
-    Ok(())
-}
diff --git a/tests/run-coverage/while.rs b/tests/run-coverage/while.rs
deleted file mode 100644
index 781b90b3566..00000000000
--- a/tests/run-coverage/while.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    let num = 9;
-    while num >= 10 {
-    }
-}
diff --git a/tests/run-coverage/while_early_ret.rs b/tests/run-coverage/while_early_ret.rs
deleted file mode 100644
index b2f0eee2cc0..00000000000
--- a/tests/run-coverage/while_early_ret.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while
-        countdown
-            >
-        0
-    {
-        if
-            countdown
-                <
-            5
-        {
-            return
-                if
-                    countdown
-                        >
-                    8
-                {
-                    Ok(())
-                }
-                else
-                {
-                    Err(1)
-                }
-                ;
-        }
-        countdown
-            -=
-        1
-        ;
-    }
-    Ok(())
-}
-
-// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and
-// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux
-// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program
-// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical
-// to the coverage test for early returns, but this is a limitation that should be fixed.
diff --git a/tests/run-coverage/yield.rs b/tests/run-coverage/yield.rs
deleted file mode 100644
index b7e2ba31b59..00000000000
--- a/tests/run-coverage/yield.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![feature(coroutines, coroutine_trait)]
-#![allow(unused_assignments)]
-
-use std::ops::{Coroutine, CoroutineState};
-use std::pin::Pin;
-
-fn main() {
-    let mut coroutine = || {
-        yield 1;
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(1) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Complete("foo") => {}
-        _ => panic!("unexpected value from resume"),
-    }
-
-    let mut coroutine = || {
-        yield 1;
-        yield 2;
-        yield 3;
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(1) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(2) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-}