WIP - Add LLVM coverage instrumentation

#34701

Prototype coverage implementation with partial support for the various
branch types to be covered.

    cargo -vv rustc -- -Z instrument-coverage

With the `-Z instrument-coverage` flag, the compiler injects calls to a
new std::coverage module, adding counters at various points in the code.

At the end of the compile, a list of coverage regions (`Span`s) and
corresponding coverage retion IDs are printed to stdout.

When executing the program, the counters increment statically, and upon
normal exit, the counters are printed to stdout with the same
corresponding coverage region IDs.

The stdout results will be replaced by output files in a format
compatible with LLVM coverage reports.

Currently counts the following coverage regions:
    * All blocks ending in a semicolon or expression
    * break, return, and yield statements, with or without a value
      expression
    * continue statment

Not yet supported are:
    * match pattern arms without a block
    * closures without a block
    * expressions ending in '?' (that return on Result::Err)
    * lazy boolean right-hand-side expressions that may not be invoked

Author: richkadel

Cargo.lock

@@ -3622,6 +3622,7 @@ dependencies = [
  "rustc_ast",
  "rustc_resolve",
  "rustc_span",
+ "smallvec 1.0.0",
 ]
 
 [[package]]

src/librustc_ast_lowering/lib.rs

@@ -40,7 +40,6 @@ use rustc_ast::ast;
 use rustc_ast::ast::*;
 use rustc_ast::attr;
 use rustc_ast::node_id::NodeMap;
-use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Nonterminal, Token};
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::visit::{self, AssocCtxt, Visitor};
@@ -70,7 +69,6 @@ use log::{debug, trace};
 use smallvec::{smallvec, SmallVec};
 use std::collections::BTreeMap;
 use std::mem;
-use std::sync::Mutex;
 
 macro_rules! arena_vec {
     ($this:expr; $($x:expr),*) => ({
@@ -173,9 +171,6 @@ struct LoweringContext<'a, 'hir: 'a> {
 
     allow_try_trait: Option<Lrc<[Symbol]>>,
     allow_gen_future: Option<Lrc<[Symbol]>>,
-
-    /// `true` if `rustc` was invoked with an option to inject code coverage instrumentation.
-    is_instrumenting_for_coverage: bool,
 }
 
 pub trait Resolver {
@@ -305,7 +300,6 @@ pub fn lower_crate<'a, 'hir>(
         in_scope_lifetimes: Vec::new(),
         allow_try_trait: Some([sym::try_trait][..].into()),
         allow_gen_future: Some([sym::gen_future][..].into()),
-        is_instrumenting_for_coverage: false,
     }
     .lower_crate(krate)
 }
@@ -400,148 +394,6 @@ impl Visitor<'_> for ImplTraitTypeIdVisitor<'_> {
     }
 }
 
-struct CoverageRegion {
-    region: Span,
-    counter_hash: u128,
-}
-
-static mut COVERAGE_REGIONS: Option<Mutex<Vec<CoverageRegion>>> = None;
-
-impl CoverageRegion {
-
-    /// Generates a unique coverage region identifier to associate with
-    /// a counter. The counter increment statement is injected into the
-    /// code at the start of a coverage region.
-    // TODO(richkadel): This function will need additional arguments and/or context
-    // data from which to generate the hash values.
-    fn generate_hash(region: &Span) -> u128 {
-        // THIS IS NOT THREAD SAFE, BUT WILL BE REPLACED WITH HASH FUNCTION ANYWAY.
-        // Seems like lazy_static is not used in the compiler at all.
-        static mut NEXT_COUNTER_ID: Option<Mutex<u128>> = None;
-        let counter_hash = {
-            let counter_id = unsafe {
-                &match NEXT_COUNTER_ID.as_ref() {
-                    Some(counter_id) => counter_id,
-                    None => {
-                        NEXT_COUNTER_ID = Some(Mutex::new(0));
-                        NEXT_COUNTER_ID.as_ref().unwrap()
-                    }
-                }
-            };
-            let mut locked_counter_id = counter_id.lock().unwrap();
-            *locked_counter_id += 1;
-            *locked_counter_id
-        };
-
-        let coverage_regions = unsafe {
-            &match COVERAGE_REGIONS.as_ref() {
-                Some(coverage_regions) => coverage_regions,
-                None => {
-                    COVERAGE_REGIONS = Some(Mutex::new(vec![]));
-                    COVERAGE_REGIONS.as_ref().unwrap()
-                }
-            }
-        };
-        let mut locked_coverage_regions = coverage_regions.lock().unwrap();
-        locked_coverage_regions.push(CoverageRegion {
-            region: region.clone(),
-            counter_hash,
-        });
-
-        // return the counter hash value
-        counter_hash
-    }
-
-    pub fn write_coverage_regions(/* filename param? */) {
-        unsafe {
-            if let Some(coverage_regions) = COVERAGE_REGIONS.as_ref() {
-                let locked_coverage_regions = coverage_regions.lock().unwrap();
-                for coverage in locked_coverage_regions.iter() {
-                    println!("{}: {:?}", coverage.counter_hash, coverage.region);
-                }
-            }
-        }
-    }
-}
-
-struct CoverageInjector<'tcx, 'lowering, 'hir> {
-    lctx: &'tcx mut LoweringContext<'lowering, 'hir>,
-    span: Span,
-}
-
-impl<'tcx, 'lowering, 'hir> CoverageInjector<'tcx, 'lowering, 'hir> {
-    fn at(lctx: &'tcx mut LoweringContext<'lowering, 'hir>, before: &Span) -> CoverageInjector<'tcx, 'lowering, 'hir> {
-        CoverageInjector {
-            lctx,
-            span: before.shrink_to_lo(),
-        }
-    }
-
-    fn next_ast_node_id(&mut self) -> NodeId {
-        self.lctx.resolver.next_node_id()
-    }
-
-    fn span(&self) -> Span {
-        self.span.clone()
-    }
-
-    fn expr(&mut self, kind: ExprKind) -> P<Expr> {
-        P(Expr {
-            kind,
-            span: self.span(),
-            attrs: AttrVec::new(),
-            id: self.next_ast_node_id(),
-        })
-    }
-
-    fn path_segment(&mut self, string: &str) -> PathSegment {
-        PathSegment {
-            ident: Ident::from_str_and_span(string, self.span()),
-            id: self.next_ast_node_id(),
-            args: None,
-        }
-    }
-
-    fn coverage_count_fn_path(&mut self) -> P<Expr> {
-        let path = Path {
-            span: self.span(),
-            segments: vec![
-                self.path_segment("coverage"),
-                self.path_segment("count"),
-            ],
-        };
-        self.expr(ExprKind::Path(None, path))
-    }
-
-    fn coverage_counter_hash_lit(&mut self, counter_hash: u128) -> P<Expr> {
-        let token = token::Lit::new(token::Integer, sym::integer(counter_hash), /*suffix=*/None);
-        let kind = LitKind::Int(
-            counter_hash, 
-            LitIntType::Unsigned(UintTy::U128), // TODO: this should not be necessary (should be "Unsuffixed" per JSON)
-        );
-        let lit = Lit { token, kind, span: self.span() };
-        self.expr(ExprKind::Lit(lit))
-    }
-
-    fn call(&mut self, fn_path: P<Expr>, args: Vec<P<Expr>>) -> P<Expr> {
-        self.expr(ExprKind::Call(fn_path, args))
-    }
-
-    fn counter_stmt(&mut self, coverage_span: &Span) -> Stmt {
-        let counter_hash = CoverageRegion::generate_hash(coverage_span);
-        let coverage_count_fn = self.coverage_count_fn_path();
-        let args = vec![ self.coverage_counter_hash_lit(counter_hash) ];
-        let call = self.call(coverage_count_fn, args);
-
-        Stmt {
-            id: self.next_ast_node_id(),
-            span: self.span(),
-            kind: StmtKind::Semi(call)
-        }
-    }
-}
-
-
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_crate(mut self, c: &Crate) -> hir::Crate<'hir> {
         /// Full-crate AST visitor that inserts into a fresh
@@ -669,21 +521,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
         }
 
-        self.is_instrumenting_for_coverage = match self.sess.opts.debugging_opts.instrument_coverage {
-            Some(opt) => opt,
-            None => false,
-        };
-
         self.lower_node_id(CRATE_NODE_ID);
         debug_assert!(self.node_id_to_hir_id[CRATE_NODE_ID] == hir::CRATE_HIR_ID);
 
         visit::walk_crate(&mut MiscCollector { lctx: &mut self, hir_id_owner: None }, c);
         visit::walk_crate(&mut item::ItemLowerer { lctx: &mut self }, c);
 
-        if self.is_instrumenting_for_coverage {
-            CoverageRegion::write_coverage_regions();
-        }
-
         let module = self.lower_mod(&c.module);
         let attrs = self.lower_attrs(&c.attrs);
         let body_ids = body_ids(&self.bodies);
@@ -2365,33 +2208,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let mut stmts = vec![];
         let mut expr: Option<&'hir _> = None;
 
-        // THIS COVERAGE CODE MAY NEED TO BE IN A DIFFERENT LOCATION? BUT SEEMS LIKE IT SHOULD
-        // WORK FOR BASIC BLOCKS THAT DON'T `break`, `continue`, or `return` in any nested
-        // branches. For those, we need to add additional counters beyond the code that might be
-        // skipped.
-        if self.is_instrumenting_for_coverage && ! b.stmts.is_empty() {
-            let inject_site = &b.stmts[0].span;
-            let mut coverage_injector = CoverageInjector::at(self, inject_site);
-            let counter_stmt = coverage_injector.counter_stmt(&b.span);
-            stmts.extend(self.lower_stmt(&counter_stmt));
-            // TODO(richkadel): The span should stop at the first occurrence of an early return
-            // (if any), and if there is one, a new counter should be inserted just after the branch
-            // that ended in the early return, and a new span should start from just after that
-            // injected counter, and ending at the end of the block, or at another early return if
-            // there is another.
-
-            // ALSO! There are language constructs that have statement spans that don't require
-            // braces if only one statement, in which case, they PROBABLY don't hit "Block", and
-            // therefore, I need to insert the counters in other parts of the AST as well, while
-            // also virtually inserting the curly braces:
-            //   * closures: |...| stmt  ->   |...| { coverage::counter(n); stmt }
-            //   * match arms: match variant { pat => stmt,  -> match variant { pat => coverage::counter(n); stmt }
-            // any others?
-
-            // There may be existing checks of similar types. See for instance "targeted_by_break"
-            // in this file.
-        }
-
         for (index, stmt) in b.stmts.iter().enumerate() {
             if index == b.stmts.len() - 1 {
                 if let StmtKind::Expr(ref e) = stmt.kind {

src/librustc_coverage/Cargo.toml

@@ -13,4 +13,5 @@ log = "0.4"
 rustc = { path = "../librustc" }
 rustc_resolve = { path = "../librustc_resolve" }
 rustc_ast = { path = "../librustc_ast" }
-rustc_span = { path = "../librustc_span" }
+rustc_span = { path = "../librustc_span" }
+smallvec = { version = "1.0", features = ["union", "may_dangle"] }

src/librustc_coverage/coverage.rs

@@ -2,4 +2,4 @@
 #![feature(nll)]
 #![recursion_limit = "256"]
 
-pub mod coverage;
+pub mod coverage;

src/librustc_coverage/lib.rs

@@ -46,7 +46,6 @@ use rustc_session::{early_error, early_warn};
 use rustc_span::source_map::{FileLoader, FileName};
 use rustc_span::symbol::sym;
 
-use log::debug;
 use std::borrow::Cow;
 use std::cmp::max;
 use std::default::Default;
@@ -338,9 +337,7 @@ pub fn run_compiler(
                 }
             }
 
-            debug!("before death");
             queries.expansion()?;
-            debug!("AFTER DEATH (we don't get here?)");
             if callbacks.after_expansion(compiler, queries) == Compilation::Stop {
                 return early_exit();
             }

src/librustc_driver/lib.rs

@@ -15,6 +15,7 @@ use rustc_ast::mut_visit::MutVisitor;
 use rustc_ast::{self, ast, visit};
 use rustc_codegen_ssa::back::link::emit_metadata;
 use rustc_codegen_ssa::traits::CodegenBackend;
+use rustc_coverage::coverage;
 use rustc_data_structures::sync::{par_iter, Lrc, Once, ParallelIterator, WorkerLocal};
 use rustc_data_structures::{box_region_allow_access, declare_box_region_type, parallel};
 use rustc_errors::PResult;
@@ -93,8 +94,8 @@ declare_box_region_type!(
 
 /// Runs the "early phases" of the compiler: initial `cfg` processing, loading compiler plugins,
 /// syntax expansion, secondary `cfg` expansion, synthesis of a test
-/// harness if one is to be provided, injection of a dependency on the
-/// standard library and prelude, and name resolution.
+/// harness if one is to be provided, and injection of a dependency on the
+/// standard library and prelude.
 ///
 /// Returns `None` if we're aborting after handling -W help.
 pub fn configure_and_expand(
@@ -137,6 +138,43 @@ pub fn configure_and_expand(
     result.map(|k| (k, resolver))
 }
 
+/// If enabled by command line option, this pass injects coverage statements into the AST to
+/// increment region counters and generate a coverage report at program exit.
+/// The AST Crate cannot be resolved until after the AST is instrumented.
+pub fn instrument(krate: ast::Crate, resolver: &mut Resolver<'_>) -> Result<ast::Crate> {
+    coverage::instrument(krate, resolver)
+}
+
+/// Performs name resolution on the expanded and optionally instrumented crate.
+pub fn resolve_crate(
+    sess: Lrc<Session>,
+    krate: ast::Crate,
+    resolver: &mut Resolver<'_>,
+) -> Result<ast::Crate> {
+    let sess = &*sess;
+
+    resolver.resolve_crate(&krate);
+
+    // FIXME(richkadel): Run tests and confirm that check_crate must go after resolve_crate(),
+    // and if not, can/should I move it into configure_and_expand_inner() (which would mean
+    // running this before instrumentation, if that's OK).
+
+    // FIXME(richkadel): original comment here with small modification:
+
+    // Needs to go *after* expansion and name resolution, to be able to check the results of macro
+    // expansion.
+    sess.time("complete_gated_feature_checking", || {
+        rustc_ast_passes::feature_gate::check_crate(
+            &krate,
+            &sess.parse_sess,
+            &sess.features_untracked(),
+            sess.opts.unstable_features,
+        );
+    });
+
+    Ok(krate)
+}
+
 impl BoxedResolver {
     pub fn to_resolver_outputs(resolver: Rc<RefCell<BoxedResolver>>) -> ResolverOutputs {
         match Rc::try_unwrap(resolver) {
@@ -405,21 +443,10 @@ fn configure_and_expand_inner<'a>(
     }
 
     if sess.opts.debugging_opts.ast_json {
+        // Note this version of the AST will not include injected code, such as coverage counters.
         println!("{}", json::as_json(&krate));
     }
 
-    resolver.resolve_crate(&krate);
-
-    // Needs to go *after* expansion to be able to check the results of macro expansion.
-    sess.time("complete_gated_feature_checking", || {
-        rustc_ast_passes::feature_gate::check_crate(
-            &krate,
-            &sess.parse_sess,
-            &sess.features_untracked(),
-            sess.opts.unstable_features,
-        );
-    });
-
     // Add all buffered lints from the `ParseSess` to the `Session`.
     sess.parse_sess.buffered_lints.with_lock(|buffered_lints| {
         info!("{} parse sess buffered_lints", buffered_lints.len());
@@ -428,6 +455,16 @@ fn configure_and_expand_inner<'a>(
         }
     });
 
+    // // Needs to go *after* expansion, to be able to check the results of macro expansion.
+    // sess.time("complete_gated_feature_checking", || {
+    //     rustc_ast_passes::feature_gate::check_crate(
+    //         &krate,
+    //         &sess.parse_sess,
+    //         &sess.features_untracked(),
+    //         sess.opts.unstable_features,
+    //     );
+    // });
+
     Ok((krate, resolver))
 }
 

src/librustc_interface/passes.rs

@@ -8,7 +8,6 @@ use rustc::ty::{GlobalCtxt, ResolverOutputs, TyCtxt};
 use rustc::util::common::ErrorReported;
 use rustc_ast::{self, ast};
 use rustc_codegen_ssa::traits::CodegenBackend;
-use rustc_coverage::coverage;
 use rustc_data_structures::sync::{Lrc, Once, WorkerLocal};
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::Crate;
@@ -18,7 +17,6 @@ use rustc_session::config::{OutputFilenames, OutputType};
 use rustc_session::{output::find_crate_name, Session};
 use rustc_span::symbol::sym;
 
-use log::debug;
 use std::any::Any;
 use std::cell::{Ref, RefCell, RefMut};
 use std::mem;
@@ -77,8 +75,9 @@ pub struct Queries<'tcx> {
     parse: Query<ast::Crate>,
     crate_name: Query<String>,
     register_plugins: Query<(ast::Crate, Lrc<LintStore>)>,
-    expansion: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>,
+    unresolved_expansion: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>,
     instrument: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>,
+    expansion: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>,
     dep_graph: Query<DepGraph>,
     lower_to_hir: Query<(&'tcx Crate<'tcx>, Steal<ResolverOutputs>)>,
     prepare_outputs: Query<OutputFilenames>,
@@ -97,6 +96,7 @@ impl<'tcx> Queries<'tcx> {
             parse: Default::default(),
             crate_name: Default::default(),
             register_plugins: Default::default(),
+            unresolved_expansion: Default::default(),
             expansion: Default::default(),
             instrument: Default::default(),
             dep_graph: Default::default(),
@@ -115,9 +115,7 @@ impl<'tcx> Queries<'tcx> {
     }
 
     pub fn dep_graph_future(&self) -> Result<&Query<Option<DepGraphFuture>>> {
-        debug!("query dep_graph_future");
         self.dep_graph_future.compute(|| {
-            debug!("compute query dep_graph_future");
             Ok(self
                 .session()
                 .opts
@@ -127,9 +125,7 @@ impl<'tcx> Queries<'tcx> {
     }
 
     pub fn parse(&self) -> Result<&Query<ast::Crate>> {
-        debug!("query parse");
         self.parse.compute(|| {
-            debug!("compute query parse");
             passes::parse(self.session(), &self.compiler.input).map_err(|mut parse_error| {
                 parse_error.emit();
                 ErrorReported
@@ -138,9 +134,7 @@ impl<'tcx> Queries<'tcx> {
     }
 
     pub fn register_plugins(&self) -> Result<&Query<(ast::Crate, Lrc<LintStore>)>> {
-        debug!("query register_plugins");
         self.register_plugins.compute(|| {
-            debug!("compute query register_plugins");
             let crate_name = self.crate_name()?.peek().clone();
             let krate = self.parse()?.take();
 
@@ -165,9 +159,7 @@ impl<'tcx> Queries<'tcx> {
     }
 
     pub fn crate_name(&self) -> Result<&Query<String>> {
-        debug!("query crate_name");
         self.crate_name.compute(|| {
-            debug!("compute query crate_name");
             Ok(match self.compiler.crate_name {
                 Some(ref crate_name) => crate_name.clone(),
                 None => {
@@ -179,16 +171,15 @@ impl<'tcx> Queries<'tcx> {
         })
     }
 
-    pub fn expansion(
+    /// Expands built-ins and other macros, but does not perform name resolution, pending potential
+    /// instrumentation.
+    pub fn unresolved_expansion(
         &self,
     ) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>> {
-        debug!("query expansion");
-        self.expansion.compute(|| {
-            debug!("compute query expansion");
+        self.unresolved_expansion.compute(|| {
             let crate_name = self.crate_name()?.peek().clone();
             let (krate, lint_store) = self.register_plugins()?.take();
             let _timer = self.session().timer("configure_and_expand");
-debug!("just before death");
             passes::configure_and_expand(
                 self.session().clone(),
                 lint_store.clone(),
@@ -197,16 +188,53 @@ debug!("just before death");
                 &crate_name,
             )
             .map(|(krate, resolver)| {
-debug!("NEVER GET HERE");
                 (krate, Steal::new(Rc::new(RefCell::new(resolver))), lint_store)
             })
         })
     }
 
+    /// Returns a modified ast::Crate with injected instrumentation code, if requested by command
+    /// line option.
+    ///
+    /// The `instrument` pass/query depends on (and implies) `unresolved_expansion`.
+    pub fn instrument(
+        &self,
+    ) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>> {
+        self.instrument.compute(|| {
+            let (krate, boxed_resolver, lint_store) = self.unresolved_expansion()?.take();
+            let instrument_coverage = match self.session().opts.debugging_opts.instrument_coverage {
+                Some(opt) => opt,
+                None => false,
+            };
+            if instrument_coverage {
+                boxed_resolver.borrow().borrow_mut().access(|resolver| {
+                    let _timer = self.session().timer("instrument_coverage");
+                    passes::instrument(krate, resolver)
+                })
+            } else {
+                Ok(krate)
+            }
+            .map(|krate| (krate, boxed_resolver, lint_store))
+        })
+    }
+
+    /// Updates the ast::Crate, first querying `instrument`, which queries `unresolved_expansion`.
+    /// After all expansions and instrumentation, performs name resolution on the final AST.
+    pub fn expansion(
+        &self,
+    ) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>> {
+        self.expansion.compute(|| {
+            let (krate, boxed_resolver, lint_store) = self.instrument()?.take();
+            let result = boxed_resolver.borrow().borrow_mut().access(|resolver| {
+                let _timer = self.session().timer("resolve_expansion");
+                passes::resolve_crate(self.session().clone(), krate, resolver)
+            });
+            result.map(|krate| (krate, boxed_resolver, lint_store))
+        })
+    }
+
     pub fn dep_graph(&self) -> Result<&Query<DepGraph>> {
-        debug!("query dep_graph");
         self.dep_graph.compute(|| {
-            debug!("compute query dep_graph");
             Ok(match self.dep_graph_future()?.take() {
                 None => DepGraph::new_disabled(),
                 Some(future) => {
@@ -225,42 +253,10 @@ debug!("NEVER GET HERE");
         })
     }
 
-    /// Instrumentation is optional (typically included based on `rustc` option). The
-    /// `instrument` pass/query depends on (and implies) `expansion`. To ensure the instrumentation
-    /// pass is executed (if requested), replace queries to `expansion` with queries to
-    /// `instrument`. The query results are the same. If instrumentation is not requested,
-    /// `expansion` will be queried and returned. If instrumentation is requested, `instrument`
-    /// will query `expansion`, inject instrumentation code (modifying the crate and updating the
-    /// `next_node_id()` in the resolver), and then return the query result from `expansion`, with
-    /// the changes to crate and resolver.
-    pub fn instrument(&'tcx self) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>> {
-        debug!("query instrument (depends on expansion), will instrument coverage if requested");
-        let expansion = self.expansion();
-        let instrument_coverage = match self.session().opts.debugging_opts.instrument_coverage {
-            Some(opt) => opt,
-            None => false,
-        };
-        if instrument_coverage {
-            self.instrument.compute(|| {
-                debug!("compute query instrument (depends on expansion), will instrument coverage if requested");
-                let (mut krate, boxed_resolver, lint_store) = expansion?.take();
-                let resolver = boxed_resolver.steal();
-                resolver.borrow_mut().access(|resolver| {
-                    coverage::instrument(&mut krate, resolver)
-                });
-                Ok((krate, Steal::new(resolver), lint_store))
-            })
-        } else {
-            expansion
-        }
-    }
-
     pub fn lower_to_hir(&'tcx self) -> Result<&Query<(&'tcx Crate<'tcx>, Steal<ResolverOutputs>)>> {
-        debug!("query lower_to_hir");
         self.lower_to_hir.compute(|| {
-            debug!("compute query lower_to_hir");
-            let instrument_result = self.instrument()?;
-            let peeked = instrument_result.peek();
+            let expansion_result = self.expansion()?;
+            let peeked = expansion_result.peek();
             let krate = &peeked.0;
             let resolver = peeked.1.steal();
             let lint_store = &peeked.2;
@@ -280,9 +276,7 @@ debug!("NEVER GET HERE");
     }
 
     pub fn prepare_outputs(&self) -> Result<&Query<OutputFilenames>> {
-        debug!("query prepare_outputs");
         self.prepare_outputs.compute(|| {
-            debug!("compute query prepare_outputs");
             let expansion_result = self.expansion()?;
             let (krate, boxed_resolver, _) = &*expansion_result.peek();
             let crate_name = self.crate_name()?;
@@ -298,9 +292,7 @@ debug!("NEVER GET HERE");
     }
 
     pub fn global_ctxt(&'tcx self) -> Result<&Query<QueryContext<'tcx>>> {
-        debug!("query global_ctxt");
         self.global_ctxt.compute(|| {
-            debug!("compute query global_ctxt");
             let crate_name = self.crate_name()?.peek().clone();
             let outputs = self.prepare_outputs()?.peek().clone();
             let lint_store = self.expansion()?.peek().2.clone();
@@ -323,9 +315,7 @@ debug!("NEVER GET HERE");
     }
 
     pub fn ongoing_codegen(&'tcx self) -> Result<&Query<Box<dyn Any>>> {
-        debug!("query ongoing_codegen");
         self.ongoing_codegen.compute(|| {
-            debug!("compute query ongoing_codegen");
             let outputs = self.prepare_outputs()?;
             self.global_ctxt()?.peek_mut().enter(|tcx| {
                 tcx.analysis(LOCAL_CRATE).ok();
@@ -413,7 +403,6 @@ pub struct Linker {
 
 impl Linker {
     pub fn link(self) -> Result<()> {
-        debug!("Linker::link");
         let codegen_results =
             self.codegen_backend.join_codegen(self.ongoing_codegen, &self.sess, &self.dep_graph)?;
         let prof = self.sess.prof.clone();

src/librustc_interface/queries.rs

@@ -440,7 +440,6 @@ impl Session {
     }
 
     pub fn init_features(&self, features: rustc_feature::Features) {
-        debug!("ABOUT TO PANIC?")
         self.features.set(features);
     }
 

src/librustc_session/session.rs

@@ -0,0 +1,83 @@
+//! Code coverage counters and report
+//!
+//! The code coverage library is typically not included in Rust source files.
+//!
+//! Instead, the `rustc` compiler optionally injects coverage calls into the internal representation
+//! of the source if requested by command line option to the compiler. The end result is an
+//! executable that includes the coverage counters, and writes a coverage report upon exit.
+//!
+//! The injected calls behave as if code like the following examples was actually part of the
+//! original source.
+//!
+//! Example:
+//!
+//! ```
+//! main() {
+//!     let value = if (true) {
+//!         std::coverage::count(1, {
+//!             // any expression
+//!             1000
+//!         })
+//!     } else {
+//!         std::coverage::count(2, 500)
+//!     }
+//!     std::coverage::count_and_report(3, ())
+//! }
+//! ```
+
+#![stable(feature = "coverage", since = "1.44.0")]
+
+use crate::collections::HashMap;
+use crate::sync::LockResult;
+use crate::sync::Mutex;
+use crate::sync::MutexGuard;
+use crate::sync::Once;
+
+static mut COUNTERS: Option<Mutex<HashMap<u128, usize>>> = None;
+
+static INIT: Once = Once::new();
+
+#[stable(feature = "coverage", since = "1.44.0")]
+#[inline]
+fn increment_counter(counter: u128) -> LockResult<MutexGuard<'static, HashMap<u128, usize>>> {
+    let mut lock = unsafe {
+        INIT.call_once(|| {
+            COUNTERS = Some(Mutex::new(HashMap::with_capacity(1024)));
+        });
+        COUNTERS.as_mut().unwrap().lock()
+    };
+    let counters = lock.as_mut().unwrap();
+    match counters.get_mut(&counter) {
+        Some(count) => *count += 1,
+        None => {
+            counters.insert(counter, 1);
+        }
+    }
+    lock
+}
+
+/// The statement may be the last statement of a block, the value of a `return` or `break`,
+/// a match pattern arm statement that might not be in a block (but if it is, don't wrap both the
+/// block and the last statement of the block), or a closure statement without braces.
+///
+///     coverage::count(234234, {some_statement_with_or_without_semicolon()})
+#[stable(feature = "coverage", since = "1.44.0")]
+#[inline]
+pub fn count<T>(counter: u128, result: T) -> T {
+    let _ = increment_counter(counter);
+    result
+}
+
+/// Increment the specified counter and then write the coverage report. This function normally wraps
+/// the final expression in a `main()` function. There can be more than one statement, for example
+/// if the `main()` has one or more `return` statements. In this case, all returns and the last
+/// statement of `main()` (unless not reachable) should use this function.
+#[stable(feature = "coverage", since = "1.44.0")]
+pub fn count_and_report<T>(counter: u128, result: T) -> T {
+    println!("Print the coverage counters:");
+    let mut counters = increment_counter(counter).unwrap();
+    for (counter, count) in counters.drain() {
+        println!("Counter '{}' has count: {}", counter, count);
+    }
+    result
+}

src/libstd/coverage.rs

@@ -447,6 +447,7 @@ pub mod thread;
 pub mod ascii;
 pub mod backtrace;
 pub mod collections;
+pub mod coverage;
 pub mod env;
 pub mod error;
 pub mod ffi;