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() }
         }

src/librustc_mir/transform/inline.rs

@@ -40,10 +40,10 @@ impl<'tcx> MirPass<'tcx> for Inline {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, source: MirSource<'tcx>, body: &mut Body<'tcx>) {
         if tcx.sess.opts.debugging_opts.mir_opt_level >= 2 {
             if tcx.sess.opts.debugging_opts.instrument_coverage {
+                // The current implementation of source code coverage injects code region counters
+                // into the MIR, and assumes a 1-to-1 correspondence between MIR and source-code-
+                // based function.
                 debug!("function inlining is disabled when compiling with `instrument_coverage`");
-            // The current implementation of source code coverage injects code region counters
-            // into the MIR, and assumes a 1-to-1 correspondence between MIR and source-code-
-            // based function.
             } else {
                 Inliner { tcx, source }.run_pass(body);
             }

src/librustc_mir/transform/instrument_coverage.rs

@@ -6,10 +6,12 @@ use rustc_hir::lang_items;
 use rustc_index::vec::IndexVec;
 use rustc_middle::hir;
 use rustc_middle::ich::StableHashingContext;
+use rustc_middle::mir::coverage::count_code_region_args::*;
+use rustc_middle::mir::coverage::{CoverageInfo, CoverageRegion};
 use rustc_middle::mir::interpret::{ConstValue, InterpResult, Scalar};
 use rustc_middle::mir::{
-    self, traversal, BasicBlock, BasicBlockData, CoverageData, CoverageRegion, Operand, Place,
-    SourceInfo, StatementKind, Terminator, TerminatorKind, START_BLOCK,
+    self, traversal, BasicBlock, BasicBlockData, Operand, Place, SourceInfo, StatementKind,
+    Terminator, TerminatorKind, START_BLOCK,
 };
 use rustc_middle::ty;
 use rustc_middle::ty::query::Providers;
@@ -18,19 +20,17 @@ use rustc_middle::ty::{ConstKind, FnDef};
 use rustc_span::def_id::DefId;
 use rustc_span::{Pos, Span};
 
-use rustc_middle::mir::count_code_region_args::{COUNTER_INDEX, END_BYTE_POS, START_BYTE_POS};
-
 /// Inserts call to count_code_region() as a placeholder to be replaced during code generation with
 /// the intrinsic llvm.instrprof.increment.
 pub struct InstrumentCoverage;
 
-/// The `query` provider for `CoverageData`, requested by `codegen_intrinsic_call()` when
+/// The `query` provider for `CoverageInfo`, requested by `codegen_intrinsic_call()` when
 /// constructing the arguments for `llvm.instrprof.increment`.
 pub(crate) fn provide(providers: &mut Providers<'_>) {
-    providers.coverage_data = |tcx, def_id| coverage_data_from_mir(tcx, def_id);
+    providers.coverageinfo = |tcx, def_id| coverageinfo_from_mir(tcx, def_id);
 }
 
-fn coverage_data_from_mir<'tcx>(tcx: TyCtxt<'tcx>, mir_def_id: DefId) -> &'tcx CoverageData {
+fn coverageinfo_from_mir<'tcx>(tcx: TyCtxt<'tcx>, mir_def_id: DefId) -> &'tcx CoverageInfo {
     let mir_body = tcx.optimized_mir(mir_def_id);
     // FIXME(richkadel): The current implementation assumes the MIR for the given DefId
     // represents a single function. Validate and/or correct if inlining and/or monomorphization
@@ -44,7 +44,6 @@ fn coverage_data_from_mir<'tcx>(tcx: TyCtxt<'tcx>, mir_def_id: DefId) -> &'tcx C
     // instrumented function) is valid.
     let mut indexed_regions = vec![];
     let mut num_counters: u32 = 0;
-    //for terminator in count_code_region_terminators(tcx, mir_body) {
     for terminator in traversal::preorder(mir_body)
         .map(|(_, data)| (data, count_code_region_fn))
         .filter_map(count_code_region_terminator_filter)
@@ -77,7 +76,7 @@ fn coverage_data_from_mir<'tcx>(tcx: TyCtxt<'tcx>, mir_def_id: DefId) -> &'tcx C
     for (index, region) in indexed_regions {
         coverage_regions[index] = region;
     }
-    tcx.arena.alloc(CoverageData { num_counters, hash, coverage_regions })
+    tcx.arena.alloc(CoverageInfo { num_counters, hash, coverage_regions })
 }
 
 fn count_code_region_terminator_filter(
@@ -95,18 +94,18 @@ fn count_code_region_terminator_filter(
     None
 }
 
-fn arg<T, F>(to_val: F, args: &Vec<Operand<'tcx>>, pos: usize) -> T
+fn arg<T, F>(to_val: F, args: &Vec<Operand<'tcx>>, arg_index: usize) -> T
 where
     F: FnOnce(Scalar) -> InterpResult<'static, T>,
 {
-    match args.get(pos).unwrap_or_else(|| bug!("count_code_region arg{} not found", pos)) {
+    match args.get(arg_index).unwrap_or_else(|| bug!("arg{} not found", arg_index)) {
         Operand::Constant(constant) => match constant.literal.val {
             ConstKind::Value(ConstValue::Scalar(scalar)) => to_val(scalar).unwrap_or_else(|err| {
-                bug!("count_code_region arg{}, {:?}: {:?}", pos, scalar, err);
+                bug!("count_code_region arg{}, {:?}: {:?}", arg_index, scalar, err);
             }),
-            _ => bug!("count_code_region arg{}: ConstKind::Value expected", pos),
+            _ => bug!("count_code_region arg{}: ConstKind::Value expected", arg_index),
         },
-        _ => bug!("count_code_region arg{}: Operand::Constant expected", pos),
+        _ => bug!("count_code_region arg{}: Operand::Constant expected", arg_index),
     }
 }
 
@@ -178,13 +177,13 @@ impl<'tcx> Instrumentor<'tcx> {
 
         let mut args = Vec::new();
 
-        assert_eq!(COUNTER_INDEX, args.len());
+        debug_assert_eq!(COUNTER_INDEX, args.len());
         args.push(self.const_u32(index, injection_point));
 
-        assert_eq!(START_BYTE_POS, args.len());
+        debug_assert_eq!(START_BYTE_POS, args.len());
         args.push(self.const_u32(code_region.lo().to_u32(), injection_point));
 
-        assert_eq!(END_BYTE_POS, args.len());
+        debug_assert_eq!(END_BYTE_POS, args.len());
         args.push(self.const_u32(code_region.hi().to_u32(), injection_point));
 
         let mut patch = MirPatch::new(mir_body);