mcdc-coverage: Add CoverageKind::MCDCBitmapRequire

Author: RenjiSann

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -105,6 +105,11 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
             | CoverageKind::MCDCDecisionMarker { .. } => unreachable!(
                 "marker statement {kind:?} should have been removed by CleanupPostBorrowck"
             ),
+            CoverageKind::MCDCBitmapRequire { needed_bytes } => {
+                // FIXME(dprn): TODO
+                let _ = needed_bytes;
+                warn!("call to correct intrinsic");
+            }
             CoverageKind::CounterIncrement { id } => {
                 func_coverage.mark_counter_id_seen(id);
                 // We need to explicitly drop the `RefMut` before calling into `instrprof_increment`,
@@ -290,4 +295,4 @@ pub(crate) fn prf_bits_section_name(cx: &CodegenCx<'_, '_>) -> String {
         llvm::LLVMRustCoverageWriteBitmapSectionNameToString(cx.llmod, s);
     })
     .expect("Rust Coverage function record section name failed UTF-8 conversion")
-}
+}

compiler/rustc_middle/src/mir/coverage.rs

@@ -116,6 +116,13 @@ pub enum CoverageKind {
     /// Has no effect during codegen.
     MCDCDecisionMarker { id: DecisionMarkerId },
 
+    /// Declares the number of bytes needed to store the test-vector bitmaps of
+    /// all the decisions in the function body.
+    ///
+    /// In LLVM backend, this is done by inserting a call to the
+    /// `instrprof.mcdc.parameters` intrinsic.
+    MCDCBitmapRequire { needed_bytes: u32 },
+
     /// Marks the point in MIR control flow represented by a coverage counter.
     ///
     /// This is eventually lowered to `llvm.instrprof.increment` in LLVM IR.
@@ -145,6 +152,7 @@ impl Debug for CoverageKind {
                 write!(fmt, "MCDCBlockMarker({:?}, {:?})", id.index(), decision_id.index())
             }
             MCDCDecisionMarker { id } => write!(fmt, "MCDCDecisionMarker({:?})", id.index()),
+            MCDCBitmapRequire { needed_bytes } => write!(fmt, "MCDCBitmapRequire({needed_bytes} bytes)"),
             CounterIncrement { id } => write!(fmt, "CounterIncrement({:?})", id.index()),
             ExpressionUsed { id } => write!(fmt, "ExpressionUsed({:?})", id.index()),
         }

compiler/rustc_middle/src/mir/pretty.rs

@@ -475,14 +475,33 @@ fn write_coverage_branch_info(
     branch_info: &coverage::BranchInfo,
     w: &mut dyn io::Write,
 ) -> io::Result<()> {
-    let coverage::BranchInfo { branch_spans, .. } = branch_info;
+    let coverage::BranchInfo { branch_spans, decision_spans, .. } = branch_info;
 
-    for coverage::BranchSpan { span, true_marker, false_marker, .. } in branch_spans {
+    // Write MCDC stuff as well if present
+    for (id, coverage::DecisionSpan { span, num_conditions }) in decision_spans.iter_enumerated() {
         writeln!(
             w,
-            "{INDENT}coverage branch {{ true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
+            "{INDENT}coverage MCDC decision {{ id: {id:?}, num_conditions: {num_conditions:?} }} => {span:?}",
         )?;
     }
+
+    if !decision_spans.is_empty() {
+        writeln!(w)?;
+        for coverage::BranchSpan { span, true_marker, false_marker, decision_id } in branch_spans {
+            writeln!(
+                w,
+                "{INDENT}coverage branch {{ decision: {decision_id:?}, true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
+            )?;
+        }
+    } else {
+        for coverage::BranchSpan { span, true_marker, false_marker, .. } in branch_spans {
+            writeln!(
+                w,
+                "{INDENT}coverage branch {{ true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
+            )?;
+        }
+    }
+
     if !branch_spans.is_empty() {
         writeln!(w)?;
     }

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

@@ -232,7 +232,8 @@ fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span> {
 
         // These coverage statements should not exist prior to coverage instrumentation.
         StatementKind::Coverage(
-            CoverageKind::CounterIncrement { .. } | CoverageKind::ExpressionUsed { .. },
+            CoverageKind::CounterIncrement { .. } | CoverageKind::ExpressionUsed { .. }
+            | CoverageKind::MCDCBitmapRequire { .. },
         ) => bug!(
             "Unexpected coverage statement found during coverage instrumentation: {statement:?}"
         ),