Implemented CoverageGraph of BasicCoverageBlocks

Author: richkadel

compiler/rustc_mir/src/transform/coverage/debug.rs

@@ -1,4 +1,4 @@
-use super::graph::BasicCoverageBlocks;
+use super::graph::CoverageGraph;
 use super::spans::CoverageSpan;
 
 use crate::util::pretty;
@@ -11,7 +11,7 @@ use rustc_middle::ty::TyCtxt;
 pub(crate) fn dump_coverage_spanview(
     tcx: TyCtxt<'tcx>,
     mir_body: &mir::Body<'tcx>,
-    basic_coverage_blocks: &BasicCoverageBlocks,
+    basic_coverage_blocks: &CoverageGraph,
     pass_name: &str,
     coverage_spans: &Vec<CoverageSpan>,
 ) {
@@ -28,20 +28,20 @@ pub(crate) fn dump_coverage_spanview(
         .expect("Unexpected IO error dumping coverage spans as HTML");
 }
 
-/// Converts the computed `BasicCoverageBlock`s into `SpanViewable`s.
+/// Converts the computed `BasicCoverageBlockData`s into `SpanViewable`s.
 fn span_viewables(
     tcx: TyCtxt<'tcx>,
     mir_body: &mir::Body<'tcx>,
-    basic_coverage_blocks: &BasicCoverageBlocks,
+    basic_coverage_blocks: &CoverageGraph,
     coverage_spans: &Vec<CoverageSpan>,
 ) -> Vec<SpanViewable> {
     let mut span_viewables = Vec::new();
     for coverage_span in coverage_spans {
         let tooltip = coverage_span.format_coverage_statements(tcx, mir_body);
-        let CoverageSpan { span, bcb_leader_bb: bb, .. } = coverage_span;
-        let bcb = &basic_coverage_blocks[*bb];
-        let id = bcb.id();
-        let leader_bb = bcb.leader_bb();
+        let CoverageSpan { span, bcb, .. } = coverage_span;
+        let bcb_data = &basic_coverage_blocks[*bcb];
+        let id = bcb_data.id();
+        let leader_bb = bcb_data.leader_bb();
         span_viewables.push(SpanViewable { bb: leader_bb, span: *span, id, tooltip });
     }
     span_viewables

compiler/rustc_mir/src/transform/coverage/graph.rs

@@ -6,13 +6,14 @@ mod graph;
 mod spans;
 
 use counters::CoverageCounters;
-use graph::BasicCoverageBlocks;
+use graph::CoverageGraph;
 use spans::{CoverageSpan, CoverageSpans};
 
 use crate::transform::MirPass;
 use crate::util::pretty;
 
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::graph::WithNumNodes;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::Lrc;
 use rustc_index::vec::IndexVec;
@@ -73,7 +74,7 @@ struct Instrumentor<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     mir_body: &'a mut mir::Body<'tcx>,
     body_span: Span,
-    basic_coverage_blocks: BasicCoverageBlocks,
+    basic_coverage_blocks: CoverageGraph,
     coverage_counters: CoverageCounters,
 }
 
@@ -82,7 +83,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         let hir_body = hir_body(tcx, mir_body.source.def_id());
         let body_span = hir_body.value.span;
         let function_source_hash = hash_mir_source(tcx, hir_body);
-        let basic_coverage_blocks = BasicCoverageBlocks::from_mir(mir_body);
+        let basic_coverage_blocks = CoverageGraph::from_mir(mir_body);
         Self {
             pass_name,
             tcx,
@@ -103,7 +104,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span));
 
         ////////////////////////////////////////////////////
-        // Compute `CoverageSpan`s from the `BasicCoverageBlocks`.
+        // Compute `CoverageSpan`s from the `CoverageGraph`.
         let coverage_spans = CoverageSpans::generate_coverage_spans(
             &self.mir_body,
             body_span,
@@ -135,9 +136,11 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         let source_file = source_map.lookup_source_file(body_span.lo());
         let file_name = Symbol::intern(&source_file.name.to_string());
 
-        let mut bb_counters = IndexVec::from_elem_n(None, self.mir_body.basic_blocks().len());
-        for CoverageSpan { span, bcb_leader_bb: bb, .. } in coverage_spans {
-            if let Some(&counter_operand) = bb_counters[bb].as_ref() {
+        let mut bcb_counters = IndexVec::from_elem_n(None, self.basic_coverage_blocks.num_nodes());
+        for covspan in coverage_spans {
+            let bcb = covspan.bcb;
+            let span = covspan.span;
+            if let Some(&counter_operand) = bcb_counters[bcb].as_ref() {
                 let expression = self.coverage_counters.make_expression(
                     counter_operand,
                     Op::Add,
@@ -149,6 +152,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                     span,
                     source_map.span_to_snippet(span).expect("Error getting source for span"),
                 );
+                let bb = self.basic_coverage_blocks[bcb].leader_bb();
                 let code_region = make_code_region(file_name, &source_file, span, body_span);
                 inject_statement(self.mir_body, expression, bb, Some(code_region));
             } else {
@@ -160,7 +164,8 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                     source_map.span_to_snippet(span).expect("Error getting source for span"),
                 );
                 let counter_operand = counter.as_operand_id();
-                bb_counters[bb] = Some(counter_operand);
+                bcb_counters[bcb] = Some(counter_operand);
+                let bb = self.basic_coverage_blocks[bcb].leader_bb();
                 let code_region = make_code_region(file_name, &source_file, span, body_span);
                 inject_statement(self.mir_body, counter, bb, Some(code_region));
             }

compiler/rustc_mir/src/transform/coverage/mod.rs

@@ -1,9 +1,8 @@
 use super::debug::term_type;
-use super::graph::{BasicCoverageBlock, BasicCoverageBlocks};
+use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph};
 
 use crate::util::spanview::source_range_no_file;
 
-use rustc_data_structures::graph::dominators::Dominators;
 use rustc_data_structures::graph::WithNumNodes;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::{
@@ -69,7 +68,7 @@ impl CoverageStatement {
 #[derive(Debug, Clone)]
 pub(crate) struct CoverageSpan {
     pub span: Span,
-    pub bcb_leader_bb: BasicBlock,
+    pub bcb: BasicCoverageBlock,
     pub coverage_statements: Vec<CoverageStatement>,
     pub is_closure: bool,
 }
@@ -78,7 +77,7 @@ impl CoverageSpan {
     pub fn for_statement(
         statement: &Statement<'tcx>,
         span: Span,
-        bcb: &BasicCoverageBlock,
+        bcb: BasicCoverageBlock,
         bb: BasicBlock,
         stmt_index: usize,
     ) -> Self {
@@ -92,16 +91,16 @@ impl CoverageSpan {
 
         Self {
             span,
-            bcb_leader_bb: bcb.leader_bb(),
+            bcb,
             coverage_statements: vec![CoverageStatement::Statement(bb, span, stmt_index)],
             is_closure,
         }
     }
 
-    pub fn for_terminator(span: Span, bcb: &BasicCoverageBlock, bb: BasicBlock) -> Self {
+    pub fn for_terminator(span: Span, bcb: BasicCoverageBlock, bb: BasicBlock) -> Self {
         Self {
             span,
-            bcb_leader_bb: bcb.leader_bb(),
+            bcb,
             coverage_statements: vec![CoverageStatement::Terminator(bb, span)],
             is_closure: false,
         }
@@ -132,7 +131,7 @@ impl CoverageSpan {
 
     #[inline]
     pub fn is_in_same_bcb(&self, other: &Self) -> bool {
-        self.bcb_leader_bb == other.bcb_leader_bb
+        self.bcb == other.bcb
     }
 
     pub fn format_coverage_statements(
@@ -164,15 +163,12 @@ pub struct CoverageSpans<'a, 'tcx> {
     /// The MIR, used to look up `BasicBlockData`.
     mir_body: &'a mir::Body<'tcx>,
 
-    /// A snapshot of the MIR CFG dominators before injecting any coverage statements.
-    dominators: Dominators<BasicBlock>,
-
     /// A `Span` covering the function body of the MIR (typically from left curly brace to right
     /// curly brace).
     body_span: Span,
 
     /// The BasicCoverageBlock Control Flow Graph (BCB CFG).
-    basic_coverage_blocks: &'a BasicCoverageBlocks,
+    basic_coverage_blocks: &'a CoverageGraph,
 
     /// The initial set of `CoverageSpan`s, sorted by `Span` (`lo` and `hi`) and by relative
     /// dominance between the `BasicCoverageBlock`s of equal `Span`s.
@@ -213,12 +209,10 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
     pub(crate) fn generate_coverage_spans(
         mir_body: &'a mir::Body<'tcx>,
         body_span: Span,
-        basic_coverage_blocks: &'a BasicCoverageBlocks,
+        basic_coverage_blocks: &'a CoverageGraph,
     ) -> Vec<CoverageSpan> {
-        let dominators = mir_body.dominators();
         let mut coverage_spans = CoverageSpans {
             mir_body,
-            dominators,
             body_span,
             basic_coverage_blocks,
             sorted_spans_iter: None,
@@ -246,7 +240,7 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
     /// The basic steps are:
     ///
     /// 1. Extract an initial set of spans from the `Statement`s and `Terminator`s of each
-    ///    `BasicCoverageBlock`.
+    ///    `BasicCoverageBlockData`.
     /// 2. Sort the spans by span.lo() (starting position). Spans that start at the same position
     ///    are sorted with longer spans before shorter spans; and equal spans are sorted
     ///    (deterministically) based on "dominator" relationship (if any).
@@ -263,8 +257,8 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
     /// to be).
     fn mir_to_initial_sorted_coverage_spans(&self) -> Vec<CoverageSpan> {
         let mut initial_spans = Vec::<CoverageSpan>::with_capacity(self.mir_body.num_nodes() * 2);
-        for bcb in self.basic_coverage_blocks.iter() {
-            for coverage_span in self.bcb_to_initial_coverage_spans(bcb) {
+        for (bcb, bcb_data) in self.basic_coverage_blocks.iter_enumerated() {
+            for coverage_span in self.bcb_to_initial_coverage_spans(bcb, bcb_data) {
                 initial_spans.push(coverage_span);
             }
         }
@@ -285,7 +279,7 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
                         // dominators always come after the dominated equal spans). When later
                         // comparing two spans in order, the first will either dominate the second,
                         // or they will have no dominator relationship.
-                        self.dominators.rank_partial_cmp(b.bcb_leader_bb, a.bcb_leader_bb)
+                        self.basic_coverage_blocks.dominators().rank_partial_cmp(b.bcb, a.bcb)
                     }
                 } else {
                     // Sort hi() in reverse order so shorter spans are attempted after longer spans.
@@ -357,13 +351,13 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
         let mut has_coverage = BitSet::new_empty(basic_coverage_blocks.num_nodes());
         for covspan in &refined_spans {
             if !covspan.span.is_empty() {
-                has_coverage.insert(covspan.bcb_leader_bb);
+                has_coverage.insert(covspan.bcb);
             }
         }
         refined_spans.retain(|covspan| {
             !(covspan.span.is_empty()
-                && is_goto(&mir_body[covspan.bcb_leader_bb].terminator().kind)
-                && has_coverage.contains(covspan.bcb_leader_bb))
+                && is_goto(&basic_coverage_blocks[covspan.bcb].terminator(mir_body).kind)
+                && has_coverage.contains(covspan.bcb))
         });
 
         // Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage
@@ -374,12 +368,17 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
     }
 
     // Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of
-    // the `BasicBlock`(s) in the given `BasicCoverageBlock`. One `CoverageSpan` is generated
+    // the `BasicBlock`(s) in the given `BasicCoverageBlockData`. One `CoverageSpan` is generated
     // for each `Statement` and `Terminator`. (Note that subsequent stages of coverage analysis will
     // merge some `CoverageSpan`s, at which point a `CoverageSpan` may represent multiple
     // `Statement`s and/or `Terminator`s.)
-    fn bcb_to_initial_coverage_spans(&self, bcb: &BasicCoverageBlock) -> Vec<CoverageSpan> {
-        bcb.blocks
+    fn bcb_to_initial_coverage_spans(
+        &self,
+        bcb: BasicCoverageBlock,
+        bcb_data: &'a BasicCoverageBlockData,
+    ) -> Vec<CoverageSpan> {
+        bcb_data
+            .basic_blocks
             .iter()
             .map(|bbref| {
                 let bb = *bbref;
@@ -636,7 +635,7 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
     }
 
     fn span_bcb_is_dominated_by(&self, covspan: &CoverageSpan, dom_covspan: &CoverageSpan) -> bool {
-        self.dominators.is_dominated_by(covspan.bcb_leader_bb, dom_covspan.bcb_leader_bb)
+        self.basic_coverage_blocks.is_dominated_by(covspan.bcb, dom_covspan.bcb)
     }
 }
 

compiler/rustc_mir/src/transform/coverage/spans.rs

@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 40,
-              "covered": 32,
-              "percent": 80
+              "covered": 30,
+              "percent": 75
             },
             "regions": {
-              "count": 39,
-              "covered": 28,
+              "count": 37,
+              "covered": 26,
               "notcovered": 11,
-              "percent": 71.7948717948718
+              "percent": 70.27027027027027
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 40,
-          "covered": 32,
-          "percent": 80
+          "covered": 30,
+          "percent": 75
         },
         "regions": {
-          "count": 39,
-          "covered": 28,
+          "count": 37,
+          "covered": 26,
           "notcovered": 11,
-          "percent": 71.7948717948718
+          "percent": 70.27027027027027
         }
       }
     }

src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json

@@ -21,10 +21,10 @@
               "percent": 100
             },
             "regions": {
-              "count": 10,
+              "count": 9,
               "covered": 8,
-              "notcovered": 2,
-              "percent": 80
+              "notcovered": 1,
+              "percent": 88.88888888888889
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 100
         },
         "regions": {
-          "count": 10,
+          "count": 9,
           "covered": 8,
-          "notcovered": 2,
-          "percent": 80
+          "notcovered": 1,
+          "percent": 88.88888888888889
         }
       }
     }

src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json

@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 21,
-              "covered": 17,
-              "percent": 80.95238095238095
+              "covered": 16,
+              "percent": 76.19047619047619
             },
             "regions": {
-              "count": 20,
-              "covered": 16,
+              "count": 18,
+              "covered": 14,
               "notcovered": 4,
-              "percent": 80
+              "percent": 77.77777777777779
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 21,
-          "covered": 17,
-          "percent": 80.95238095238095
+          "covered": 16,
+          "percent": 76.19047619047619
         },
         "regions": {
-          "count": 20,
-          "covered": 16,
+          "count": 18,
+          "covered": 14,
           "notcovered": 4,
-          "percent": 80
+          "percent": 77.77777777777779
         }
       }
     }