Tools and tests to experimentally add more counters per function

Adds a new mir_dump output file in HTML/CSS to visualize code regions
and the MIR features that they came from (including overlapping spans).

Adds `--bless` support to `test/run-make-fulldeps` so expected coverage
output can be quickly regenerated.

Adds a new `-Zexperimental-coverage` option that implies
`-Zinstrument-coverage`, but can be used to enable experimental coverage
counter injection.

Includes a basic, MIR-block-based implementation of coverage injection,
available via `-Zexperimental-coverage`. This implementation has known
flaws and omissions, but is simple enough to validate the new tools and
tests.

The existing `-Zinstrument-coverage` option currently enables
function-level coverage only, which at least appears to generate
accurate coverage reports at that level.

Experimental coverage is not accurate at this time. When branch coverage works as
intended, the `-Zexperimental-coverage` option should be removed.

Also, learned that `-C link-dead-code` (which was enabled automatically
under `-Z instrument-coverage`) was causing the linking error that
resulted in segmentation faults in coverage instrumented binaries. Link
dead code is now disabled under MSVC, allowing `-Zinstrument-coverage`
to be enabled under MSVC for the first time.

Rust compiler MCP rust-lang/compiler-team#278

Relevant issue: #34701 - Implement support for LLVMs code coverage
instrumentation

library/profiler_builtins/build.rs

@@ -20,6 +20,7 @@ fn main() {
         "InstrProfilingMergeFile.c",
         "InstrProfilingNameVar.c",
         "InstrProfilingPlatformDarwin.c",
+        "InstrProfilingPlatformFuchsia.c",
         "InstrProfilingPlatformLinux.c",
         "InstrProfilingPlatformOther.c",
         "InstrProfilingPlatformWindows.c",

src/librustc_codegen_ssa/back/link.rs

@@ -1668,7 +1668,7 @@ fn linker_with_args<'a, B: ArchiveBuilder<'a>>(
     // FIXME: Order dependent, applies to the following objects. Where should it be placed?
     // Try to strip as much out of the generated object by removing unused
     // sections if possible. See more comments in linker.rs
-    if sess.opts.cg.link_dead_code != Some(true) {
+    if !sess.link_dead_code() {
         let keep_metadata = crate_type == CrateType::Dylib;
         cmd.gc_sections(keep_metadata);
     }

src/librustc_middle/mir/mod.rs

@@ -1521,7 +1521,24 @@ impl Debug for Statement<'_> {
             AscribeUserType(box (ref place, ref c_ty), ref variance) => {
                 write!(fmt, "AscribeUserType({:?}, {:?}, {:?})", place, variance, c_ty)
             }
-            Coverage(box ref coverage) => write!(fmt, "{:?}", coverage),
+            Coverage(box ref coverage) => {
+                let rgn = &coverage.code_region;
+                match coverage.kind {
+                    CoverageKind::Counter { id, .. } => {
+                        write!(fmt, "Coverage counter({:?}) for {:?}", id.index(), rgn)
+                    }
+                    CoverageKind::Expression { id, lhs, op, rhs } => write!(
+                        fmt,
+                        "Coverage expr({:?}) = {} {} {} for {:?}",
+                        id.index(),
+                        lhs.index(),
+                        if op == coverage::Op::Add { "+" } else { "-" },
+                        rhs.index(),
+                        rgn
+                    ),
+                    CoverageKind::Unreachable => write!(fmt, "Coverage unreachable for {:?}", rgn),
+                }
+            }
             Nop => write!(fmt, "nop"),
         }
     }

src/librustc_middle/mir/mono.rs

@@ -86,7 +86,7 @@ impl<'tcx> MonoItem<'tcx> {
             .debugging_opts
             .inline_in_all_cgus
             .unwrap_or_else(|| tcx.sess.opts.optimize != OptLevel::No)
-            && tcx.sess.opts.cg.link_dead_code != Some(true);
+            && !tcx.sess.link_dead_code();
 
         match *self {
             MonoItem::Fn(ref instance) => {

src/librustc_mir/monomorphize/partitioning/mod.rs

@@ -190,7 +190,7 @@ pub fn partition<'tcx>(
 
     // Next we try to make as many symbols "internal" as possible, so LLVM has
     // more freedom to optimize.
-    if tcx.sess.opts.cg.link_dead_code != Some(true) {
+    if !tcx.sess.link_dead_code() {
         let _prof_timer = tcx.prof.generic_activity("cgu_partitioning_internalize_symbols");
         partitioner.internalize_symbols(tcx, &mut post_inlining, inlining_map);
     }
@@ -327,7 +327,7 @@ fn collect_and_partition_mono_items<'tcx>(
             }
         }
         None => {
-            if tcx.sess.opts.cg.link_dead_code == Some(true) {
+            if tcx.sess.link_dead_code() {
                 MonoItemCollectionMode::Eager
             } else {
                 MonoItemCollectionMode::Lazy