3 files changed, 15 insertions, 24 deletions
diff --git a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
index 24fb107b567..b0d7953f511 100644
--- a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
+++ b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
@@ -52,11 +52,8 @@ impl<'tcx> FunctionCoverage<'tcx> {
         }
     }
 
-    /// Although every function should have at least one `Counter`, the `Counter` isn't required to
-    /// have a `CodeRegion`. (The `CodeRegion` may be associated only with `Expressions`.) This
-    /// method supports the ability to ensure the `function_source_hash` is set from `Counters` that
-    /// do not trigger the call to `add_counter()` because they don't have an associated
-    /// `CodeRegion` to add.
+    /// Sets the function source hash value. If called multiple times for the same function, all
+    /// calls should have the same hash value.
     pub fn set_function_source_hash(&mut self, source_hash: u64) {
         if self.source_hash == 0 {
             self.source_hash = source_hash;
@@ -66,14 +63,7 @@ impl<'tcx> FunctionCoverage<'tcx> {
     }
 
     /// Adds a code region to be counted by an injected counter intrinsic.
-    /// The source_hash (computed during coverage instrumentation) should also be provided, and
-    /// should be the same for all counters in a given function.
-    pub fn add_counter(&mut self, source_hash: u64, id: CounterValueReference, region: CodeRegion) {
-        if self.source_hash == 0 {
-            self.source_hash = source_hash;
-        } else {
-            debug_assert_eq!(source_hash, self.source_hash);
-        }
+    pub fn add_counter(&mut self, id: CounterValueReference, region: CodeRegion) {
         self.counters[id].replace(region).expect_none("add_counter called with duplicate `id`");
     }
 
diff --git a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
index 339e0d95fdf..a115d358666 100644
--- a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
@@ -10,15 +10,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let Coverage { kind, code_region } = coverage;
         match kind {
             CoverageKind::Counter { function_source_hash, id } => {
-                let covmap_updated = if let Some(code_region) = code_region {
-                    // Note: Some counters do not have code regions, but may still be referenced from
-                    // expressions.
-                    bx.add_coverage_counter(self.instance, function_source_hash, id, code_region)
-                } else {
-                    bx.set_function_source_hash(self.instance, function_source_hash)
-                };
+                if bx.set_function_source_hash(self.instance, function_source_hash) {
+                    // If `set_function_source_hash()` returned true, the coverage map is enabled,
+                    // so continue adding the counter.
+                    if let Some(code_region) = code_region {
+                        // Note: Some counters do not have code regions, but may still be referenced
+                        // from expressions. In that case, don't add the counter to the coverage map,
+                        // but do inject the counter intrinsic.
+                        bx.add_coverage_counter(self.instance, id, code_region);
+                    }
 
-                if covmap_updated {
                     let coverageinfo = bx.tcx().coverageinfo(self.instance.def_id());
 
                     let fn_name = bx.create_pgo_func_name_var(self.instance);
diff --git a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
index 7da38880d60..95bddfb4b41 100644
--- a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
@@ -9,8 +9,9 @@ pub trait CoverageInfoMethods: BackendTypes {
 pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
     fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value;
 
-    /// Returns true if the function source hash was added to the coverage map; false if
-    /// `-Z instrument-coverage` is not enabled (a coverage map is not being generated).
+    /// Returns true if the function source hash was added to the coverage map (even if it had
+    /// already been added, for this instance). Returns false *only* if `-Z instrument-coverage` is
+    /// not enabled (a coverage map is not being generated).
     fn set_function_source_hash(
         &mut self,
         instance: Instance<'tcx>,
@@ -22,7 +23,6 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
     fn add_coverage_counter(
         &mut self,
         instance: Instance<'tcx>,
-        function_source_hash: u64,
         index: CounterValueReference,
         region: CodeRegion,
     ) -> bool;