coverage. Implement branch coverage in mcdc for pattern match

Author: zhuyunxing

compiler/rustc_middle/src/mir/coverage.rs

@@ -280,8 +280,7 @@ pub struct BranchInfo {
     /// data structures without having to scan the entire body first.
     pub num_block_markers: usize,
     pub branch_spans: Vec<BranchSpan>,
-    pub mcdc_branch_spans: Vec<MCDCBranchSpan>,
-    pub mcdc_decision_spans: Vec<MCDCDecisionSpan>,
+    pub mcdc_info: Option<MCDCBranchInfo>,
 }
 
 #[derive(Clone, Debug)]
@@ -321,6 +320,20 @@ pub struct MCDCBranchSpan {
     pub false_marker: BlockMarkerId,
 }
 
+#[derive(Clone, Debug)]
+#[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
+pub struct MCDCMatchArmSpan {
+    pub span: Span,
+    pub condition_info: Option<ConditionInfo>,
+    // Mark the blocks which test the pattern.
+    pub test_markers: Vec<BlockMarkerId>,
+    // The blocks switched into if this pattern was matched.
+    pub true_markers: Vec<BlockMarkerId>,
+    // The blocks of `true_markers` of the prior bindings.
+    // Eg. in `A | B` pattern A is prior to pattern B.
+    pub prior_binding_markers: Vec<BlockMarkerId>,
+}
+
 #[derive(Copy, Clone, Debug)]
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct DecisionInfo {
@@ -335,3 +348,20 @@ pub struct MCDCDecisionSpan {
     pub conditions_num: usize,
     pub end_markers: Vec<BlockMarkerId>,
 }
+
+/// Branch information recorded during THIR-to-MIR lowering, and stored in MIR.
+#[derive(Clone, Debug)]
+#[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
+pub struct MCDCBranchInfo {
+    pub branch_spans: Vec<MCDCBranchSpan>,
+    pub match_arm_spans: Vec<MCDCMatchArmSpan>,
+    pub decision_spans: Vec<MCDCDecisionSpan>,
+}
+
+impl MCDCBranchInfo {
+    pub fn calc_bitmap_bytes(&self) -> u32 {
+        self.decision_spans
+            .iter()
+            .fold(0, |acc, decision| acc + (1_u32 << decision.conditions_num).div_ceil(8))
+    }
+}

compiler/rustc_middle/src/mir/pretty.rs

@@ -475,35 +475,57 @@ fn write_coverage_branch_info(
     branch_info: &coverage::BranchInfo,
     w: &mut dyn io::Write,
 ) -> io::Result<()> {
-    let coverage::BranchInfo { branch_spans, mcdc_branch_spans, mcdc_decision_spans, .. } =
-        branch_info;
+    let coverage::BranchInfo { branch_spans, mcdc_info, .. } = branch_info;
 
+    let mut printed = false;
     for coverage::BranchSpan { span, true_marker, false_marker } in branch_spans {
         writeln!(
             w,
             "{INDENT}coverage branch {{ true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
         )?;
     }
 
-    for coverage::MCDCBranchSpan { span, condition_info, true_marker, false_marker } in
-        mcdc_branch_spans
+    printed |= !branch_spans.is_empty();
+
+    if let Some(coverage::MCDCBranchInfo { branch_spans, decision_spans, match_arm_spans }) =
+        mcdc_info.as_ref()
     {
-        writeln!(
-            w,
-            "{INDENT}coverage mcdc branch {{ condition_id: {:?}, true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
-            condition_info.map(|info| info.condition_id)
-        )?;
-    }
+        for coverage::MCDCBranchSpan { span, condition_info, true_marker, false_marker } in
+            branch_spans
+        {
+            writeln!(
+                w,
+                "{INDENT}coverage mcdc branch {{ condition_id: {:?}, true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
+                condition_info.map(|info| info.condition_id)
+            )?;
+        }
 
-    for coverage::MCDCDecisionSpan { span, conditions_num, end_markers } in mcdc_decision_spans {
-        writeln!(
-            w,
-            "{INDENT}coverage mcdc decision {{ conditions_num: {conditions_num:?}, end: {end_markers:?} }} => {span:?}"
-        )?;
+        for coverage::MCDCMatchArmSpan {
+            span,
+            condition_info,
+            test_markers,
+            true_markers,
+            prior_binding_markers,
+        } in match_arm_spans
+        {
+            writeln!(
+                w,
+                "{INDENT}coverage mcdc match arm {{ condition_id: {:?}, test: {test_markers:?}, true: {true_markers:?}, prior: {prior_binding_markers:?} }} => {span:?}",
+                condition_info.map(|info| info.condition_id)
+            )?;
+        }
+
+        for coverage::MCDCDecisionSpan { span, conditions_num, end_markers } in decision_spans {
+            writeln!(
+                w,
+                "{INDENT}coverage mcdc decision {{ conditions_num: {conditions_num:?}, end: {end_markers:?} }} => {span:?}"
+            )?;
+        }
+        printed |=
+            !branch_spans.is_empty() || !decision_spans.is_empty() || !match_arm_spans.is_empty();
     }
 
-    if !branch_spans.is_empty() || !mcdc_branch_spans.is_empty() || !mcdc_decision_spans.is_empty()
-    {
+    if printed {
         writeln!(w)?;
     }
 

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -1,11 +1,11 @@
 use std::assert_matches::assert_matches;
 use std::collections::hash_map::Entry;
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, VecDeque};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::mir::coverage::{
-    BlockMarkerId, BranchSpan, ConditionId, ConditionInfo, CoverageKind, MCDCBranchSpan,
-    MCDCDecisionSpan,
+    BlockMarkerId, BranchSpan, ConditionId, ConditionInfo, CoverageKind, MCDCBranchInfo,
+    MCDCBranchSpan, MCDCDecisionSpan, MCDCMatchArmSpan,
 };
 use rustc_middle::mir::{self, BasicBlock, SourceInfo, UnOp};
 use rustc_middle::thir::{ExprId, ExprKind, LogicalOp, Thir};
@@ -23,9 +23,7 @@ pub(crate) struct BranchInfoBuilder {
     num_block_markers: usize,
     branch_spans: Vec<BranchSpan>,
 
-    mcdc_branch_spans: Vec<MCDCBranchSpan>,
-    mcdc_decision_spans: Vec<MCDCDecisionSpan>,
-    mcdc_state: Option<MCDCState>,
+    mcdc_builder: Option<MCDCBuilder>,
 }
 
 #[derive(Clone, Copy)]
@@ -47,9 +45,7 @@ impl BranchInfoBuilder {
                 nots: FxHashMap::default(),
                 num_block_markers: 0,
                 branch_spans: vec![],
-                mcdc_branch_spans: vec![],
-                mcdc_decision_spans: vec![],
-                mcdc_state: MCDCState::new_if_enabled(tcx),
+                mcdc_builder: MCDCBuilder::new_if_enabled(tcx),
             })
         } else {
             None
@@ -102,21 +98,21 @@ impl BranchInfoBuilder {
         true_marker: BlockMarkerId,
         false_marker: BlockMarkerId,
     ) -> Option<ConditionInfo> {
-        let mcdc_state = self.mcdc_state.as_mut()?;
+        let mcdc_builder = self.mcdc_builder.as_mut()?;
         let (mut condition_info, decision_result) =
-            mcdc_state.take_condition(true_marker, false_marker);
+            mcdc_builder.take_condition(true_marker, false_marker);
         if let Some(decision) = decision_result {
             match decision.conditions_num {
                 0 => {
                     unreachable!("Decision with no condition is not expected");
                 }
                 1..=MAX_CONDITIONS_NUM_IN_DECISION => {
-                    self.mcdc_decision_spans.push(decision);
+                    mcdc_builder.decision_spans.push(decision);
                 }
                 _ => {
                     // Do not generate mcdc mappings and statements for decisions with too many conditions.
-                    let rebase_idx = self.mcdc_branch_spans.len() - decision.conditions_num + 1;
-                    for branch in &mut self.mcdc_branch_spans[rebase_idx..] {
+                    let rebase_idx = mcdc_builder.branch_spans.len() - decision.conditions_num + 1;
+                    for branch in &mut mcdc_builder.branch_spans[rebase_idx..] {
                         branch.condition_info = None;
                     }
 
@@ -171,14 +167,7 @@ impl BranchInfoBuilder {
     }
 
     pub(crate) fn into_done(self) -> Option<Box<mir::coverage::BranchInfo>> {
-        let Self {
-            nots: _,
-            num_block_markers,
-            branch_spans,
-            mcdc_branch_spans,
-            mcdc_decision_spans,
-            mcdc_state: _,
-        } = self;
+        let Self { nots: _, num_block_markers, branch_spans, mcdc_builder } = self;
 
         if num_block_markers == 0 {
             assert!(branch_spans.is_empty());
@@ -188,8 +177,7 @@ impl BranchInfoBuilder {
         Some(Box::new(mir::coverage::BranchInfo {
             num_block_markers,
             branch_spans,
-            mcdc_branch_spans,
-            mcdc_decision_spans,
+            mcdc_info: mcdc_builder.map(MCDCBuilder::into_done),
         }))
     }
 }
@@ -199,17 +187,25 @@ impl BranchInfoBuilder {
 /// This limit may be relaxed if the [upstream change](https://github.com/llvm/llvm-project/pull/82448) is merged.
 const MAX_CONDITIONS_NUM_IN_DECISION: usize = 6;
 
-struct MCDCState {
+struct MCDCBuilder {
     /// To construct condition evaluation tree.
     decision_stack: VecDeque<ConditionInfo>,
     processing_decision: Option<MCDCDecisionSpan>,
+
+    match_arm_records: BTreeMap<Span, MCDCMatchArmSpan>,
+    branch_spans: Vec<MCDCBranchSpan>,
+    decision_spans: Vec<MCDCDecisionSpan>,
 }
 
-impl MCDCState {
+impl MCDCBuilder {
     fn new_if_enabled(tcx: TyCtxt<'_>) -> Option<Self> {
-        tcx.sess
-            .instrument_coverage_mcdc()
-            .then(|| Self { decision_stack: VecDeque::new(), processing_decision: None })
+        tcx.sess.instrument_coverage_mcdc().then(|| Self {
+            decision_stack: VecDeque::new(),
+            processing_decision: None,
+            match_arm_records: BTreeMap::new(),
+            branch_spans: vec![],
+            decision_spans: vec![],
+        })
     }
 
     // At first we assign ConditionIds for each sub expression.
@@ -333,6 +329,23 @@ impl MCDCState {
             (Some(condition_info), None)
         }
     }
+
+    fn into_done(self) -> MCDCBranchInfo {
+        let Self { match_arm_records, branch_spans, decision_spans, .. } = self;
+
+        let mut match_arm_spans = match_arm_records.into_values().collect::<Vec<_>>();
+        match_arm_spans.sort_by(|a, b| {
+            if a.span.contains(b.span) { std::cmp::Ordering::Less } else { a.span.cmp(&b.span) }
+        });
+        for idx in 0..match_arm_spans.len().saturating_sub(1) {
+            if match_arm_spans[idx].span.contains(match_arm_spans[idx + 1].span) {
+                let refined_span = match_arm_spans[idx].span.until(match_arm_spans[idx + 1].span);
+                match_arm_spans[idx].span = refined_span;
+            }
+        }
+
+        MCDCBranchInfo { branch_spans, match_arm_spans, decision_spans }
+    }
 }
 
 impl Builder<'_, '_> {
@@ -359,19 +372,21 @@ impl Builder<'_, '_> {
         let source_info = SourceInfo { span: self.thir[expr_id].span, scope: self.source_scope };
 
         // Separate path for handling branches when MC/DC is enabled.
-        if branch_info.mcdc_state.is_some() {
+        if branch_info.mcdc_builder.is_some() {
             let mut inject_block_marker =
                 |block| branch_info.inject_block_marker(&mut self.cfg, source_info, block);
             let true_marker = inject_block_marker(then_block);
             let false_marker = inject_block_marker(else_block);
             let condition_info =
                 branch_info.fetch_mcdc_condition_info(self.tcx, true_marker, false_marker);
-            branch_info.mcdc_branch_spans.push(MCDCBranchSpan {
-                span: source_info.span,
-                condition_info,
-                true_marker,
-                false_marker,
-            });
+            branch_info.mcdc_builder.as_mut().expect("checked at condition").branch_spans.push(
+                MCDCBranchSpan {
+                    span: source_info.span,
+                    condition_info,
+                    true_marker,
+                    false_marker,
+                },
+            );
             return;
         }
 
@@ -380,9 +395,54 @@ impl Builder<'_, '_> {
 
     pub(crate) fn visit_coverage_branch_operation(&mut self, logical_op: LogicalOp, span: Span) {
         if let Some(branch_info) = self.coverage_branch_info.as_mut()
-            && let Some(mcdc_state) = branch_info.mcdc_state.as_mut()
+            && let Some(mcdc_state) = branch_info.mcdc_builder.as_mut()
         {
             mcdc_state.record_conditions(logical_op, span);
         }
     }
+
+    pub(crate) fn visit_coverage_mcdc_match_arms(
+        &mut self,
+        (test_span, test_block): (Span, BasicBlock),
+        targets: impl Iterator<Item = (Span, BasicBlock)>,
+    ) {
+        let Some(branch_info) = self.coverage_branch_info.as_mut() else { return };
+        // Only enabled in mcdc
+        if branch_info.mcdc_builder.is_none() {
+            return;
+        }
+
+        // May inject redundant block markers, it's ok because we will transform them into basic coverage block in coverage pass.
+        let mut gen_marker_id = |span, block| {
+            branch_info.inject_block_marker(
+                &mut self.cfg,
+                SourceInfo { span, scope: self.source_scope },
+                block,
+            )
+        };
+
+        let test_block_id = gen_marker_id(test_span, test_block);
+
+        let mut targets =
+            targets.map(|(span, block)| (span, gen_marker_id(span, block))).collect::<Vec<_>>();
+
+        let branch_records =
+            &mut branch_info.mcdc_builder.as_mut().expect("checked at entry").match_arm_records;
+
+        while let Some((span, matched_block)) = targets.pop() {
+            // By here we do not know the span of the target yet, so just record the
+            // basic blocks and insert BlockMarkerId later.
+            let record = branch_records.entry(span).or_insert_with(|| MCDCMatchArmSpan {
+                span,
+                condition_info: None,
+                test_markers: vec![],
+                true_markers: vec![],
+                prior_binding_markers: vec![],
+            });
+            record.test_markers.push(test_block_id);
+            record.true_markers.push(matched_block);
+
+            record.prior_binding_markers.extend(targets.iter().map(|(_, blk)| *blk));
+        }
+    }
 }