WIP: Injects counters before every block (experimental only)

Uses the span from the start of the first statement to the end of the
Terminator.

Includes "cleanup" subgraphs.

This simple approach does introduce some poor coverage results. For
example, a function that only calls macros (like `println!`, for
example) may only have counters injected at the macro site, and these
may never get counted, for some reason. (I'm seeing some functions with
coverage counts of zero, even though they clearly should be called.)

I'm developing a follow-up change to this one that injects counters more
precisely, by inspecting the Statement and Terminator types, and making
different decisions regarding what blocks should be counted, and what
spans to use to generate the code regions.

Author: Rich Kadel

src/librustc_mir/transform/instrument_coverage.rs

@@ -174,21 +174,27 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         let body_span = self.hir_body.value.span;
         debug!("instrumenting {:?}, span: {:?}", self.mir_def_id, body_span);
 
-        // FIXME(richkadel): As a first step, counters are only injected at the top of each
-        // function. The complete solution will inject counters at each conditional code branch.
-        let _ignore = mir_body;
-        let id = self.next_counter();
-        let function_source_hash = self.function_source_hash();
-        let code_region = body_span;
-        let scope = rustc_middle::mir::OUTERMOST_SOURCE_SCOPE;
-        let is_cleanup = false;
-        let next_block = rustc_middle::mir::START_BLOCK;
-        self.inject_call(
-            self.make_counter(id, function_source_hash, code_region),
-            scope,
-            is_cleanup,
-            next_block,
-        );
+        // Experimentally: Instrument every block (including cleanup).
+        let mut source_info_by_bb = Vec::with_capacity(mir_body.basic_blocks().len());
+        for (bb, data) in traversal::preorder(mir_body) {
+            debug!("Injecting before: {:?}", data);
+            let source_info = self.get_block_source_info(data);
+            let scope = source_info.scope;
+            let code_region = source_info.span;
+            source_info_by_bb.push((code_region, scope, data.is_cleanup, bb));
+        }
+
+        // Inject counters for the selected code regions
+        for (code_region, scope, is_cleanup, next_block) in source_info_by_bb {
+            let id = self.next_counter();
+            let function_source_hash = self.function_source_hash();
+            self.inject_call(
+                self.make_counter(id, function_source_hash, code_region),
+                scope,
+                is_cleanup,
+                next_block,
+            );
+        }
 
         // FIXME(richkadel): The next step to implement source based coverage analysis will be
         // instrumenting branches within functions, and some regions will be counted by "counter
@@ -335,6 +341,33 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         self.mir_body.basic_blocks_mut().swap(next_block, new_block);
     }
 
+    fn get_block_source_info(&self, data: &BasicBlockData<'tcx>) -> SourceInfo {
+        if let Some(statement) = data.statements.get(0) {
+            let start = &statement.source_info;
+            let end = &data.terminator().source_info;
+            let scope = if start.scope == end.scope {
+                start.scope
+            } else if self.mir_body.is_sub_scope(start.scope, end.scope) {
+                end.scope
+            } else if self.mir_body.is_sub_scope(end.scope, start.scope) {
+                start.scope
+            } else {
+                rustc_middle::mir::OUTERMOST_SOURCE_SCOPE
+            };
+            let span = start.span.to(end.span);
+            // FIXME(richkadel): See the embedded `FIXME` comments in `Span::to()`, and note,
+            // the function may return only the span of `start` or `end`, if the contexts are
+            // not equal. When attempting to encompass the `Span`s of `BasicBlock`s, as is
+            // done here, it is apparently not unusual to have different contexts. Upcoming
+            // (near term) iterations of coverage injection will be more deliberate about
+            // selecting the spans for code regions, from the analysis of `Statement`s and
+            // `Terminator`s, so this issue should be revisited at that time.
+            SourceInfo { span, scope }
+        } else {
+            data.terminator().source_info
+        }
+    }
+
     fn const_u32(&self, value: u32, span: Span) -> Operand<'tcx> {
         Operand::const_from_scalar(self.tcx, self.tcx.types.u32, Scalar::from_u32(value), span)
     }

src/test/mir-opt/instrument_coverage/rustc.bar.InstrumentCoverage.diff

@@ -3,40 +3,40 @@
 
   fn bar() -> bool {
       let mut _0: bool;                    // return place in scope 0 at $DIR/instrument_coverage.rs:18:13: 18:17
-+     let mut _1: ();                      // in scope 0 at $DIR/instrument_coverage.rs:18:18: 18:18
++     let mut _1: ();                      // in scope 0 at $DIR/instrument_coverage.rs:19:5: 19:5
 
       bb0: {
-+         StorageLive(_1);                 // scope 0 at $DIR/instrument_coverage.rs:18:18: 18:18
-+         _1 = const std::intrinsics::count_code_region(const 10208505205182607101_u64, const 0_u32, const 501_u32, const 513_u32) -> bb2; // scope 0 at $DIR/instrument_coverage.rs:18:18: 18:18
++         StorageLive(_1);                 // scope 0 at $DIR/instrument_coverage.rs:19:5: 19:5
++         _1 = const std::intrinsics::count_code_region(const 10208505205182607101_u64, const 0_u32, const 507_u32, const 513_u32) -> bb2; // scope 0 at $DIR/instrument_coverage.rs:19:5: 19:5
 +                                          // ty::Const
 +                                          // + ty: unsafe extern "rust-intrinsic" fn(u64, u32, u32, u32) {std::intrinsics::count_code_region}
 +                                          // + val: Value(Scalar(<ZST>))
 +                                          // mir::Constant
-+                                          // + span: $DIR/instrument_coverage.rs:18:18: 18:18
++                                          // + span: $DIR/instrument_coverage.rs:19:5: 19:5
 +                                          // + literal: Const { ty: unsafe extern "rust-intrinsic" fn(u64, u32, u32, u32) {std::intrinsics::count_code_region}, val: Value(Scalar(<ZST>)) }
 +                                          // ty::Const
 +                                          // + ty: u64
 +                                          // + val: Value(Scalar(0x8dabe565aaa2aefd))
 +                                          // mir::Constant
-+                                          // + span: $DIR/instrument_coverage.rs:18:18: 18:18
++                                          // + span: $DIR/instrument_coverage.rs:19:5: 19:5
 +                                          // + literal: Const { ty: u64, val: Value(Scalar(0x8dabe565aaa2aefd)) }
 +                                          // ty::Const
 +                                          // + ty: u32
 +                                          // + val: Value(Scalar(0x00000000))
 +                                          // mir::Constant
-+                                          // + span: $DIR/instrument_coverage.rs:18:18: 18:18
++                                          // + span: $DIR/instrument_coverage.rs:19:5: 19:5
 +                                          // + literal: Const { ty: u32, val: Value(Scalar(0x00000000)) }
 +                                          // ty::Const
 +                                          // + ty: u32
-+                                          // + val: Value(Scalar(0x000001f5))
++                                          // + val: Value(Scalar(0x000001fb))
 +                                          // mir::Constant
-+                                          // + span: $DIR/instrument_coverage.rs:18:18: 18:18
-+                                          // + literal: Const { ty: u32, val: Value(Scalar(0x000001f5)) }
++                                          // + span: $DIR/instrument_coverage.rs:19:5: 19:5
++                                          // + literal: Const { ty: u32, val: Value(Scalar(0x000001fb)) }
 +                                          // ty::Const
 +                                          // + ty: u32
 +                                          // + val: Value(Scalar(0x00000201))
 +                                          // mir::Constant
-+                                          // + span: $DIR/instrument_coverage.rs:18:18: 18:18
++                                          // + span: $DIR/instrument_coverage.rs:19:5: 19:5
 +                                          // + literal: Const { ty: u32, val: Value(Scalar(0x00000201)) }
 +     }
 +