Struct rustc_mir::transform::instrument_coverage::Instrumentor

struct Instrumentor<'a, 'tcx> {
    pass_name: &'a str,
    tcx: TyCtxt<'tcx>,
    mir_body: &'a mut Body<'tcx>,
    hir_body: &'tcx Body<'tcx>,
    dominators: Option<Dominators<BasicBlock>>,
    basic_coverage_blocks: Option<BasicCoverageBlocks>,
    function_source_hash: Option<u64>,
    next_counter_id: u32,
    num_expressions: u32,
}

Fields

pass_name: &'a str

tcx: TyCtxt<'tcx>

mir_body: &'a mut Body<'tcx>

hir_body: &'tcx Body<'tcx>

dominators: Option<Dominators<BasicBlock>>

basic_coverage_blocks: Option<BasicCoverageBlocks>

function_source_hash: Option<u64>

next_counter_id: u32

num_expressions: u32

Implementations

impl<'a, 'tcx> Instrumentor<'a, 'tcx>

fn new(
    pass_name: &'a str,
    tcx: TyCtxt<'tcx>,
    mir_body: &'a mut Body<'tcx>
) -> Self

fn next_counter(&mut self) -> CounterValueReference

Counter IDs start from one and go up.

fn next_expression(&mut self) -> InjectedExpressionIndex

Expression IDs start from u32::MAX and go down because a CounterExpression can reference (add or subtract counts) of both Counter regions and CounterExpression regions. The counter expression operand IDs must be unique across both types.

fn dominators(&self) -> &Dominators<BasicBlock>

fn basic_coverage_blocks(&self) -> &BasicCoverageBlocks

fn function_source_hash(&mut self) -> u64

fn inject_counters(&mut self)

fn make_counter(&mut self) -> CoverageKind

fn make_expression(
    &mut self,
    lhs: ExpressionOperandId,
    op: Op,
    rhs: ExpressionOperandId
) -> CoverageKind

fn inject_statement(
    &mut self,
    file_name: Symbol,
    source_file: &Lrc<SourceFile>,
    coverage_kind: CoverageKind,
    span: Span,
    block: BasicBlock
)

fn span_viewables(
    &self,
    coverage_spans: &Vec<CoverageSpan>
) -> Vec<SpanViewable>

Converts the computed BasicCoverageBlocks into SpanViewables.

fn bcb_from_coverage_span(
    &self,
    coverage_span: &CoverageSpan
) -> &BasicCoverageBlock

fn body_span(&self) -> Span

fn extract_spans(&self, bcb: &'a BasicCoverageBlock) -> Vec<CoverageSpan>

fn coverage_spans(&self) -> Vec<CoverageSpan>

Generate a minimal set of CoverageSpans, each representing a contiguous code region to be counted.

The basic steps are:

1. Extract an initial set of spans from the Statements and Terminators of each BasicCoverageBlock.

2. Sort the spans by span.lo() (starting position). Spans that start at the same position are sorted with longer spans before shorter spans; and equal spans are sorted (deterministically) based on "dominator" relationship (if any).

3. Traverse the spans in sorted order to identify spans that can be dropped (for instance, if another span or spans are already counting the same code region), or should be merged into a broader combined span (because it represents a contiguous, non-branching, and uninterrupted region of source code).

   Closures are exposed in their enclosing functions as Assign Rvalues, and since closures have their own MIR, their Span in their enclosing function should be left "uncovered".

Note the resulting vector of CoverageSpans does may not be fully sorted (and does not need to be).