coverage. Introduce MCDCBranchMarker to trace branch blocks of conditions

Author: zhuyunxing

compiler/rustc_middle/src/mir/coverage.rs

@@ -291,8 +291,8 @@ 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_degraded_spans: Vec<MCDCBranchSpan>,
+    pub mcdc_spans: Vec<(MCDCDecisionSpan, Vec<MCDCBranchSpan>)>,
 }
 
 #[derive(Clone, Debug)]
@@ -325,12 +325,16 @@ impl Default for ConditionInfo {
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct MCDCBranchSpan {
     pub span: Span,
-    /// If `None`, this actually represents a normal branch span inserted for
-    /// code that was too complex for MC/DC.
-    pub condition_info: Option<ConditionInfo>,
-    pub true_marker: BlockMarkerId,
-    pub false_marker: BlockMarkerId,
-    pub decision_depth: u16,
+    pub condition_info: ConditionInfo,
+    pub markers: MCDCBranchMarkers,
+}
+
+#[derive(Clone, Debug)]
+#[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
+pub enum MCDCBranchMarkers {
+    /// The first indicates true branch, the second indicates the false branch.
+    Boolean(BlockMarkerId, BlockMarkerId),
+    PatternMatching,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -344,7 +348,6 @@ pub struct DecisionInfo {
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct MCDCDecisionSpan {
     pub span: Span,
-    pub num_conditions: usize,
     pub end_markers: Vec<BlockMarkerId>,
     pub decision_depth: u16,
 }

compiler/rustc_middle/src/mir/pretty.rs

@@ -487,8 +487,7 @@ 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_degraded_spans, mcdc_spans, .. } = branch_info;
 
     for coverage::BranchSpan { span, true_marker, false_marker } in branch_spans {
         writeln!(
@@ -497,32 +496,30 @@ fn write_coverage_branch_info(
         )?;
     }
 
-    for coverage::MCDCBranchSpan {
-        span,
-        condition_info,
-        true_marker,
-        false_marker,
-        decision_depth,
-    } in mcdc_branch_spans
-    {
+    for coverage::MCDCBranchSpan { span, markers, .. } in mcdc_degraded_spans {
         writeln!(
             w,
-            "{INDENT}coverage mcdc branch {{ condition_id: {:?}, true: {true_marker:?}, false: {false_marker:?}, depth: {decision_depth:?} }} => {span:?}",
-            condition_info.map(|info| info.condition_id)
+            "{INDENT}coverage mcdc degraded branch {{ markers: {markers:?} }} => {span:?}",
         )?;
     }
 
-    for coverage::MCDCDecisionSpan { span, num_conditions, end_markers, decision_depth } in
-        mcdc_decision_spans
+    for (coverage::MCDCDecisionSpan { span, end_markers, decision_depth }, conditions) in mcdc_spans
     {
+        let num_conditions = conditions.len();
         writeln!(
             w,
             "{INDENT}coverage mcdc decision {{ num_conditions: {num_conditions:?}, end: {end_markers:?}, depth: {decision_depth:?} }} => {span:?}"
         )?;
+        for coverage::MCDCBranchSpan { span, condition_info, markers } in conditions {
+            writeln!(
+                w,
+                "{INDENT}coverage mcdc branch {{ condition_id: {:?}, markers: {markers:?} }} => {span:?}",
+                condition_info.condition_id
+            )?;
+        }
     }
 
-    if !branch_spans.is_empty() || !mcdc_branch_spans.is_empty() || !mcdc_decision_spans.is_empty()
-    {
+    if !branch_spans.is_empty() || !mcdc_degraded_spans.is_empty() || !mcdc_spans.is_empty() {
         writeln!(w)?;
     }
 

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -162,18 +162,13 @@ impl BranchInfoBuilder {
             return None;
         }
 
-        let (mut mcdc_branch_spans, mcdc_spans) =
+        let (mcdc_degraded_spans, mcdc_spans) =
             mcdc_info.map(MCDCInfoBuilder::into_done).unwrap_or_default();
-        let mut mcdc_decision_spans = Vec::with_capacity(mcdc_spans.len());
-        for (decision, conditions) in mcdc_spans {
-            mcdc_branch_spans.extend(conditions);
-            mcdc_decision_spans.push(decision);
-        }
         Some(Box::new(mir::coverage::BranchInfo {
             num_block_markers,
             branch_spans,
-            mcdc_branch_spans,
-            mcdc_decision_spans,
+            mcdc_degraded_spans,
+            mcdc_spans,
         }))
     }
 }

compiler/rustc_mir_build/src/build/coverageinfo/mcdc.rs

@@ -3,7 +3,8 @@ use std::collections::VecDeque;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_middle::bug;
 use rustc_middle::mir::coverage::{
-    BlockMarkerId, ConditionId, ConditionInfo, DecisionId, MCDCBranchSpan, MCDCDecisionSpan,
+    BlockMarkerId, ConditionId, ConditionInfo, DecisionId, MCDCBranchMarkers, MCDCBranchSpan,
+    MCDCDecisionSpan,
 };
 use rustc_middle::mir::BasicBlock;
 use rustc_middle::thir::LogicalOp;
@@ -29,6 +30,7 @@ struct BooleanDecisionCtx {
     /// To construct condition evaluation tree.
     decision_stack: VecDeque<ConditionInfo>,
     conditions: Vec<MCDCBranchSpan>,
+    condition_id_counter: usize,
 }
 
 impl BooleanDecisionCtx {
@@ -37,15 +39,20 @@ impl BooleanDecisionCtx {
             id,
             decision_info: MCDCDecisionSpan {
                 span: Span::default(),
-                num_conditions: 0,
                 end_markers: vec![],
                 decision_depth: 0,
             },
             decision_stack: VecDeque::new(),
             conditions: vec![],
+            condition_id_counter: 0,
         }
     }
 
+    fn next_condition_id(&mut self) -> ConditionId {
+        self.condition_id_counter += 1;
+        ConditionId::from_usize(self.condition_id_counter)
+    }
+
     // At first we assign ConditionIds for each sub expression.
     // If the sub expression is composite, re-assign its ConditionId to its LHS and generate a new ConditionId for its RHS.
     //
@@ -89,14 +96,12 @@ impl BooleanDecisionCtx {
     fn record_conditions(&mut self, op: LogicalOp) {
         let parent_condition = self.decision_stack.pop_back().unwrap_or_default();
         let lhs_id = if parent_condition.condition_id == ConditionId::NONE {
-            self.decision_info.num_conditions += 1;
-            ConditionId::from(self.decision_info.num_conditions)
+            ConditionId::from(self.next_condition_id())
         } else {
             parent_condition.condition_id
         };
 
-        self.decision_info.num_conditions += 1;
-        let rhs_condition_id = ConditionId::from(self.decision_info.num_conditions);
+        let rhs_condition_id = self.next_condition_id();
 
         let (lhs, rhs) = match op {
             LogicalOp::And => {
@@ -147,13 +152,9 @@ impl BooleanDecisionCtx {
 
         self.conditions.push(MCDCBranchSpan {
             span,
-            condition_info: Some(condition_info),
-            true_marker,
-            false_marker,
-            decision_depth: 0,
+            condition_info,
+            markers: MCDCBranchMarkers::Boolean(true_marker, false_marker),
         });
-        // In case this decision had only one condition
-        self.decision_info.num_conditions = self.decision_info.num_conditions.max(1);
     }
 
     fn is_finished(&self) -> bool {
@@ -250,7 +251,6 @@ struct MCDCTargetInfo {
 impl MCDCTargetInfo {
     fn set_depth(&mut self, depth: u16) {
         self.decision.decision_depth = depth;
-        self.conditions.iter_mut().for_each(|branch| branch.decision_depth = depth);
     }
 }
 
@@ -298,7 +298,9 @@ impl MCDCInfoBuilder {
     }
 
     fn append_normal_branches(&mut self, mut branches: Vec<MCDCBranchSpan>) {
-        branches.iter_mut().for_each(|branch| branch.condition_info = None);
+        branches
+            .iter_mut()
+            .for_each(|branch| branch.condition_info.condition_id = ConditionId::NONE);
         self.normal_branch_spans.extend(branches);
     }
 

compiler/rustc_mir_transform/src/coverage/counters.rs

@@ -101,7 +101,12 @@ impl CoverageCounters {
         BcbCounter::Counter { id }
     }
 
-    fn make_expression(&mut self, lhs: BcbCounter, op: Op, rhs: BcbCounter) -> BcbCounter {
+    pub(super) fn make_expression(
+        &mut self,
+        lhs: BcbCounter,
+        op: Op,
+        rhs: BcbCounter,
+    ) -> BcbCounter {
         let new_expr = BcbExpression { lhs, op, rhs };
         *self
             .expressions_memo
@@ -159,7 +164,11 @@ impl CoverageCounters {
     /// Variant of `make_expression` that makes `lhs` optional and assumes [`Op::Add`].
     ///
     /// This is useful when using [`Iterator::fold`] to build an arbitrary-length sum.
-    fn make_sum_expression(&mut self, lhs: Option<BcbCounter>, rhs: BcbCounter) -> BcbCounter {
+    pub(super) fn make_sum_expression(
+        &mut self,
+        lhs: Option<BcbCounter>,
+        rhs: BcbCounter,
+    ) -> BcbCounter {
         let Some(lhs) = lhs else { return rhs };
         self.make_expression(lhs, Op::Add, rhs)
     }

compiler/rustc_mir_transform/src/coverage/mappings.rs

@@ -3,7 +3,9 @@ use std::collections::BTreeSet;
 use rustc_data_structures::graph::DirectedGraph;
 use rustc_index::bit_set::BitSet;
 use rustc_index::IndexVec;
-use rustc_middle::mir::coverage::{BlockMarkerId, BranchSpan, ConditionInfo, CoverageKind};
+use rustc_middle::mir::coverage::{
+    BlockMarkerId, BranchSpan, ConditionInfo, CoverageKind, MCDCBranchMarkers,
+};
 use rustc_middle::mir::{self, BasicBlock, StatementKind};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
@@ -35,12 +37,15 @@ pub(super) struct BranchPair {
 #[derive(Debug)]
 pub(super) struct MCDCBranch {
     pub(super) span: Span,
-    pub(super) true_bcb: BasicCoverageBlock,
-    pub(super) false_bcb: BasicCoverageBlock,
-    /// If `None`, this actually represents a normal branch mapping inserted
-    /// for code that was too complex for MC/DC.
-    pub(super) condition_info: Option<ConditionInfo>,
-    pub(super) decision_depth: u16,
+    pub(super) branch_bcbs: MCDCBranchBlocks,
+    pub(super) condition_info: ConditionInfo,
+}
+
+#[derive(Debug)]
+pub(super) enum MCDCBranchBlocks {
+    Boolean(BasicCoverageBlock, BasicCoverageBlock),
+    #[allow(dead_code)]
+    PatternMatching,
 }
 
 /// Associates an MC/DC decision with its join BCBs.
@@ -49,7 +54,6 @@ pub(super) struct MCDCDecision {
     pub(super) span: Span,
     pub(super) end_bcbs: BTreeSet<BasicCoverageBlock>,
     pub(super) bitmap_idx: u32,
-    pub(super) num_conditions: u16,
     pub(super) decision_depth: u16,
 }
 
@@ -58,8 +62,8 @@ pub(super) struct ExtractedMappings {
     pub(super) code_mappings: Vec<CodeMapping>,
     pub(super) branch_pairs: Vec<BranchPair>,
     pub(super) mcdc_bitmap_bytes: u32,
-    pub(super) mcdc_branches: Vec<MCDCBranch>,
-    pub(super) mcdc_decisions: Vec<MCDCDecision>,
+    pub(super) mcdc_degraded_branches: Vec<MCDCBranch>,
+    pub(super) mcdc_mappings: Vec<(MCDCDecision, Vec<MCDCBranch>)>,
 }
 
 /// Extracts coverage-relevant spans from MIR, and associates them with
@@ -72,9 +76,8 @@ pub(super) fn extract_all_mapping_info_from_mir<'tcx>(
 ) -> ExtractedMappings {
     let mut code_mappings = vec![];
     let mut branch_pairs = vec![];
-    let mut mcdc_bitmap_bytes = 0;
-    let mut mcdc_branches = vec![];
-    let mut mcdc_decisions = vec![];
+    let mut mcdc_degraded_branches = vec![];
+    let mut mcdc_mappings = vec![];
 
     if hir_info.is_async_fn || tcx.sess.coverage_no_mir_spans() {
         // An async function desugars into a function that returns a future,
@@ -99,17 +102,16 @@ pub(super) fn extract_all_mapping_info_from_mir<'tcx>(
         mir_body,
         hir_info.body_span,
         basic_coverage_blocks,
-        &mut mcdc_bitmap_bytes,
-        &mut mcdc_branches,
-        &mut mcdc_decisions,
+        &mut mcdc_degraded_branches,
+        &mut mcdc_mappings,
     );
 
     ExtractedMappings {
         code_mappings,
         branch_pairs,
-        mcdc_bitmap_bytes,
-        mcdc_branches,
-        mcdc_decisions,
+        mcdc_bitmap_bytes: 0, // Calculated in `coverage::create_mappings`
+        mcdc_degraded_branches,
+        mcdc_mappings,
     }
 }
 
@@ -123,8 +125,8 @@ impl ExtractedMappings {
             code_mappings,
             branch_pairs,
             mcdc_bitmap_bytes: _,
-            mcdc_branches,
-            mcdc_decisions,
+            mcdc_degraded_branches,
+            mcdc_mappings,
         } = self;
 
         // Identify which BCBs have one or more mappings.
@@ -140,16 +142,26 @@ impl ExtractedMappings {
             insert(true_bcb);
             insert(false_bcb);
         }
-        for &MCDCBranch { true_bcb, false_bcb, .. } in mcdc_branches {
-            insert(true_bcb);
-            insert(false_bcb);
+        for MCDCBranch { branch_bcbs, .. } in mcdc_degraded_branches
+            .iter()
+            .chain(mcdc_mappings.iter().map(|(_, branches)| branches.into_iter()).flatten())
+        {
+            match branch_bcbs {
+                MCDCBranchBlocks::Boolean(true_bcb, false_bcb) => {
+                    insert(*true_bcb);
+                    insert(*false_bcb);
+                }
+                MCDCBranchBlocks::PatternMatching => {
+                    unimplemented!("mcdc for pattern matching is not implemented yet")
+                }
+            }
         }
 
         // MC/DC decisions refer to BCBs, but don't require those BCBs to have counters.
         if bcbs_with_counter_mappings.is_empty() {
             debug_assert!(
-                mcdc_decisions.is_empty(),
-                "A function with no counter mappings shouldn't have any decisions: {mcdc_decisions:?}",
+                mcdc_mappings.is_empty(),
+                "A function with no counter mappings shouldn't have any decisions: {mcdc_mappings:?}",
             );
         }
 
@@ -220,9 +232,8 @@ pub(super) fn extract_mcdc_mappings(
     mir_body: &mir::Body<'_>,
     body_span: Span,
     basic_coverage_blocks: &CoverageGraph,
-    mcdc_bitmap_bytes: &mut u32,
-    mcdc_branches: &mut impl Extend<MCDCBranch>,
-    mcdc_decisions: &mut impl Extend<MCDCDecision>,
+    mcdc_degraded_branches: &mut impl Extend<MCDCBranch>,
+    mcdc_mappings: &mut impl Extend<(MCDCDecision, Vec<MCDCBranch>)>,
 ) {
     let Some(branch_info) = mir_body.coverage_branch_info.as_deref() else { return };
 
@@ -231,57 +242,63 @@ pub(super) fn extract_mcdc_mappings(
     let bcb_from_marker =
         |marker: BlockMarkerId| basic_coverage_blocks.bcb_from_bb(block_markers[marker]?);
 
-    let check_branch_bcb =
-        |raw_span: Span, true_marker: BlockMarkerId, false_marker: BlockMarkerId| {
-            // For now, ignore any branch span that was introduced by
-            // expansion. This makes things like assert macros less noisy.
-            if !raw_span.ctxt().outer_expn_data().is_root() {
-                return None;
-            }
-            let (span, _) = unexpand_into_body_span_with_visible_macro(raw_span, body_span)?;
-
-            let true_bcb = bcb_from_marker(true_marker)?;
-            let false_bcb = bcb_from_marker(false_marker)?;
-            Some((span, true_bcb, false_bcb))
+    let check_branch_bcb = |raw_span: Span,
+                            first_markers: &[BlockMarkerId],
+                            second_markers: &[BlockMarkerId]| {
+        // For now, ignore any branch span that was introduced by
+        // expansion. This makes things like assert macros less noisy.
+        if !raw_span.ctxt().outer_expn_data().is_root() {
+            return None;
+        }
+        let (span, _) = unexpand_into_body_span_with_visible_macro(raw_span, body_span)?;
+
+        let first_bcbs =
+            first_markers.into_iter().copied().map(&bcb_from_marker).collect::<Option<Vec<_>>>()?;
+        let second_bcbs = second_markers
+            .into_iter()
+            .copied()
+            .map(&bcb_from_marker)
+            .collect::<Option<Vec<_>>>()?;
+
+        Some((span, first_bcbs, second_bcbs))
+    };
+
+    let extract_branch_mapping =
+        |&mir::coverage::MCDCBranchSpan { span: raw_span, condition_info, ref markers }| {
+            let (span, branch_bcbs) = match markers {
+                MCDCBranchMarkers::Boolean(true_marker, false_marker) => {
+                    let (span, true_bcb, false_bcb) =
+                        check_branch_bcb(raw_span, &[*true_marker], &[*false_marker])?;
+                    (span, MCDCBranchBlocks::Boolean(true_bcb[0], false_bcb[0]))
+                }
+                MCDCBranchMarkers::PatternMatching => unimplemented!("not implemented yet"),
+            };
+
+            Some(MCDCBranch { span, branch_bcbs, condition_info })
         };
 
-    mcdc_branches.extend(branch_info.mcdc_branch_spans.iter().filter_map(
-        |&mir::coverage::MCDCBranchSpan {
-             span: raw_span,
-             condition_info,
-             true_marker,
-             false_marker,
-             decision_depth,
-         }| {
-            let (span, true_bcb, false_bcb) =
-                check_branch_bcb(raw_span, true_marker, false_marker)?;
-            Some(MCDCBranch { span, true_bcb, false_bcb, condition_info, decision_depth })
-        },
-    ));
-
-    mcdc_decisions.extend(branch_info.mcdc_decision_spans.iter().filter_map(
-        |decision: &mir::coverage::MCDCDecisionSpan| {
-            let (span, _) = unexpand_into_body_span_with_visible_macro(decision.span, body_span)?;
-
-            let end_bcbs = decision
-                .end_markers
-                .iter()
-                .map(|&marker| bcb_from_marker(marker))
-                .collect::<Option<_>>()?;
-
-            // Each decision containing N conditions needs 2^N bits of space in
-            // the bitmap, rounded up to a whole number of bytes.
-            // The decision's "bitmap index" points to its first byte in the bitmap.
-            let bitmap_idx = *mcdc_bitmap_bytes;
-            *mcdc_bitmap_bytes += (1_u32 << decision.num_conditions).div_ceil(8);
-
-            Some(MCDCDecision {
+    mcdc_degraded_branches
+        .extend(branch_info.mcdc_degraded_spans.iter().filter_map(extract_branch_mapping));
+
+    mcdc_mappings.extend(branch_info.mcdc_spans.iter().filter_map(|(decision, branches)| {
+        let (span, _) = unexpand_into_body_span_with_visible_macro(decision.span, body_span)?;
+
+        let end_bcbs = decision
+            .end_markers
+            .iter()
+            .map(|&marker| bcb_from_marker(marker))
+            .collect::<Option<_>>()?;
+
+        let branch_mappings: Vec<_> =
+            branches.into_iter().filter_map(extract_branch_mapping).collect();
+        (branch_mappings.len() > 0).then_some((
+            MCDCDecision {
                 span,
                 end_bcbs,
-                bitmap_idx,
-                num_conditions: decision.num_conditions as u16,
+                bitmap_idx: 0, // Assigned in `coverage::create_mappings`
                 decision_depth: decision.decision_depth,
-            })
-        },
-    ));
+            },
+            branch_mappings,
+        ))
+    }));
 }

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -21,7 +21,7 @@ use rustc_span::{BytePos, Pos, RelativeBytePos, Span, Symbol};
 
 use crate::coverage::counters::{CounterIncrementSite, CoverageCounters};
 use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph};
-use crate::coverage::mappings::ExtractedMappings;
+use crate::coverage::mappings::{ExtractedMappings, MCDCBranchBlocks};
 use crate::MirPass;
 
 /// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected
@@ -71,7 +71,7 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
 
     ////////////////////////////////////////////////////
     // Extract coverage spans and other mapping info from MIR.
-    let extracted_mappings = mappings::extract_all_mapping_info_from_mir(
+    let mut extracted_mappings = mappings::extract_all_mapping_info_from_mir(
         tcx,
         mir_body,
         &hir_info,
@@ -91,29 +91,29 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
     }
 
     let bcb_has_counter_mappings = |bcb| bcbs_with_counter_mappings.contains(bcb);
-    let coverage_counters =
+    let mut coverage_counters =
         CoverageCounters::make_bcb_counters(&basic_coverage_blocks, bcb_has_counter_mappings);
 
-    let mappings = create_mappings(tcx, &hir_info, &extracted_mappings, &coverage_counters);
-    if mappings.is_empty() {
-        // No spans could be converted into valid mappings, so skip this function.
-        debug!("no spans could be converted into valid mappings; skipping");
-        return;
-    }
-
     inject_coverage_statements(
         mir_body,
         &basic_coverage_blocks,
         bcb_has_counter_mappings,
-        &coverage_counters,
+        &mut coverage_counters,
     );
 
+    let mappings = create_mappings(tcx, &hir_info, &mut extracted_mappings, &mut coverage_counters);
+    if mappings.is_empty() {
+        // No spans could be converted into valid mappings, so skip this function.
+        debug!("no spans could be converted into valid mappings; skipping");
+        return;
+    }
+
     inject_mcdc_statements(mir_body, &basic_coverage_blocks, &extracted_mappings);
 
     let mcdc_num_condition_bitmaps = extracted_mappings
-        .mcdc_decisions
+        .mcdc_mappings
         .iter()
-        .map(|&mappings::MCDCDecision { decision_depth, .. }| decision_depth)
+        .map(|&(mappings::MCDCDecision { decision_depth, .. }, _)| decision_depth)
         .max()
         .map_or(0, |max| usize::from(max) + 1);
 
@@ -135,8 +135,8 @@ fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir:
 fn create_mappings<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_info: &ExtractedHirInfo,
-    extracted_mappings: &ExtractedMappings,
-    coverage_counters: &CoverageCounters,
+    extracted_mappings: &mut ExtractedMappings,
+    coverage_counters: &mut CoverageCounters,
 ) -> Vec<Mapping> {
     let source_map = tcx.sess.source_map();
     let body_span = hir_info.body_span;
@@ -160,9 +160,9 @@ fn create_mappings<'tcx>(
     let ExtractedMappings {
         code_mappings,
         branch_pairs,
-        mcdc_bitmap_bytes: _,
-        mcdc_branches,
-        mcdc_decisions,
+        mcdc_bitmap_bytes,
+        mcdc_degraded_branches,
+        mcdc_mappings,
     } = extracted_mappings;
     let mut mappings = Vec::new();
 
@@ -184,27 +184,91 @@ fn create_mappings<'tcx>(
             Some(Mapping { kind, code_region })
         },
     ));
+    let mut counter_for_bcbs_group = |bcbs: &[BasicCoverageBlock]| {
+        let counters = bcbs
+            .into_iter()
+            .copied()
+            .map(|bcb| {
+                coverage_counters.bcb_counter(bcb).expect("all BCBs with spans were given counters")
+            })
+            .collect::<Vec<_>>();
+        counters
+            .into_iter()
+            .fold(None, |acc, val| Some(coverage_counters.make_sum_expression(acc, val)))
+            .expect("counters must be non-empty")
+    };
 
-    mappings.extend(mcdc_branches.iter().filter_map(
-        |&mappings::MCDCBranch { span, true_bcb, false_bcb, condition_info, decision_depth: _ }| {
+    let mut create_mcdc_branch_terms = |branch_bcbs: &MCDCBranchBlocks| match branch_bcbs {
+        MCDCBranchBlocks::Boolean(true_bcb, false_bcb) => {
+            let true_counter = counter_for_bcbs_group(&[*true_bcb]);
+            let false_counter = counter_for_bcbs_group(&[*false_bcb]);
+            (true_counter.as_term(), false_counter.as_term())
+        }
+        MCDCBranchBlocks::PatternMatching => {
+            unimplemented!("mcdc for pattern matching is not implemented yet");
+        }
+    };
+    // MCDC branch mappings are appended with their decisions in case decisions were ignored.
+    mappings.extend(mcdc_degraded_branches.iter().filter_map(
+        |&mappings::MCDCBranch { span, ref branch_bcbs, condition_info: _ }| {
             let code_region = region_for_span(span)?;
-            let true_term = term_for_bcb(true_bcb);
-            let false_term = term_for_bcb(false_bcb);
-            let kind = match condition_info {
-                Some(mcdc_params) => MappingKind::MCDCBranch { true_term, false_term, mcdc_params },
-                None => MappingKind::Branch { true_term, false_term },
-            };
-            Some(Mapping { kind, code_region })
+            let (true_term, false_term) = create_mcdc_branch_terms(branch_bcbs);
+            Some(Mapping { kind: MappingKind::Branch { true_term, false_term }, code_region })
         },
     ));
 
-    mappings.extend(mcdc_decisions.iter().filter_map(
-        |&mappings::MCDCDecision { span, bitmap_idx, num_conditions, .. }| {
-            let code_region = region_for_span(span)?;
-            let kind = MappingKind::MCDCDecision(DecisionInfo { bitmap_idx, num_conditions });
-            Some(Mapping { kind, code_region })
-        },
-    ));
+    let mut next_bitmap_idx = |num_conditions: u16| {
+        let bitmap_idx = *mcdc_bitmap_bytes;
+        // Each decision containing N conditions needs 2^N bits of space in
+        // the bitmap, rounded up to a whole number of bytes.
+        // The decision's "bitmap index" points to its first byte in the bitmap.
+        *mcdc_bitmap_bytes += (1_u16 << num_conditions).div_ceil(8) as u32;
+        bitmap_idx
+    };
+
+    for (decision, branches) in mcdc_mappings {
+        let num_conditions = branches.len() as u16;
+        let conditions = branches
+            .into_iter()
+            .filter_map(|&mut mappings::MCDCBranch { span, ref branch_bcbs, condition_info }| {
+                let code_region = region_for_span(span)?;
+                let (true_term, false_term) = create_mcdc_branch_terms(branch_bcbs);
+                Some(Mapping {
+                    kind: MappingKind::MCDCBranch {
+                        true_term,
+                        false_term,
+                        mcdc_params: condition_info,
+                    },
+                    code_region,
+                })
+            })
+            .collect::<Vec<_>>();
+
+        if conditions.len() == num_conditions as usize
+            && let Some(code_region) = region_for_span(decision.span)
+        {
+            decision.bitmap_idx = next_bitmap_idx(num_conditions);
+            let kind = MappingKind::MCDCDecision(DecisionInfo {
+                bitmap_idx: decision.bitmap_idx,
+                num_conditions,
+            });
+            mappings.extend(
+                std::iter::once(Mapping { kind, code_region }).chain(conditions.into_iter()),
+            );
+        } else {
+            mappings.extend(conditions.into_iter().map(|mapping| {
+                let MappingKind::MCDCBranch { true_term, false_term, mcdc_params: _ } =
+                    mapping.kind
+                else {
+                    unreachable!("all mappings here are MCDCBranch as shown above");
+                };
+                Mapping {
+                    kind: MappingKind::Branch { true_term, false_term },
+                    code_region: mapping.code_region,
+                }
+            }))
+        }
+    }
 
     mappings
 }
@@ -268,43 +332,41 @@ fn inject_mcdc_statements<'tcx>(
     basic_coverage_blocks: &CoverageGraph,
     extracted_mappings: &ExtractedMappings,
 ) {
-    // Inject test vector update first because `inject_statement` always insert new statement at head.
-    for &mappings::MCDCDecision {
-        span: _,
-        ref end_bcbs,
-        bitmap_idx,
-        num_conditions: _,
-        decision_depth,
-    } in &extracted_mappings.mcdc_decisions
-    {
-        for end in end_bcbs {
-            let end_bb = basic_coverage_blocks[*end].leader_bb();
+    for (decision, conditions) in &extracted_mappings.mcdc_mappings {
+        // Inject test vector update first because `inject_statement` always insert new statement at head.
+        for &end in &decision.end_bcbs {
+            let end_bb = basic_coverage_blocks[end].leader_bb();
             inject_statement(
                 mir_body,
-                CoverageKind::TestVectorBitmapUpdate { bitmap_idx, decision_depth },
+                CoverageKind::TestVectorBitmapUpdate {
+                    bitmap_idx: decision.bitmap_idx,
+                    decision_depth: decision.decision_depth,
+                },
                 end_bb,
             );
         }
-    }
-
-    for &mappings::MCDCBranch { span: _, true_bcb, false_bcb, condition_info, decision_depth } in
-        &extracted_mappings.mcdc_branches
-    {
-        let Some(condition_info) = condition_info else { continue };
-        let id = condition_info.condition_id;
 
-        let true_bb = basic_coverage_blocks[true_bcb].leader_bb();
-        inject_statement(
-            mir_body,
-            CoverageKind::CondBitmapUpdate { id, value: true, decision_depth },
-            true_bb,
-        );
-        let false_bb = basic_coverage_blocks[false_bcb].leader_bb();
-        inject_statement(
-            mir_body,
-            CoverageKind::CondBitmapUpdate { id, value: false, decision_depth },
-            false_bb,
-        );
+        for &mappings::MCDCBranch { span: _, ref branch_bcbs, condition_info } in conditions {
+            let id = condition_info.condition_id;
+            let true_bcbs = match branch_bcbs {
+                MCDCBranchBlocks::Boolean(true_bcb, _) => &[*true_bcb],
+                MCDCBranchBlocks::PatternMatching => {
+                    unimplemented!("mcdc for pattern matching is not implemented yet")
+                }
+            };
+            for &bcb in true_bcbs {
+                let bb = basic_coverage_blocks[bcb].leader_bb();
+                inject_statement(
+                    mir_body,
+                    CoverageKind::CondBitmapUpdate {
+                        id,
+                        value: true,
+                        decision_depth: decision.decision_depth,
+                    },
+                    bb,
+                );
+            }
+        }
     }
 }