rustc_mir_transform/coverage/
mod.rs

1use rustc_middle::mir::coverage::{CoverageKind, FunctionCoverageInfo, Mapping, MappingKind};
2use rustc_middle::mir::{self, BasicBlock, Statement, StatementKind, TerminatorKind};
3use rustc_middle::ty::TyCtxt;
4use tracing::{debug, debug_span, trace};
5
6use crate::coverage::counters::BcbCountersData;
7use crate::coverage::graph::CoverageGraph;
8use crate::coverage::mappings::ExtractedMappings;
9
10mod counters;
11mod graph;
12mod hir_info;
13mod mappings;
14pub(super) mod query;
15mod spans;
16#[cfg(test)]
17mod tests;
18mod unexpand;
19
20/// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected
21/// counters, via intrinsic `llvm.instrprof.increment`, and/or inject metadata used during codegen
22/// to construct the coverage map.
23pub(super) struct InstrumentCoverage;
24
25impl<'tcx> crate::MirPass<'tcx> for InstrumentCoverage {
26    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
27        sess.instrument_coverage()
28    }
29
30    fn run_pass(&self, tcx: TyCtxt<'tcx>, mir_body: &mut mir::Body<'tcx>) {
31        let mir_source = mir_body.source;
32
33        // This pass runs after MIR promotion, but before promoted MIR starts to
34        // be transformed, so it should never see promoted MIR.
35        assert!(mir_source.promoted.is_none());
36
37        let def_id = mir_source.def_id().expect_local();
38
39        if !tcx.is_eligible_for_coverage(def_id) {
40            trace!("InstrumentCoverage skipped for {def_id:?} (not eligible)");
41            return;
42        }
43
44        // An otherwise-eligible function is still skipped if its start block
45        // is known to be unreachable.
46        match mir_body.basic_blocks[mir::START_BLOCK].terminator().kind {
47            TerminatorKind::Unreachable => {
48                trace!("InstrumentCoverage skipped for unreachable `START_BLOCK`");
49                return;
50            }
51            _ => {}
52        }
53
54        instrument_function_for_coverage(tcx, mir_body);
55    }
56
57    fn is_required(&self) -> bool {
58        false
59    }
60}
61
62fn instrument_function_for_coverage<'tcx>(tcx: TyCtxt<'tcx>, mir_body: &mut mir::Body<'tcx>) {
63    let def_id = mir_body.source.def_id();
64    let _span = debug_span!("instrument_function_for_coverage", ?def_id).entered();
65
66    let hir_info = hir_info::extract_hir_info(tcx, def_id.expect_local());
67
68    // Build the coverage graph, which is a simplified view of the MIR control-flow
69    // graph that ignores some details not relevant to coverage instrumentation.
70    let graph = CoverageGraph::from_mir(mir_body);
71
72    ////////////////////////////////////////////////////
73    // Extract coverage spans and other mapping info from MIR.
74    let extracted_mappings =
75        mappings::extract_all_mapping_info_from_mir(tcx, mir_body, &hir_info, &graph);
76
77    let mappings = create_mappings(&extracted_mappings);
78    if mappings.is_empty() {
79        // No spans could be converted into valid mappings, so skip this function.
80        debug!("no spans could be converted into valid mappings; skipping");
81        return;
82    }
83
84    // Use the coverage graph to prepare intermediate data that will eventually
85    // be used to assign physical counters and counter expressions to points in
86    // the control-flow graph.
87    let BcbCountersData { node_flow_data, priority_list } =
88        counters::prepare_bcb_counters_data(&graph);
89
90    // Inject coverage statements into MIR.
91    inject_coverage_statements(mir_body, &graph);
92
93    mir_body.function_coverage_info = Some(Box::new(FunctionCoverageInfo {
94        function_source_hash: hir_info.function_source_hash,
95
96        node_flow_data,
97        priority_list,
98
99        mappings,
100    }));
101}
102
103/// For each coverage span extracted from MIR, create a corresponding mapping.
104///
105/// FIXME(Zalathar): This used to be where BCBs in the extracted mappings were
106/// resolved to a `CovTerm`. But that is now handled elsewhere, so this
107/// function can potentially be simplified even further.
108fn create_mappings(extracted_mappings: &ExtractedMappings) -> Vec<Mapping> {
109    // Fully destructure the mappings struct to make sure we don't miss any kinds.
110    let ExtractedMappings { code_mappings, branch_pairs } = extracted_mappings;
111    let mut mappings = Vec::new();
112
113    mappings.extend(code_mappings.iter().map(
114        // Ordinary code mappings are the simplest kind.
115        |&mappings::CodeMapping { span, bcb }| {
116            let kind = MappingKind::Code { bcb };
117            Mapping { kind, span }
118        },
119    ));
120
121    mappings.extend(branch_pairs.iter().map(
122        |&mappings::BranchPair { span, true_bcb, false_bcb }| {
123            let kind = MappingKind::Branch { true_bcb, false_bcb };
124            Mapping { kind, span }
125        },
126    ));
127
128    mappings
129}
130
131/// Inject any necessary coverage statements into MIR, so that they influence codegen.
132fn inject_coverage_statements<'tcx>(mir_body: &mut mir::Body<'tcx>, graph: &CoverageGraph) {
133    for (bcb, data) in graph.iter_enumerated() {
134        let target_bb = data.leader_bb();
135        inject_statement(mir_body, CoverageKind::VirtualCounter { bcb }, target_bb);
136    }
137}
138
139fn inject_statement(mir_body: &mut mir::Body<'_>, counter_kind: CoverageKind, bb: BasicBlock) {
140    debug!("  injecting statement {counter_kind:?} for {bb:?}");
141    let data = &mut mir_body[bb];
142    let source_info = data.terminator().source_info;
143    let statement = Statement::new(source_info, StatementKind::Coverage(counter_kind));
144    data.statements.insert(0, statement);
145}
rustc_mir_transform/coverage/mod.rs

rustc_mir_transform/coverage/
mod.rs
