coverage: Store each BCB's code regions in one coverage statement

If a BCB has more than one code region, those extra regions can now all be
stored in the same coverage statement, instead of being stored in additional
statements.

Author: Zalathar

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -215,19 +215,16 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         }
     }
 
-    /// Inject a counter for each coverage span. There can be multiple coverage spans for a given
-    /// BCB, but only one actual counter needs to be incremented per BCB. `bcb_counters` maps each
-    /// `bcb` to its `Counter`, when injected. Subsequent coverage spans for a BCB that already has
-    /// a `Counter` will inject an `Expression` instead, and compute its value by adding `ZERO` to
-    /// the BCB `Counter` value.
+    /// Injects a single [`StatementKind::Coverage`] for each BCB that has one
+    /// or more coverage spans.
     fn inject_coverage_span_counters(&mut self, coverage_spans: &CoverageSpans) {
         let tcx = self.tcx;
         let source_map = tcx.sess.source_map();
         let body_span = self.body_span;
         let file_name = Symbol::intern(&self.source_file.name.prefer_remapped().to_string_lossy());
 
         let mut bcb_counters = IndexVec::from_elem_n(None, self.basic_coverage_blocks.num_nodes());
-        for (bcb, span) in coverage_spans.bcb_span_pairs() {
+        for (bcb, spans) in coverage_spans.bcbs_with_coverage_spans() {
             let counter_kind = if let Some(&counter_operand) = bcb_counters[bcb].as_ref() {
                 self.coverage_counters.make_identity_counter(counter_operand)
             } else if let Some(counter_kind) = self.coverage_counters.take_bcb_counter(bcb) {
@@ -237,20 +234,24 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                 bug!("Every BasicCoverageBlock should have a Counter or Expression");
             };
 
-            let code_region = make_code_region(source_map, file_name, span, body_span);
+            // Convert the coverage spans into a vector of code regions to be
+            // associated with this BCB's coverage statement.
+            let code_regions = spans
+                .iter()
+                .map(|&span| make_code_region(source_map, file_name, span, body_span))
+                .collect::<Vec<_>>();
 
             inject_statement(
                 self.mir_body,
                 self.make_mir_coverage_kind(&counter_kind),
                 self.bcb_leader_bb(bcb),
-                vec![code_region],
+                code_regions,
             );
         }
     }
 
-    /// `inject_coverage_span_counters()` looped through the coverage spans and injected the
-    /// counter from the coverage span's `BasicCoverageBlock`, removing it from the BCB in the
-    /// process (via `take_counter()`).
+    /// At this point, any BCB with coverage counters has already had its counter injected
+    /// into MIR, and had its counter removed from `coverage_counters` (via `take_counter()`).
     ///
     /// Any other counter associated with a `BasicCoverageBlock`, or its incoming edge, but not
     /// associated with a coverage span, should only exist if the counter is an `Expression`

compiler/rustc_mir_transform/src/coverage/spans.rs

@@ -1,7 +1,7 @@
 use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph, START_BCB};
 
 use rustc_data_structures::graph::WithNumNodes;
-use rustc_index::bit_set::BitSet;
+use rustc_index::IndexVec;
 use rustc_middle::mir::{
     self, AggregateKind, BasicBlock, FakeReadCause, Rvalue, Statement, StatementKind, Terminator,
     TerminatorKind,
@@ -12,8 +12,8 @@ use rustc_span::{BytePos, ExpnKind, MacroKind, Span, Symbol};
 use std::cell::OnceCell;
 
 pub(super) struct CoverageSpans {
-    coverage_spans: Vec<CoverageSpan>,
-    bcbs_with_coverage_spans: BitSet<BasicCoverageBlock>,
+    /// Map from BCBs to their list of coverage spans.
+    bcb_to_spans: IndexVec<BasicCoverageBlock, Vec<Span>>,
 }
 
 impl CoverageSpans {
@@ -30,20 +30,26 @@ impl CoverageSpans {
             basic_coverage_blocks,
         );
 
-        let mut bcbs_with_coverage_spans = BitSet::new_empty(basic_coverage_blocks.num_nodes());
-        for coverage_span in &coverage_spans {
-            bcbs_with_coverage_spans.insert(coverage_span.bcb);
+        // Group the coverage spans by BCB, with the BCBs in sorted order.
+        let mut bcb_to_spans = IndexVec::from_elem_n(Vec::new(), basic_coverage_blocks.num_nodes());
+        for CoverageSpan { bcb, span, .. } in coverage_spans {
+            bcb_to_spans[bcb].push(span);
         }
 
-        Self { coverage_spans, bcbs_with_coverage_spans }
+        Self { bcb_to_spans }
     }
 
     pub(super) fn bcb_has_coverage_spans(&self, bcb: BasicCoverageBlock) -> bool {
-        self.bcbs_with_coverage_spans.contains(bcb)
+        !self.bcb_to_spans[bcb].is_empty()
     }
 
-    pub(super) fn bcb_span_pairs(&self) -> impl Iterator<Item = (BasicCoverageBlock, Span)> + '_ {
-        self.coverage_spans.iter().map(|&CoverageSpan { bcb, span, .. }| (bcb, span))
+    pub(super) fn bcbs_with_coverage_spans(
+        &self,
+    ) -> impl Iterator<Item = (BasicCoverageBlock, &[Span])> {
+        self.bcb_to_spans.iter_enumerated().filter_map(|(bcb, spans)| {
+            // Only yield BCBs that have at least one coverage span.
+            (!spans.is_empty()).then_some((bcb, spans.as_slice()))
+        })
     }
 }
 

tests/coverage-map/status-quo/async.cov-map

@@ -54,26 +54,24 @@ Number of file 0 mappings: 1
 - Code(Zero) at (prev + 15, 20) to (start + 0, 25)
 
 Function name: async::executor::block_on::<core::pin::Pin<&mut async::i::{closure#0}>>
-Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 6e, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
+Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 6e, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 5
+Number of expressions: 3
 - expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
-- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
 Number of file 0 mappings: 6
 - Code(Counter(0)) at (prev + 110, 5) to (start + 10, 54)
 - Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
     = ((c0 + c1) - c1)
 - Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
     = (c0 + c1)
-- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
+    = ((c0 + c1) - c1)
 - Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
-- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
+    = ((c0 + c1) - c1)
 
 Function name: async::executor::block_on::VTABLE::{closure#0}
 Raw bytes (9): 0x[01, 01, 00, 01, 01, 72, 11, 00, 33]
@@ -199,58 +197,46 @@ Number of file 0 mappings: 1
 - Code(Counter(0)) at (prev + 38, 1) to (start + 0, 19)
 
 Function name: async::i::{closure#0}
-Raw bytes (84): 0x[01, 01, 05, 01, 00, 0d, 00, 1d, 00, 19, 13, 1d, 21, 0e, 01, 26, 13, 04, 0c, 0d, 05, 09, 00, 0a, 03, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 07, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 0b, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 0f, 02, 01, 00, 02]
+Raw bytes (78): 0x[01, 01, 02, 19, 07, 1d, 21, 0e, 01, 26, 13, 04, 0c, 0d, 05, 09, 00, 0a, 01, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 0d, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 1d, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 5
-- expression 0 operands: lhs = Counter(0), rhs = Zero
-- expression 1 operands: lhs = Counter(3), rhs = Zero
-- expression 2 operands: lhs = Counter(7), rhs = Zero
-- expression 3 operands: lhs = Counter(6), rhs = Expression(4, Add)
-- expression 4 operands: lhs = Counter(7), rhs = Counter(8)
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(6), rhs = Expression(1, Add)
+- expression 1 operands: lhs = Counter(7), rhs = Counter(8)
 Number of file 0 mappings: 14
 - Code(Counter(0)) at (prev + 38, 19) to (start + 4, 12)
 - Code(Counter(3)) at (prev + 5, 9) to (start + 0, 10)
-- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 18)
-    = (c0 + Zero)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18)
 - Code(Counter(1)) at (prev + 0, 19) to (start + 0, 24)
 - Code(Counter(2)) at (prev + 0, 28) to (start + 0, 33)
-- Code(Expression(1, Add)) at (prev + 0, 39) to (start + 0, 42)
-    = (c3 + Zero)
+- Code(Counter(3)) at (prev + 0, 39) to (start + 0, 42)
 - Code(Counter(5)) at (prev + 0, 43) to (start + 0, 48)
 - Code(Counter(7)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(4)) at (prev + 0, 14) to (start + 0, 17)
 - Code(Counter(9)) at (prev + 0, 18) to (start + 0, 23)
 - Code(Counter(10)) at (prev + 0, 27) to (start + 0, 32)
-- Code(Expression(2, Add)) at (prev + 0, 36) to (start + 0, 38)
-    = (c7 + Zero)
+- Code(Counter(7)) at (prev + 0, 36) to (start + 0, 38)
 - Code(Counter(8)) at (prev + 1, 14) to (start + 0, 16)
-- Code(Expression(3, Add)) at (prev + 2, 1) to (start + 0, 2)
+- Code(Expression(0, Add)) at (prev + 2, 1) to (start + 0, 2)
     = (c6 + (c7 + c8))
 
 Function name: async::j
-Raw bytes (59): 0x[01, 01, 05, 01, 00, 05, 00, 09, 00, 05, 13, 09, 0d, 09, 01, 31, 01, 13, 0c, 05, 14, 09, 00, 0a, 03, 00, 0e, 00, 1b, 07, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 0b, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 0f, 02, 01, 00, 02]
+Raw bytes (53): 0x[01, 01, 02, 05, 07, 09, 0d, 09, 01, 31, 01, 13, 0c, 05, 14, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 5
-- expression 0 operands: lhs = Counter(0), rhs = Zero
-- expression 1 operands: lhs = Counter(1), rhs = Zero
-- expression 2 operands: lhs = Counter(2), rhs = Zero
-- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add)
-- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
+- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 9
 - Code(Counter(0)) at (prev + 49, 1) to (start + 19, 12)
 - Code(Counter(1)) at (prev + 20, 9) to (start + 0, 10)
-- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 27)
-    = (c0 + Zero)
-- Code(Expression(1, Add)) at (prev + 0, 31) to (start + 0, 39)
-    = (c1 + Zero)
+- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 27)
+- Code(Counter(1)) at (prev + 0, 31) to (start + 0, 39)
 - Code(Counter(2)) at (prev + 1, 9) to (start + 0, 10)
 - Code(Counter(4)) at (prev + 0, 14) to (start + 0, 26)
-- Code(Expression(2, Add)) at (prev + 0, 30) to (start + 0, 32)
-    = (c2 + Zero)
+- Code(Counter(2)) at (prev + 0, 30) to (start + 0, 32)
 - Code(Counter(3)) at (prev + 1, 14) to (start + 0, 16)
-- Code(Expression(3, Add)) at (prev + 2, 1) to (start + 0, 2)
+- Code(Expression(0, Add)) at (prev + 2, 1) to (start + 0, 2)
     = (c1 + (c2 + c3))
 
 Function name: async::j::c

tests/coverage-map/status-quo/async2.cov-map

@@ -38,48 +38,44 @@ Number of file 0 mappings: 1
 - Code(Counter(0)) at (prev + 19, 36) to (start + 2, 2)
 
 Function name: async2::executor::block_on::<async2::async_func::{closure#0}>
-Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
+Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 5
+Number of expressions: 3
 - expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
-- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
 Number of file 0 mappings: 6
 - Code(Counter(0)) at (prev + 39, 5) to (start + 10, 54)
 - Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
     = ((c0 + c1) - c1)
 - Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
     = (c0 + c1)
-- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
+    = ((c0 + c1) - c1)
 - Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
-- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
+    = ((c0 + c1) - c1)
 
 Function name: async2::executor::block_on::<async2::async_func_just_println::{closure#0}>
-Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
+Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 5
+Number of expressions: 3
 - expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 2 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
-- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
 Number of file 0 mappings: 6
 - Code(Counter(0)) at (prev + 39, 5) to (start + 10, 54)
 - Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
     = ((c0 + c1) - c1)
 - Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
     = (c0 + c1)
-- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
+    = ((c0 + c1) - c1)
 - Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
-- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
-    = (((c0 + c1) - c1) + Zero)
+- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
+    = ((c0 + c1) - c1)
 
 Function name: async2::executor::block_on::VTABLE::{closure#0}
 Raw bytes (9): 0x[01, 01, 00, 01, 01, 2b, 11, 00, 33]