mcdc-coverage: Add decision_depth field in structs

Add decision_depth field to TVBitmapUpdate/CondBitmapUpdate statements
Add decision_depth field to BcbMappingKinds MCDCBranch and MCDCDecision
Add decision_depth field to MCDCBranchSpan and MCDCDecisionSpan

Author: RenjiSann

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -146,7 +146,7 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
             CoverageKind::ExpressionUsed { id } => {
                 func_coverage.mark_expression_id_seen(id);
             }
-            CoverageKind::CondBitmapUpdate { id, value, .. } => {
+            CoverageKind::CondBitmapUpdate { id, value, decision_depth } => {
                 drop(coverage_map);
                 assert_ne!(
                     id.as_u32(),
@@ -156,21 +156,23 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
                 let cond_bitmaps = coverage_context
                     .try_get_mcdc_condition_bitmap(&instance)
                     .expect("mcdc cond bitmap should have been allocated for updating");
-                let cond_bitmap =
-                    cond_bitmaps.get(0).expect("no mcdc cond bitmap with the given depth");
+                let cond_bitmap = cond_bitmaps
+                    .get(decision_depth as usize)
+                    .expect("no mcdc cond bitmap with the given depth");
                 let cond_loc = bx.const_i32(id.as_u32() as i32 - 1);
                 let bool_value = bx.const_bool(value);
                 let fn_name = bx.get_pgo_func_name_var(instance);
                 let hash = bx.const_u64(function_coverage_info.function_source_hash);
                 bx.mcdc_condbitmap_update(fn_name, hash, cond_loc, cond_bitmap, bool_value);
             }
-            CoverageKind::TestVectorBitmapUpdate { bitmap_idx } => {
+            CoverageKind::TestVectorBitmapUpdate { bitmap_idx, decision_depth } => {
                 drop(coverage_map);
                 let cond_bitmaps = coverage_context
                                     .try_get_mcdc_condition_bitmap(&instance)
                                     .expect("mcdc cond bitmap should have been allocated for merging into the global bitmap");
-                let cond_bitmap =
-                    cond_bitmaps.get(0).expect("no mcdc cond bitmap with the given depth");
+                let cond_bitmap = cond_bitmaps
+                    .get(decision_depth as usize)
+                    .expect("no mcdc cond bitmap with the given depth");
                 let bitmap_bytes = bx.tcx().coverage_ids_info(instance.def).mcdc_bitmap_bytes;
                 assert!(bitmap_idx < bitmap_bytes, "bitmap index of the decision out of range");
                 assert!(

compiler/rustc_middle/src/mir/coverage.rs

@@ -132,15 +132,15 @@ pub enum CoverageKind {
     ///
     /// If this statement does not survive MIR optimizations, the condition would never be
     /// taken as evaluated.
-    CondBitmapUpdate { id: ConditionId, value: bool },
+    CondBitmapUpdate { id: ConditionId, value: bool, decision_depth: u16 },
 
     /// Marks the point in MIR control flow represented by a evaluated decision.
     ///
     /// This is eventually lowered to `llvm.instrprof.mcdc.tvbitmap.update` in LLVM IR.
     ///
     /// If this statement does not survive MIR optimizations, the decision would never be
     /// taken as evaluated.
-    TestVectorBitmapUpdate { bitmap_idx: u32 },
+    TestVectorBitmapUpdate { bitmap_idx: u32, decision_depth: u16 },
 }
 
 impl Debug for CoverageKind {
@@ -151,11 +151,11 @@ impl Debug for CoverageKind {
             BlockMarker { id } => write!(fmt, "BlockMarker({:?})", id.index()),
             CounterIncrement { id } => write!(fmt, "CounterIncrement({:?})", id.index()),
             ExpressionUsed { id } => write!(fmt, "ExpressionUsed({:?})", id.index()),
-            CondBitmapUpdate { id, value } => {
-                write!(fmt, "CondBitmapUpdate({:?}, {:?})", id.index(), value)
+            CondBitmapUpdate { id, value, decision_depth } => {
+                write!(fmt, "CondBitmapUpdate({:?}, {:?}, {:?})", id.index(), value, decision_depth)
             }
-            TestVectorBitmapUpdate { bitmap_idx } => {
-                write!(fmt, "TestVectorUpdate({:?})", bitmap_idx)
+            TestVectorBitmapUpdate { bitmap_idx, decision_depth } => {
+                write!(fmt, "TestVectorUpdate({:?}, {:?})", bitmap_idx, decision_depth)
             }
         }
     }
@@ -317,6 +317,7 @@ pub struct MCDCBranchSpan {
     pub condition_info: ConditionInfo,
     pub true_marker: BlockMarkerId,
     pub false_marker: BlockMarkerId,
+    pub decision_depth: u16,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -332,4 +333,5 @@ pub struct MCDCDecisionSpan {
     pub span: Span,
     pub conditions_num: usize,
     pub end_markers: Vec<BlockMarkerId>,
+    pub decision_depth: u16,
 }

compiler/rustc_middle/src/mir/pretty.rs

@@ -485,20 +485,27 @@ fn write_coverage_branch_info(
         )?;
     }
 
-    for coverage::MCDCBranchSpan { span, condition_info, true_marker, false_marker } in
-        mcdc_branch_spans
+    for coverage::MCDCBranchSpan {
+        span,
+        condition_info,
+        true_marker,
+        false_marker,
+        decision_depth,
+    } in mcdc_branch_spans
     {
         writeln!(
             w,
-            "{INDENT}coverage mcdc branch {{ condition_id: {:?}, true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
+            "{INDENT}coverage mcdc branch {{ condition_id: {:?}, true: {true_marker:?}, false: {false_marker:?}, depth: {decision_depth:?} }} => {span:?}",
             condition_info.condition_id
         )?;
     }
 
-    for coverage::MCDCDecisionSpan { span, conditions_num, end_markers } in mcdc_decision_spans {
+    for coverage::MCDCDecisionSpan { span, conditions_num, end_markers, decision_depth } in
+        mcdc_decision_spans
+    {
         writeln!(
             w,
-            "{INDENT}coverage mcdc decision {{ conditions_num: {conditions_num:?}, end: {end_markers:?} }} => {span:?}"
+            "{INDENT}coverage mcdc decision {{ conditions_num: {conditions_num:?}, end: {end_markers:?}, depth: {decision_depth:?} }} => {span:?}"
         )?;
     }
 

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -242,6 +242,7 @@ impl MCDCState {
                 span,
                 conditions_num: 0,
                 end_markers: vec![],
+                decision_depth: 0,
             }),
         };
 
@@ -363,6 +364,7 @@ impl Builder<'_, '_> {
                 condition_info,
                 true_marker,
                 false_marker,
+                decision_depth: 0,
             });
         } else {
             branch_info.branch_spans.push(BranchSpan {

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -149,7 +149,7 @@ fn create_mappings<'tcx>(
                     true_term: term_for_bcb(true_bcb),
                     false_term: term_for_bcb(false_bcb),
                 },
-                BcbMappingKind::MCDCBranch { true_bcb, false_bcb, condition_info } => {
+                BcbMappingKind::MCDCBranch { true_bcb, false_bcb, condition_info, .. } => {
                     MappingKind::MCDCBranch {
                         true_term: term_for_bcb(true_bcb),
                         false_term: term_for_bcb(false_bcb),
@@ -232,38 +232,42 @@ fn inject_mcdc_statements<'tcx>(
     }
 
     // Inject test vector update first because `inject_statement` always insert new statement at head.
-    for (end_bcbs, bitmap_idx) in
+    for (end_bcbs, bitmap_idx, decision_depth) in
         coverage_spans.all_bcb_mappings().filter_map(|mapping| match &mapping.kind {
-            BcbMappingKind::MCDCDecision { end_bcbs, bitmap_idx, .. } => {
-                Some((end_bcbs, *bitmap_idx))
+            BcbMappingKind::MCDCDecision { end_bcbs, bitmap_idx, decision_depth, .. } => {
+                Some((end_bcbs, *bitmap_idx, *decision_depth))
             }
             _ => None,
         })
     {
         for end in end_bcbs {
             let end_bb = basic_coverage_blocks[*end].leader_bb();
-            inject_statement(mir_body, CoverageKind::TestVectorBitmapUpdate { bitmap_idx }, end_bb);
+            inject_statement(
+                mir_body,
+                CoverageKind::TestVectorBitmapUpdate { bitmap_idx, decision_depth },
+                end_bb,
+            );
         }
     }
 
-    for (true_bcb, false_bcb, condition_id) in
+    for (true_bcb, false_bcb, condition_id, decision_depth) in
         coverage_spans.all_bcb_mappings().filter_map(|mapping| match mapping.kind {
-            BcbMappingKind::MCDCBranch { true_bcb, false_bcb, condition_info } => {
-                Some((true_bcb, false_bcb, condition_info.condition_id))
+            BcbMappingKind::MCDCBranch { true_bcb, false_bcb, condition_info, decision_depth } => {
+                Some((true_bcb, false_bcb, condition_info.condition_id, decision_depth))
             }
             _ => None,
         })
     {
         let true_bb = basic_coverage_blocks[true_bcb].leader_bb();
         inject_statement(
             mir_body,
-            CoverageKind::CondBitmapUpdate { id: condition_id, value: true },
+            CoverageKind::CondBitmapUpdate { id: condition_id, value: true, decision_depth },
             true_bb,
         );
         let false_bb = basic_coverage_blocks[false_bcb].leader_bb();
         inject_statement(
             mir_body,
-            CoverageKind::CondBitmapUpdate { id: condition_id, value: false },
+            CoverageKind::CondBitmapUpdate { id: condition_id, value: false, decision_depth },
             false_bb,
         );
     }

compiler/rustc_mir_transform/src/coverage/spans.rs

@@ -22,9 +22,15 @@ pub(super) enum BcbMappingKind {
         true_bcb: BasicCoverageBlock,
         false_bcb: BasicCoverageBlock,
         condition_info: ConditionInfo,
+        decision_depth: u16,
     },
     /// Associates a mcdc decision with its join BCB.
-    MCDCDecision { end_bcbs: BTreeSet<BasicCoverageBlock>, bitmap_idx: u32, conditions_num: u16 },
+    MCDCDecision {
+        end_bcbs: BTreeSet<BasicCoverageBlock>,
+        bitmap_idx: u32,
+        conditions_num: u16,
+        decision_depth: u16,
+    },
 }
 
 #[derive(Debug)]

compiler/rustc_mir_transform/src/coverage/spans/from_mir.rs

@@ -412,15 +412,25 @@ pub(super) fn extract_branch_mappings(
         })
     };
 
-    let mcdc_branch_filter_map =
-        |&MCDCBranchSpan { span: raw_span, true_marker, false_marker, condition_info }| {
-            check_branch_bcb(raw_span, true_marker, false_marker).map(
-                |(span, true_bcb, false_bcb)| BcbMapping {
-                    kind: BcbMappingKind::MCDCBranch { true_bcb, false_bcb, condition_info },
-                    span,
+    let mcdc_branch_filter_map = |&MCDCBranchSpan {
+                                      span: raw_span,
+                                      true_marker,
+                                      false_marker,
+                                      condition_info,
+                                      decision_depth,
+                                  }| {
+        check_branch_bcb(raw_span, true_marker, false_marker).map(|(span, true_bcb, false_bcb)| {
+            BcbMapping {
+                kind: BcbMappingKind::MCDCBranch {
+                    true_bcb,
+                    false_bcb,
+                    condition_info,
+                    decision_depth,
                 },
-            )
-        };
+                span,
+            }
+        })
+    };
 
     let mut next_bitmap_idx = 0;
 
@@ -441,6 +451,7 @@ pub(super) fn extract_branch_mappings(
                 end_bcbs,
                 bitmap_idx,
                 conditions_num: decision.conditions_num as u16,
+                decision_depth: decision.decision_depth,
             },
             span,
         })