Refactor MIR coverage instrumentation

Lays a better foundation for injecting more counters in each function.

Author: richkadel

src/librustc_codegen_llvm/coverageinfo/mapgen.rs

@@ -24,7 +24,7 @@ use std::ffi::CString;
 /// replicated for Rust's Coverage Map.
 pub fn finalize<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) {
     let function_coverage_map = cx.coverage_context().take_function_coverage_map();
-    if function_coverage_map.len() == 0 {
+    if function_coverage_map.is_empty() {
         // This module has no functions with coverage instrumentation
         return;
     }
@@ -81,7 +81,7 @@ struct CoverageMapGenerator {
 
 impl CoverageMapGenerator {
     fn new() -> Self {
-        Self { filenames: Vec::new(), filename_to_index: FxHashMap::<CString, u32>::default() }
+        Self { filenames: Vec::new(), filename_to_index: FxHashMap::default() }
     }
 
     /// Using the `expressions` and `counter_regions` collected for the current function, generate
@@ -95,7 +95,7 @@ impl CoverageMapGenerator {
         coverage_mappings_buffer: &RustString,
     ) {
         let mut counter_regions = counter_regions.collect::<Vec<_>>();
-        if counter_regions.len() == 0 {
+        if counter_regions.is_empty() {
             return;
         }
 
@@ -109,7 +109,7 @@ impl CoverageMapGenerator {
         // `file_id` (indexing files referenced by the current function), and construct the
         // function-specific `virtual_file_mapping` from `file_id` to its index in the module's
         // `filenames` array.
-        counter_regions.sort_by_key(|(_counter, region)| *region);
+        counter_regions.sort_unstable_by_key(|(_counter, region)| *region);
         for (counter, region) in counter_regions {
             let (file_path, start_line, start_col, end_line, end_col) = region.file_start_and_end();
             let same_file = current_file_path.as_ref().map_or(false, |p| p == file_path);

src/librustc_codegen_llvm/coverageinfo/mod.rs

@@ -110,36 +110,37 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     }
 }
 
-/// Aligns to C++ struct llvm::coverage::Counter::CounterKind.
-/// The order of discrimiators is important.
+/// Aligns with [llvm::coverage::CounterMappingRegion::RegionKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L205-L221)
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 enum RegionKind {
     /// A CodeRegion associates some code with a counter
-    CodeRegion,
+    CodeRegion = 0,
 
     /// An ExpansionRegion represents a file expansion region that associates
     /// a source range with the expansion of a virtual source file, such as
     /// for a macro instantiation or #include file.
-    ExpansionRegion,
+    ExpansionRegion = 1,
 
     /// A SkippedRegion represents a source range with code that was skipped
     /// by a preprocessor or similar means.
-    SkippedRegion,
+    SkippedRegion = 2,
 
     /// A GapRegion is like a CodeRegion, but its count is only set as the
     /// line execution count when its the only region in the line.
-    GapRegion,
+    GapRegion = 3,
 }
 
 /// This struct provides LLVM's representation of a "CoverageMappingRegion", encoded into the
-/// coverage map in accordance with LLVM's "Coverage Mapping Format". The struct composes fields
-/// representing the `Counter` type and value(s) (injected counter ID, or expression type and
-/// operands), the source file (an indirect index into a "filenames array", encoded separately),
-/// and source location (start and end positions of the represented code region).
+/// coverage map, in accordance with the
+/// [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format).
+/// The struct composes fields representing the `Counter` type and value(s) (injected counter ID,
+/// or expression type and operands), the source file (an indirect index into a "filenames array",
+/// encoded separately), and source location (start and end positions of the represented code
+/// region).
 ///
-/// Aligns to C++ struct llvm::coverage::CounterMappingRegion.
-/// The order of fields is important.
+/// Aligns with [llvm::coverage::CounterMappingRegion](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L223-L226)
+/// Important: The Rust struct layout (order and types of fields) must match its C++ counterpart.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct CounterMappingRegion {

src/librustc_codegen_ssa/coverageinfo/map.rs

@@ -7,26 +7,28 @@ use std::cmp::{Ord, Ordering};
 use std::fmt;
 use std::path::PathBuf;
 
-/// Aligns to C++ struct llvm::coverage::Counter::CounterKind.
-/// The order of discriminators is important.
+/// Aligns with [llvm::coverage::Counter::CounterKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L91)
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 enum CounterKind {
-    Zero,
-    CounterValueReference,
-    Expression,
+    Zero = 0,
+    CounterValueReference = 1,
+    Expression = 2,
 }
 
-/// Aligns to C++ struct llvm::coverage::Counter. Note that `id` has
-/// different interpretations, depending on the `kind`:
+/// A reference to an instance of an abstract "counter" that will yield a value in a coverage
+/// report. Note that `id` has different interpretations, depending on the `kind`:
 ///   * For `CounterKind::Zero`, `id` is assumed to be `0`
 ///   * For `CounterKind::CounterValueReference`,  `id` matches the `counter_id` of the injected
 ///     instrumentation counter (the `index` argument to the LLVM intrinsic `instrprof.increment()`)
-///   * For `CounterKind::Expression`, `id` is the index into the array of counter expressions.
-/// The order of fields is important.
+///   * For `CounterKind::Expression`, `id` is the index into the coverage map's array of counter
+///     expressions.
+/// Aligns with [llvm::coverage::Counter](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L98-L99)
+/// Important: The Rust struct layout (order and types of fields) must match its C++ counterpart.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct Counter {
+    // Important: The layout (order and types of fields) must match its C++ counterpart.
     kind: CounterKind,
     id: u32,
 }
@@ -45,21 +47,19 @@ impl Counter {
     }
 }
 
-/// Aligns to C++ struct llvm::coverage::CounterExpression::ExprKind.
-/// The order of discriminators is important.
+/// Aligns with [llvm::coverage::CounterExpression::ExprKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L146)
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub enum ExprKind {
-    Subtract,
-    Add,
+    Subtract = 0,
+    Add = 1,
 }
 
-/// Aligns to C++ struct llvm::coverage::CounterExpression.
-/// The order of fields is important.
+/// Aligns with [llvm::coverage::CounterExpression](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L147-L148)
+/// Important: The Rust struct layout (order and types of fields) must match its C++ counterpart.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct CounterExpression {
-    // Note the field order is important.
     kind: ExprKind,
     lhs: Counter,
     rhs: Counter,