Support MCDC Coverage with LLVM backend.

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1238,6 +1238,122 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
+    fn instrprof_mcdc_parameters(
+        &mut self,
+        fn_name: Self::Value,
+        hash: Self::Value,
+        num_bitmap_bytes: Self::Value,
+    ) {
+        debug!(
+            "instrprof_mcdc_parameters() with args ({:?}, {:?}, {:?})",
+            fn_name, hash, num_bitmap_bytes
+        );
+
+        let llfn = unsafe { llvm::LLVMRustGetInstrProfMCDCParametersIntrinsic(self.cx().llmod) };
+        let llty = self.cx.type_func(
+            &[self.cx.type_ptr(), self.cx.type_i64(), self.cx.type_i32()],
+            self.cx.type_void(),
+        );
+        let args = &[fn_name, hash, num_bitmap_bytes];
+        let args = self.check_call("call", llty, llfn, args);
+
+        unsafe {
+            let _ = llvm::LLVMRustBuildCall(
+                self.llbuilder,
+                llty,
+                llfn,
+                args.as_ptr() as *const &llvm::Value,
+                args.len() as c_uint,
+                [].as_ptr(),
+                0 as c_uint,
+            );
+        }
+    }
+
+    fn instrprof_mcdc_condbitmap_update(
+        &mut self,
+        fn_name: Self::Value,
+        hash: Self::Value,
+        cond_id: Self::Value,
+        cond_bitmap_addr: Self::Value,
+        cond_result: Self::Value,
+    ) {
+        debug!(
+            "instrprof_mcdc_condbitmap_update() with args ({:?}, {:?}, {:?}, {:?}, {:?})",
+            fn_name, hash, cond_id, cond_bitmap_addr, cond_result
+        );
+
+        let llfn =
+            unsafe { llvm::LLVMRustGetInstrProfMCDCCondBitmapUpdateIntrinsic(self.cx().llmod) };
+        let llty = self.cx.type_func(
+            &[
+                self.cx.type_ptr(),
+                self.cx.type_i64(),
+                self.cx.type_i32(),
+                self.cx.type_ptr(),
+                self.cx.type_i1(),
+            ],
+            self.cx.type_void(),
+        );
+
+        let args = &[fn_name, hash, cond_id, cond_bitmap_addr, cond_result];
+        let args = self.check_call("call", llty, llfn, args);
+
+        unsafe {
+            let _ = llvm::LLVMRustBuildCall(
+                self.llbuilder,
+                llty,
+                llfn,
+                args.as_ptr(),
+                args.len() as c_uint,
+                [].as_ptr(),
+                0 as c_uint,
+            );
+        }
+    }
+
+    fn instrprof_mcdc_tvbitmap_update(
+        &mut self,
+        fn_name: Self::Value,
+        hash: Self::Value,
+        needed_bytes: Self::Value,
+        bitmap_idx: Self::Value,
+        cond_bitmap_addr: Self::Value,
+    ) {
+        debug!(
+            "instrprof_mcdc_tvbitmap_update() with args ({:?}, {:?}, {:?}, {:?}, {:?})",
+            fn_name, hash, needed_bytes, bitmap_idx, cond_bitmap_addr
+        );
+
+        let llfn =
+            unsafe { llvm::LLVMRustGetInstrProfMCDCTVBitmapUpdateIntrinsic(self.cx().llmod) };
+        let llty = self.cx.type_func(
+            &[
+                self.cx.type_ptr(),
+                self.cx.type_i64(),
+                self.cx.type_i32(),
+                self.cx.type_i32(),
+                self.cx.type_ptr(),
+            ],
+            self.cx.type_void(),
+        );
+
+        let args = &[fn_name, hash, needed_bytes, bitmap_idx, cond_bitmap_addr];
+        let args = self.check_call("call", llty, llfn, args);
+
+        unsafe {
+            let _ = llvm::LLVMRustBuildCall(
+                self.llbuilder,
+                llty,
+                llfn,
+                args.as_ptr(),
+                args.len() as c_uint,
+                [].as_ptr(),
+                0 as c_uint,
+            );
+        }
+    }
+
     fn call(
         &mut self,
         llty: &'ll Type,

compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs

@@ -99,6 +99,36 @@ pub enum RegionKind {
     /// associated with two counters, each representing the number of times the
     /// expression evaluates to true or false.
     BranchRegion = 4,
+
+    /// A DecisionRegion represents a top-level boolean expression and is
+    /// associated with a variable length bitmap index and condition number.
+    MCDCDecisionRegion = 5,
+
+    /// A Branch Region can be extended to include IDs to facilitate MC/DC.
+    #[allow(dead_code)]
+    MCDCBranchRegion = 6,
+}
+
+/// This struct provides LLVM's representation of "MCDCParameters" that may be defined for a
+/// Coverage Mapping Region.
+///
+/// Correspond to struct `llvm::coverage::CounterMappingRegion::MCDCParameters`
+///
+/// Must match The layout of `LLVMRustMCDCParameters`
+#[derive(Copy, Clone, Debug, Default)]
+#[repr(C)]
+pub struct MCDCParameters {
+    /// Byte Index of Bitmap Coverage Object for a Decision Region.
+    bitmap_idx: u32,
+
+    /// Number of Conditions used for a Decision Region.
+    num_conditions: u32,
+
+    /// IDs used to represent a branch region and other branch regions
+    /// evaluated based on True and False branches.
+    id: u32,
+    true_id: u32,
+    false_id: u32,
 }
 
 /// This struct provides LLVM's representation of a "CoverageMappingRegion", encoded into the
@@ -146,6 +176,8 @@ pub struct CounterMappingRegion {
     end_col: u32,
 
     kind: RegionKind,
+
+    mcdc_params: MCDCParameters,
 }
 
 impl CounterMappingRegion {
@@ -172,6 +204,33 @@ impl CounterMappingRegion {
                 start_col,
                 end_line,
                 end_col,
+                None,
+            ),
+            MappingKind::MCDCBranch { true_term, false_term, id, true_id, false_id } => {
+                Self::branch_region(
+                    Counter::from_term(true_term),
+                    Counter::from_term(false_term),
+                    local_file_id,
+                    start_line,
+                    start_col,
+                    end_line,
+                    end_col,
+                    Some(MCDCParameters {
+                        id,
+                        true_id,
+                        false_id,
+                        .. Default::default()
+                    }),
+                )
+            }
+            MappingKind::MCDCDecision { bitmap_idx, num_conditions } => Self::decision_region(
+                bitmap_idx,
+                num_conditions,
+                local_file_id,
+                start_line,
+                start_col,
+                end_line,
+                end_col,
             ),
         }
     }
@@ -194,9 +253,11 @@ impl CounterMappingRegion {
             end_line,
             end_col,
             kind: RegionKind::CodeRegion,
+            mcdc_params: Default::default(),
         }
     }
 
+    /// - `mcdc_params` should be None when MCDC is disabled.
     pub(crate) fn branch_region(
         counter: Counter,
         false_counter: Counter,
@@ -205,7 +266,13 @@ impl CounterMappingRegion {
         start_col: u32,
         end_line: u32,
         end_col: u32,
+        mcdc_params: Option<MCDCParameters>,
     ) -> Self {
+        let (kind, mcdc_params) = match mcdc_params {
+            None => (RegionKind::BranchRegion, Default::default()),
+            Some(params) => (RegionKind::MCDCBranchRegion, params),
+        };
+
         Self {
             counter,
             false_counter,
@@ -215,7 +282,31 @@ impl CounterMappingRegion {
             start_col,
             end_line,
             end_col,
-            kind: RegionKind::BranchRegion,
+            kind,
+            mcdc_params,
+        }
+    }
+
+    pub(crate) fn decision_region(
+        bitmap_idx: u32,
+        num_conditions: u32,
+        file_id: u32,
+        start_line: u32,
+        start_col: u32,
+        end_line: u32,
+        end_col: u32,
+    ) -> Self {
+        Self {
+            counter: Counter::ZERO,
+            false_counter: Counter::ZERO,
+            file_id,
+            expanded_file_id: 0,
+            start_line,
+            start_col,
+            end_line,
+            end_col,
+            kind: RegionKind::MCDCDecisionRegion,
+            mcdc_params: MCDCParameters { bitmap_idx, num_conditions, ..Default::default() },
         }
     }
 
@@ -240,6 +331,7 @@ impl CounterMappingRegion {
             end_line,
             end_col,
             kind: RegionKind::ExpansionRegion,
+            mcdc_params: Default::default(),
         }
     }
 
@@ -263,6 +355,7 @@ impl CounterMappingRegion {
             end_line,
             end_col,
             kind: RegionKind::SkippedRegion,
+            mcdc_params: Default::default(),
         }
     }
 
@@ -287,6 +380,7 @@ impl CounterMappingRegion {
             end_line,
             end_col: (1_u32 << 31) | end_col,
             kind: RegionKind::GapRegion,
+            mcdc_params: Default::default(),
         }
     }
 }

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

@@ -31,10 +31,10 @@ use rustc_span::Symbol;
 pub fn finalize(cx: &CodegenCx<'_, '_>) {
     let tcx = cx.tcx;
 
-    // Ensure the installed version of LLVM supports Coverage Map Version 6
-    // (encoded as a zero-based value: 5), which was introduced with LLVM 13.
+    // Ensure the installed version of LLVM supports Coverage Map Version 7
+    // (encoded as a zero-based value: 6), which was introduced with LLVM 13.
     let version = coverageinfo::mapping_version();
-    assert_eq!(version, 5, "The `CoverageMappingVersion` exposed by `llvm-wrapper` is out of sync");
+    assert_eq!(version, 6, "The `CoverageMappingVersion` exposed by `llvm-wrapper` is out of sync");
 
     debug!("Generating coverage map for CodegenUnit: `{}`", cx.codegen_unit.name());
 
@@ -276,6 +276,7 @@ fn encode_mappings_for_function(
 /// Construct coverage map header and the array of function records, and combine them into the
 /// coverage map. Save the coverage map data into the LLVM IR as a static global using a
 /// specific, well-known section and name.
+/// https://llvm.org/docs/CoverageMappingFormat.html#llvm-ir-representation
 fn generate_coverage_map<'ll>(
     cx: &CodegenCx<'ll, '_>,
     version: u32,