coverage. Add CondBitmapReset statement

Author: zhuyunxing

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1744,7 +1744,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
                 0 as c_uint,
             );
         }
-        self.store(self.const_i32(0), mcdc_temp, self.tcx.data_layout.i32_align.abi);
+        self.mcdc_condbitmap_reset(mcdc_temp);
     }
 
     pub(crate) fn mcdc_condbitmap_update(&mut self, cond_index: &'ll Value, mcdc_temp: &'ll Value) {
@@ -1758,4 +1758,10 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         let new_tv_index = self.add(current_tv_index, cond_index);
         self.store(new_tv_index, mcdc_temp, align);
     }
+
+    pub(crate) fn mcdc_condbitmap_reset(&mut self, mcdc_temp: &'ll Value) {
+        debug!("mcdc_condbitmap_reset() with args ({:?})", mcdc_temp);
+        let align = self.tcx.data_layout.i32_align.abi;
+        self.store(self.const_i32(0), mcdc_temp, align);
+    }
 }

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -208,6 +208,13 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
                 let bitmap_index = bx.const_u32(bitmap_idx);
                 bx.mcdc_tvbitmap_update(fn_name, hash, bitmap_index, cond_bitmap);
             }
+            CoverageKind::CondBitmapReset { decision_depth } => {
+                drop(coverage_map);
+                let cond_bitmap = coverage_context
+                                    .try_get_mcdc_condition_bitmap(&instance, decision_depth)
+                                    .expect("mcdc cond bitmap should have been allocated for merging into the global bitmap");
+                bx.mcdc_condbitmap_reset(cond_bitmap);
+            }
         }
     }
 }

compiler/rustc_middle/src/mir/coverage.rs

@@ -140,6 +140,11 @@ pub enum CoverageKind {
     /// This is eventually lowered to instruments updating mcdc temp variables.
     CondBitmapUpdate { index: u32, decision_depth: u16 },
 
+    /// Marks the point in MIR control flow where a condition bitmap is reset.
+    ///
+    /// This is eventually lowered to instruments set the mcdc temp variable to zero.
+    CondBitmapReset { 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.
@@ -157,6 +162,9 @@ impl Debug for CoverageKind {
             CondBitmapUpdate { index, decision_depth } => {
                 write!(fmt, "CondBitmapUpdate(index={:?}, depth={:?})", index, decision_depth)
             }
+            CondBitmapReset { decision_depth } => {
+                write!(fmt, "CondBitmapReset(depth={:?})", decision_depth)
+            }
             TestVectorBitmapUpdate { bitmap_idx, decision_depth } => {
                 write!(fmt, "TestVectorUpdate({:?}, depth={:?})", bitmap_idx, decision_depth)
             }

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

@@ -139,7 +139,8 @@ fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span> {
             CoverageKind::CounterIncrement { .. }
             | CoverageKind::ExpressionUsed { .. }
             | CoverageKind::CondBitmapUpdate { .. }
-            | CoverageKind::TestVectorBitmapUpdate { .. },
+            | CoverageKind::TestVectorBitmapUpdate { .. }
+            | CoverageKind::CondBitmapReset { .. },
         ) => bug!(
             "Unexpected coverage statement found during coverage instrumentation: {statement:?}"
         ),