Injecting expressions in place of counters where helpful

Implementing the Graph traits for the BasicCoverageBlock
graph.

optimized replacement of counters with expressions plus new BCB graphviz

* Avoid adding coverage to unreachable blocks.
* Special case for Goto at the end of the body. Make it non-reportable.

Improved debugging and formatting options (from env)

Don't automatically add counters to BCBs without CoverageSpans. They may
still get counters but only if there are dependencies from
other BCBs that have spans, I think.

Make CodeRegions optional for Counters too. It is
possible to inject counters (`llvm.instrprof.increment` intrinsic calls
without corresponding code regions in the coverage map. An expression
can still uses these counter values.

Refactored instrument_coverage.rs -> instrument_coverage/mod.rs, and
then broke up the mod into multiple files.

Compiling with coverage, with the expression optimization, works on
the json5format crate and its dependencies.

Refactored debug features from mod.rs to debug.rs

Author: richkadel

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -58,7 +58,11 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         unsafe { llvm::LLVMRustCoverageCreatePGOFuncNameVar(llfn, mangled_fn_name.as_ptr()) }
     }
 
-    fn set_function_source_hash(&mut self, instance: Instance<'tcx>, function_source_hash: u64) -> bool {
+    fn set_function_source_hash(
+        &mut self,
+        instance: Instance<'tcx>,
+        function_source_hash: u64,
+    ) -> bool {
         if let Some(coverage_context) = self.coverage_context() {
             debug!(
                 "ensuring function source hash is set for instance={:?}; function_source_hash={}",
@@ -69,6 +73,7 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .set_function_source_hash(function_source_hash);
+            true
         } else {
             false
         }
@@ -92,6 +97,7 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_counter(function_source_hash, id, region);
+            true
         } else {
             false
         }
@@ -105,8 +111,8 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         op: Op,
         rhs: ExpressionOperandId,
         region: Option<CodeRegion>,
-    ) {
-        if let Some(coverage_context) = self.coverage_context() -> bool {
+    ) -> bool {
+        if let Some(coverage_context) = self.coverage_context() {
             debug!(
                 "adding counter expression to coverage_map: instance={:?}, id={:?}, {:?} {:?} {:?}; \
                 region: {:?}",
@@ -117,19 +123,24 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_counter_expression(id, lhs, op, rhs, region);
+            true
         } else {
             false
         }
     }
 
     fn add_coverage_unreachable(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool {
         if let Some(coverage_context) = self.coverage_context() {
-            debug!("adding unreachable code to coverage_map: instance={:?}, at {:?}", instance, region,);
+            debug!(
+                "adding unreachable code to coverage_map: instance={:?}, at {:?}",
+                instance, region,
+            );
             let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
             coverage_map
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_unreachable_region(region);
+            true
         } else {
             false
         }

compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs

@@ -24,10 +24,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     let fn_name = bx.create_pgo_func_name_var(self.instance);
                     let hash = bx.const_u64(function_source_hash);
                     let num_counters = bx.const_u32(coverageinfo.num_counters);
-                    let id = bx.const_u32(u32::from(id));
+                    let index = bx.const_u32(u32::from(id));
                     debug!(
                         "codegen intrinsic instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})",
-                        fn_name, hash, num_counters, id,
+                        fn_name, hash, num_counters, index,
                     );
                     bx.instrprof_increment(fn_name, hash, num_counters, index);
                 }

compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs

@@ -11,15 +11,19 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
 
     /// Returns true if the function source hash was added to the coverage map; false if
     /// `-Z instrument-coverage` is not enabled (a coverage map is not being generated).
-    fn set_function_source_hash(&mut self, instance: Instance<'tcx>, function_source_hash: u64) -> bool;
+    fn set_function_source_hash(
+        &mut self,
+        instance: Instance<'tcx>,
+        function_source_hash: u64,
+    ) -> bool;
 
     /// Returns true if the counter was added to the coverage map; false if `-Z instrument-coverage`
     /// is not enabled (a coverage map is not being generated).
     fn add_coverage_counter(
         &mut self,
         instance: Instance<'tcx>,
         function_source_hash: u64,
-        id: CounterValueReference,
+        index: CounterValueReference,
         region: CodeRegion,
     ) -> bool;
 
@@ -33,7 +37,7 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
         op: Op,
         rhs: ExpressionOperandId,
         region: Option<CodeRegion>,
-    );
+    ) -> bool;
 
     /// Returns true if the region was added to the coverage map; false if `-Z instrument-coverage`
     /// is not enabled (a coverage map is not being generated).