Added codegen_llvm/coverageinfo mod for upcoming coverage map

Author: richkadel

src/librustc_codegen_llvm/base.rs

@@ -150,6 +150,11 @@ pub fn compile_codegen_unit(
                 cx.create_used_variable()
             }
 
+            // Finalize code coverage by injecting the coverage map
+            if cx.sess().opts.debugging_opts.instrument_coverage {
+                cx.coverageinfo_finalize();
+            }
+
             // Finalize debuginfo
             if cx.sess().opts.debuginfo != DebugInfo::None {
                 cx.debuginfo_finalize();

src/librustc_codegen_llvm/coverageinfo/mod.rs

@@ -0,0 +1,60 @@
+use crate::common::CodegenCx;
+use log::debug;
+use rustc_codegen_ssa::traits::CoverageInfoMethods;
+use rustc_hir::def_id::LOCAL_CRATE;
+
+// FIXME(richkadel): This might not be where I put the coverage map generation, but it's a
+// placeholder for now.
+//
+// I need to inject the coverage map into the LLVM IR. This is one possible place to do it.
+//
+// The code below is here, at least temporarily, to verify that the `CoverageRegion`s are
+// available, to produce the coverage map.
+
+/// Generates and exports the Coverage Map.
+pub fn finalize(cx: &CodegenCx<'_, '_>) {
+    let instances = &*cx.instances.borrow();
+    for instance in instances.keys() {
+        if instance.def_id().krate == LOCAL_CRATE {
+            // FIXME(richkadel): Is this check `krate == LOCAL_CRATE` right?
+            //
+            // NOTE: I'm considering at least one alternative to this loop on `instances`,
+            // But if I do go with this, make sure the check on LOCAL_CRATE works for all cases.
+            //
+            //
+            // Without it, I was crashing on some of the instances, with:
+            //
+            //     src/librustc_metadata/rmeta/decoder.rs:1127:17: get_optimized_mir: missing MIR for `DefId(1:2867 ~ std[70cc]::io[0]::stdio[0]::_print[0])`
+            //
+            // This check avoids it, but still works for the very limited testing I've done so far.
+            let coverageinfo = cx.tcx.coverageinfo(instance.def_id());
+            if coverageinfo.num_counters > 0 {
+                debug!(
+                    "Generate coverage map for: {}, hash: {:?}, num_counters: {}\n{}",
+                    instance,
+                    coverageinfo.hash,
+                    coverageinfo.num_counters,
+                    {
+                        let regions = &coverageinfo.coverage_regions;
+                        (0..regions.len() as u32)
+                            .map(|counter_index| {
+                                let region = &regions[counter_index];
+                                format!(
+                                    "  counter_index {} byte range: {}..{}",
+                                    counter_index, region.start_byte_pos, region.end_byte_pos
+                                )
+                            })
+                            .collect::<Vec<String>>()
+                            .join("\n")
+                    }
+                );
+            }
+        }
+    }
+}
+
+impl CoverageInfoMethods for CodegenCx<'ll, 'tcx> {
+    fn coverageinfo_finalize(&self) {
+        finalize(self)
+    }
+}

src/librustc_codegen_llvm/intrinsic.rs

@@ -19,6 +19,7 @@ use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::MemFlags;
 use rustc_hir as hir;
+use rustc_middle::mir::coverage;
 use rustc_middle::ty::layout::{FnAbiExt, HasTyCtxt};
 use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, span_bug};
@@ -140,27 +141,24 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 self.call(llfn, &[], None)
             }
             "count_code_region" => {
-                use rustc_middle::mir::count_code_region_args::{
-                    COUNTER_INDEX, END_BYTE_POS, START_BYTE_POS,
-                };
+                use coverage::count_code_region_args::*;
                 // FIXME(richkadel): The current implementation assumes the MIR for the given
                 // caller_instance represents a single function. Validate and/or correct if inlining
                 // and/or monomorphization invalidates these assumptions.
-                let coverage_data = tcx.coverage_data(caller_instance.def_id());
+                let coverageinfo = tcx.coverageinfo(caller_instance.def_id());
                 let mangled_fn = tcx.symbol_name(caller_instance);
                 let (mangled_fn_name, _len_val) = self.const_str(mangled_fn.name);
-                let hash = self.const_u64(coverage_data.hash);
-                let num_counters = self.const_u32(coverage_data.num_counters);
+                let hash = self.const_u64(coverageinfo.hash);
+                let num_counters = self.const_u32(coverageinfo.num_counters);
                 let index = args[COUNTER_INDEX].immediate();
                 debug!(
-                    "count_code_region to LLVM intrinsic instrprof.increment(fn_name={}, hash={:?}, num_counters={:?}, index={:?}), byte range {:?}..{:?}, coverage_regions: {:?}",
+                    "count_code_region to LLVM intrinsic instrprof.increment(fn_name={}, hash={:?}, num_counters={:?}, index={:?}), byte range {:?}..{:?}",
                     mangled_fn.name,
                     hash,
                     num_counters,
                     index,
                     args[START_BYTE_POS].immediate(),
                     args[END_BYTE_POS].immediate(),
-                    coverage_data.coverage_regions,
                 );
                 self.instrprof_increment(mangled_fn_name, hash, num_counters, index)
             }

src/librustc_codegen_llvm/lib.rs

@@ -55,6 +55,7 @@ mod callee;
 mod common;
 mod consts;
 mod context;
+mod coverageinfo;
 mod debuginfo;
 mod declare;
 mod intrinsic;

src/librustc_codegen_ssa/traits/coverageinfo.rs

@@ -0,0 +1,5 @@
+use super::BackendTypes;
+
+pub trait CoverageInfoMethods: BackendTypes {
+    fn coverageinfo_finalize(&self);
+}

src/librustc_codegen_ssa/traits/mod.rs

@@ -19,6 +19,7 @@ mod asm;
 mod backend;
 mod builder;
 mod consts;
+mod coverageinfo;
 mod debuginfo;
 mod declare;
 mod intrinsic;
@@ -32,6 +33,7 @@ pub use self::asm::{AsmBuilderMethods, AsmMethods, InlineAsmOperandRef};
 pub use self::backend::{Backend, BackendTypes, CodegenBackend, ExtraBackendMethods};
 pub use self::builder::{BuilderMethods, OverflowOp};
 pub use self::consts::ConstMethods;
+pub use self::coverageinfo::CoverageInfoMethods;
 pub use self::debuginfo::{DebugInfoBuilderMethods, DebugInfoMethods};
 pub use self::declare::{DeclareMethods, PreDefineMethods};
 pub use self::intrinsic::IntrinsicCallMethods;
@@ -56,6 +58,7 @@ pub trait CodegenMethods<'tcx>:
     + MiscMethods<'tcx>
     + ConstMethods<'tcx>
     + StaticMethods
+    + CoverageInfoMethods
     + DebugInfoMethods<'tcx>
     + DeclareMethods<'tcx>
     + AsmMethods
@@ -72,6 +75,7 @@ impl<'tcx, T> CodegenMethods<'tcx> for T where
         + MiscMethods<'tcx>
         + ConstMethods<'tcx>
         + StaticMethods
+        + CoverageInfoMethods
         + DebugInfoMethods<'tcx>
         + DeclareMethods<'tcx>
         + AsmMethods

src/librustc_middle/arena.rs

@@ -94,7 +94,7 @@ macro_rules! arena_types {
             [] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>, rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>;
             [] object_safety_violations: rustc_middle::traits::ObjectSafetyViolation, rustc_middle::traits::ObjectSafetyViolation;
             [] codegen_unit: rustc_middle::mir::mono::CodegenUnit<$tcx>, rustc_middle::mir::mono::CodegenUnit<'_x>;
-            [] coverage_data: rustc_middle::mir::CoverageData, rustc_middle::mir::CoverageData;
+            [] coverageinfo: rustc_middle::mir::coverage::CoverageInfo, rustc_middle::mir::coverage::CoverageInfo;
             [] attribute: rustc_ast::ast::Attribute, rustc_ast::ast::Attribute;
             [] name_set: rustc_data_structures::fx::FxHashSet<rustc_span::symbol::Symbol>, rustc_data_structures::fx::FxHashSet<rustc_span::symbol::Symbol>;
             [] hir_id_set: rustc_hir::HirIdSet, rustc_hir::HirIdSet;

src/librustc_middle/mir/coverage/mod.rs

@@ -0,0 +1,40 @@
+//! Metadata from source code coverage analysis and instrumentation.
+
+use rustc_index::vec::IndexVec;
+
+/// Coverage information associated with each function (MIR) instrumented with coverage counters, when
+/// compiled with `-Zinstrument_coverage`. The query `tcx.coverageinfo(DefId)` computes these
+/// values on demand (during code generation). This query is only valid after executing the MIR pass
+/// `InstrumentCoverage`.
+#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
+pub struct CoverageInfo {
+    /// A hash value that can be used by the consumer of the coverage profile data to detect
+    /// changes to the instrumented source of the associated MIR body (typically, for an
+    /// individual function).
+    pub hash: u64,
+
+    /// The total number of coverage region counters added to the MIR `Body`.
+    pub num_counters: u32,
+
+    /// The start and end positions within a source file for the region of source code counted by
+    /// the given counter index.
+    pub coverage_regions: IndexVec<u32, CoverageRegion>,
+}
+
+/// Defines the region, within the source code, where a counter is optionally injected (if compiled
+/// with `-Zinstrument_coverage`), to count the number of times this code region is executed.
+#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
+pub struct CoverageRegion {
+    /// The code region's starting position within the source code file.
+    pub start_byte_pos: u32,
+
+    /// The code region's ending position within the source code file.
+    pub end_byte_pos: u32,
+}
+
+/// Positional arguments to `libcore::count_code_region()`
+pub mod count_code_region_args {
+    pub const COUNTER_INDEX: usize = 0;
+    pub const START_BYTE_POS: usize = 1;
+    pub const END_BYTE_POS: usize = 2;
+}

src/librustc_middle/mir/mod.rs

@@ -42,6 +42,7 @@ use std::{iter, mem, option};
 use self::predecessors::{PredecessorCache, Predecessors};
 pub use self::query::*;
 
+pub mod coverage;
 pub mod interpret;
 pub mod mono;
 mod predecessors;
@@ -2993,44 +2994,3 @@ impl Location {
         }
     }
 }
-
-///////////////////////////////////////////////////////////////////////////
-// Source code coverage
-
-/// Coverage data associated with each function (MIR) instrumented with coverage counters, when
-/// compiled with `-Zinstrument_coverage`. The query `tcx.coverage_data(DefId)` computes these
-/// values on demand (during code generation). This query is only valid after executing the MIR pass
-/// `InstrumentCoverage`.
-#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
-pub struct CoverageRegion {
-    /// The code region's starting position within the source code file.
-    pub start_byte_pos: u32,
-
-    /// The code region's ending position within the source code file.
-    pub end_byte_pos: u32,
-}
-
-/// Coverage data associated with each function (MIR) instrumented with coverage counters, when
-/// compiled with `-Zinstrument_coverage`. The query `tcx.coverage_data(DefId)` computes these
-/// values on demand (during code generation). This query is only valid after executing the MIR pass
-/// `InstrumentCoverage`.
-#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
-pub struct CoverageData {
-    /// A hash value that can be used by the consumer of the coverage profile data to detect
-    /// changes to the instrumented source of the associated MIR body (typically, for an
-    /// individual function).
-    pub hash: u64,
-
-    /// The total number of coverage region counters added to the MIR `Body`.
-    pub num_counters: u32,
-
-    /// The start and end positions within a source file for the region of source code counted by
-    /// the given counter index.
-    pub coverage_regions: IndexVec<u32, CoverageRegion>,
-}
-
-pub mod count_code_region_args {
-    pub const COUNTER_INDEX: usize = 0;
-    pub const START_BYTE_POS: usize = 1;
-    pub const END_BYTE_POS: usize = 2;
-}

src/librustc_middle/query/mod.rs

@@ -231,8 +231,8 @@ rustc_queries! {
             cache_on_disk_if { key.is_local() }
         }
 
-        query coverage_data(key: DefId) -> &'tcx mir::CoverageData {
-            desc { |tcx| "retrieving coverage data from MIR for `{}`", tcx.def_path_str(key) }
+        query coverageinfo(key: DefId) -> &'tcx mir::coverage::CoverageInfo {
+            desc { |tcx| "retrieving coverageinfo from MIR for `{}`", tcx.def_path_str(key) }
             storage(ArenaCacheSelector<'tcx>)
             cache_on_disk_if { key.is_local() }
         }