diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs index c4b4032fd478..75e8abaf2a9e 100644 --- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs +++ b/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, - ) { - 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,6 +123,7 @@ 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 } @@ -124,12 +131,16 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> { 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 } diff --git a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs index e52f952e9327..339e0d95fdff 100644 --- a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs +++ b/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); } diff --git a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs index 5aa0950b399e..7da38880d603 100644 --- a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs +++ b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs @@ -11,7 +11,11 @@ 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). @@ -19,7 +23,7 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes { &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, - ); + ) -> 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). diff --git a/compiler/rustc_mir/src/transform/coverage/counters.rs b/compiler/rustc_mir/src/transform/coverage/counters.rs index c31f401780e1..a3ae30215248 100644 --- a/compiler/rustc_mir/src/transform/coverage/counters.rs +++ b/compiler/rustc_mir/src/transform/coverage/counters.rs @@ -1,7 +1,15 @@ +use super::Error; + use super::debug; +use super::graph; +use super::spans; -use debug::DebugCounters; +use debug::{DebugCounters, NESTED_INDENT}; +use graph::{BasicCoverageBlock, BcbBranch, CoverageGraph, TraverseCoverageGraphWithLoops}; +use spans::CoverageSpan; +use rustc_data_structures::graph::WithNumNodes; +use rustc_index::bit_set::BitSet; use rustc_middle::mir::coverage::*; /// Manages the counter and expression indexes/IDs to generate `CoverageKind` components for MIR @@ -29,7 +37,19 @@ impl CoverageCounters { self.debug_counters.enable(); } - pub fn make_counter(&mut self, debug_block_label_fn: F) -> CoverageKind + /// Makes `CoverageKind` `Counter`s and `Expressions` for the `BasicCoverageBlocks` directly or + /// indirectly associated with `CoverageSpans`, and returns additional `Expression`s + /// representing intermediate values. + pub fn make_bcb_counters( + &mut self, + basic_coverage_blocks: &mut CoverageGraph, + coverage_spans: &Vec, + ) -> Result, Error> { + let mut bcb_counters = BcbCounters::new(self, basic_coverage_blocks); + bcb_counters.make_bcb_counters(coverage_spans) + } + + fn make_counter(&mut self, debug_block_label_fn: F) -> CoverageKind where F: Fn() -> Option, { @@ -43,7 +63,7 @@ impl CoverageCounters { counter } - pub fn make_expression( + fn make_expression( &mut self, lhs: ExpressionOperandId, op: Op, @@ -61,6 +81,17 @@ impl CoverageCounters { expression } + pub fn make_identity_counter(&mut self, counter_operand: ExpressionOperandId) -> CoverageKind { + let some_debug_block_label = if self.debug_counters.is_enabled() { + self.debug_counters.some_block_label(counter_operand).cloned() + } else { + None + }; + self.make_expression(counter_operand, Op::Add, ExpressionOperandId::ZERO, || { + some_debug_block_label.clone() + }) + } + /// Counter IDs start from one and go up. fn next_counter(&mut self) -> CounterValueReference { assert!(self.next_counter_id < u32::MAX - self.num_expressions); @@ -79,3 +110,490 @@ impl CoverageCounters { InjectedExpressionId::from(next) } } + +/// Traverse the `CoverageGraph` and add either a `Counter` or `Expression` to every BCB, to be +/// injected with `CoverageSpan`s. `Expressions` have no runtime overhead, so if a viable expression +/// (adding or subtracting two other counters or expressions) can compute the same result as an +/// embedded counter, an `Expression` should be used. +struct BcbCounters<'a> { + coverage_counters: &'a mut CoverageCounters, + basic_coverage_blocks: &'a mut CoverageGraph, +} + +impl<'a> BcbCounters<'a> { + fn new( + coverage_counters: &'a mut CoverageCounters, + basic_coverage_blocks: &'a mut CoverageGraph, + ) -> Self { + Self { coverage_counters, basic_coverage_blocks } + } + + /// If two `CoverageGraph` branch from another `BasicCoverageBlock`, one of the branches + /// can be counted by `Expression` by subtracting the other branch from the branching + /// block. Otherwise, the `BasicCoverageBlock` executed the least should have the `Counter`. + /// One way to predict which branch executes the least is by considering loops. A loop is exited + /// at a branch, so the branch that jumps to a `BasicCoverageBlock` outside the loop is almost + /// always executed less than the branch that does not exit the loop. + /// + /// Returns any non-code-span expressions created to represent intermediate values (such as to + /// add two counters so the result can be subtracted from another counter), or an Error with + /// message for subsequent debugging. + fn make_bcb_counters( + &mut self, + coverage_spans: &Vec, + ) -> Result, Error> { + debug!("make_bcb_counters(): adding a counter or expression to each BasicCoverageBlock"); + let num_bcbs = self.basic_coverage_blocks.num_nodes(); + let mut collect_intermediate_expressions = Vec::with_capacity(num_bcbs); + + let mut bcbs_with_coverage = BitSet::new_empty(num_bcbs); + for covspan in coverage_spans { + bcbs_with_coverage.insert(covspan.bcb); + } + + // FIXME(richkadel): Add more comments to explain the logic here and in the rest of this + // function, and refactor this function to break it up into smaller functions that are + // easier to understand. + + let mut traversal = TraverseCoverageGraphWithLoops::new(&self.basic_coverage_blocks); + while let Some(bcb) = traversal.next(self.basic_coverage_blocks) { + if bcbs_with_coverage.contains(bcb) { + debug!("{:?} has at least one `CoverageSpan`. Get or make its counter", bcb); + let branching_counter_operand = + self.get_or_make_counter_operand(bcb, &mut collect_intermediate_expressions)?; + + if self.bcb_needs_branch_counters(bcb) { + self.make_branch_counters( + &mut traversal, + bcb, + branching_counter_operand, + &mut collect_intermediate_expressions, + )?; + } + } else { + debug!( + "{:?} does not have any `CoverageSpan`s. A counter will only be added if \ + and when a covered BCB has an expression dependency.", + bcb, + ); + } + } + + if traversal.is_complete() { + Ok(collect_intermediate_expressions) + } else { + Error::from_string(format!( + "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s: {:?}", + traversal.unvisited(), + )) + } + } + + fn make_branch_counters( + &mut self, + traversal: &mut TraverseCoverageGraphWithLoops, + branching_bcb: BasicCoverageBlock, + branching_counter_operand: ExpressionOperandId, + collect_intermediate_expressions: &mut Vec, + ) -> Result<(), Error> { + let branches = self.bcb_branches(branching_bcb); + debug!( + "{:?} has some branch(es) without counters:\n {}", + branching_bcb, + branches + .iter() + .map(|branch| { + format!("{:?}: {:?}", branch, branch.counter(&self.basic_coverage_blocks)) + }) + .collect::>() + .join("\n "), + ); + + let expression_branch = self.choose_preferred_expression_branch(traversal, &branches); + // Assign a Counter or Expression to each branch, plus additional + // `Expression`s, as needed, to sum up intermediate results. + let mut some_sumup_counter_operand = None; + for branch in branches { + if branch != expression_branch { + let branch_counter_operand = if branch.is_only_path_to_target() { + debug!( + " {:?} has only one incoming edge (from {:?}), so adding a \ + counter", + branch, branching_bcb + ); + self.get_or_make_counter_operand( + branch.target_bcb, + collect_intermediate_expressions, + )? + } else { + debug!(" {:?} has multiple incoming edges, so adding an edge counter", branch); + self.get_or_make_edge_counter_operand( + branching_bcb, + branch.target_bcb, + collect_intermediate_expressions, + )? + }; + if let Some(sumup_counter_operand) = + some_sumup_counter_operand.replace(branch_counter_operand) + { + let intermediate_expression = self.coverage_counters.make_expression( + branch_counter_operand, + Op::Add, + sumup_counter_operand, + || None, + ); + debug!( + " [new intermediate expression: {}]", + self.format_counter(&intermediate_expression) + ); + let intermediate_expression_operand = intermediate_expression.as_operand_id(); + collect_intermediate_expressions.push(intermediate_expression); + some_sumup_counter_operand.replace(intermediate_expression_operand); + } + } + } + let sumup_counter_operand = + some_sumup_counter_operand.expect("sumup_counter_operand should have a value"); + debug!( + "Making an expression for the selected expression_branch: {:?} \ + (expression_branch predecessors: {:?})", + expression_branch, + self.bcb_predecessors(expression_branch.target_bcb), + ); + let expression = self.coverage_counters.make_expression( + branching_counter_operand, + Op::Subtract, + sumup_counter_operand, + || Some(format!("{:?}", expression_branch)), + ); + debug!("{:?} gets an expression: {}", expression_branch, self.format_counter(&expression)); + let bcb = expression_branch.target_bcb; + if expression_branch.is_only_path_to_target() { + self.basic_coverage_blocks[bcb].set_counter(expression)?; + } else { + self.basic_coverage_blocks[bcb].set_edge_counter_from(branching_bcb, expression)?; + } + Ok(()) + } + + fn get_or_make_counter_operand( + &mut self, + bcb: BasicCoverageBlock, + collect_intermediate_expressions: &mut Vec, + ) -> Result { + self.recursive_get_or_make_counter_operand(bcb, collect_intermediate_expressions, 1) + } + + fn recursive_get_or_make_counter_operand( + &mut self, + bcb: BasicCoverageBlock, + collect_intermediate_expressions: &mut Vec, + debug_indent_level: usize, + ) -> Result { + Ok({ + if let Some(counter_kind) = self.basic_coverage_blocks[bcb].counter() { + debug!( + "{}{:?} already has a counter: {}", + NESTED_INDENT.repeat(debug_indent_level), + bcb, + self.format_counter(counter_kind), + ); + counter_kind.as_operand_id() + } else { + let one_path_to_target = self.bcb_has_one_path_to_target(bcb); + if one_path_to_target || self.bcb_predecessors(bcb).contains(&bcb) { + let counter_kind = + self.coverage_counters.make_counter(|| Some(format!("{:?}", bcb))); + if one_path_to_target { + debug!( + "{}{:?} gets a new counter: {}", + NESTED_INDENT.repeat(debug_indent_level), + bcb, + self.format_counter(&counter_kind), + ); + } else { + debug!( + "{}{:?} has itself as its own predecessor. It can't be part of its own \ + Expression sum, so it will get its own new counter: {}. (Note, the \ + compiled code will generate an infinite loop.)", + NESTED_INDENT.repeat(debug_indent_level), + bcb, + self.format_counter(&counter_kind), + ); + } + self.basic_coverage_blocks[bcb].set_counter(counter_kind)? + } else { + let mut predecessors = self.bcb_predecessors(bcb).clone().into_iter(); + debug!( + "{}{:?} has multiple incoming edges and will get an expression that sums \ + them up...", + NESTED_INDENT.repeat(debug_indent_level), + bcb, + ); + let first_edge_counter_operand = self + .recursive_get_or_make_edge_counter_operand( + predecessors.next().unwrap(), + bcb, + collect_intermediate_expressions, + debug_indent_level + 1, + )?; + let mut some_sumup_edge_counter_operand = None; + for predecessor in predecessors { + let edge_counter_operand = self + .recursive_get_or_make_edge_counter_operand( + predecessor, + bcb, + collect_intermediate_expressions, + debug_indent_level + 1, + )?; + if let Some(sumup_edge_counter_operand) = + some_sumup_edge_counter_operand.replace(edge_counter_operand) + { + let intermediate_expression = self.coverage_counters.make_expression( + sumup_edge_counter_operand, + Op::Add, + edge_counter_operand, + || None, + ); + debug!( + "{}new intermediate expression: {}", + NESTED_INDENT.repeat(debug_indent_level), + self.format_counter(&intermediate_expression) + ); + let intermediate_expression_operand = + intermediate_expression.as_operand_id(); + collect_intermediate_expressions.push(intermediate_expression); + some_sumup_edge_counter_operand + .replace(intermediate_expression_operand); + } + } + let counter_kind = self.coverage_counters.make_expression( + first_edge_counter_operand, + Op::Add, + some_sumup_edge_counter_operand.unwrap(), + || Some(format!("{:?}", bcb)), + ); + debug!( + "{}{:?} gets a new counter (sum of predecessor counters): {}", + NESTED_INDENT.repeat(debug_indent_level), + bcb, + self.format_counter(&counter_kind) + ); + self.basic_coverage_blocks[bcb].set_counter(counter_kind)? + } + } + }) + } + + fn get_or_make_edge_counter_operand( + &mut self, + from_bcb: BasicCoverageBlock, + to_bcb: BasicCoverageBlock, + collect_intermediate_expressions: &mut Vec, + ) -> Result { + self.recursive_get_or_make_edge_counter_operand( + from_bcb, + to_bcb, + collect_intermediate_expressions, + 1, + ) + } + + fn recursive_get_or_make_edge_counter_operand( + &mut self, + from_bcb: BasicCoverageBlock, + to_bcb: BasicCoverageBlock, + collect_intermediate_expressions: &mut Vec, + debug_indent_level: usize, + ) -> Result { + Ok({ + let successors = self.bcb_successors(from_bcb).iter(); + if successors.len() > 1 { + if let Some(counter_kind) = + self.basic_coverage_blocks[to_bcb].edge_counter_from(from_bcb) + { + debug!( + "{}Edge {:?}->{:?} already has a counter: {}", + NESTED_INDENT.repeat(debug_indent_level), + from_bcb, + to_bcb, + self.format_counter(counter_kind) + ); + counter_kind.as_operand_id() + } else { + let counter_kind = self + .coverage_counters + .make_counter(|| Some(format!("{:?}->{:?}", from_bcb, to_bcb))); + debug!( + "{}Edge {:?}->{:?} gets a new counter: {}", + NESTED_INDENT.repeat(debug_indent_level), + from_bcb, + to_bcb, + self.format_counter(&counter_kind) + ); + self.basic_coverage_blocks[to_bcb] + .set_edge_counter_from(from_bcb, counter_kind)? + } + } else { + self.recursive_get_or_make_counter_operand( + from_bcb, + collect_intermediate_expressions, + debug_indent_level + 1, + )? + } + }) + } + + /// Select a branch for the expression, either the recommended `reloop_branch`, or + /// if none was found, select any branch. + fn choose_preferred_expression_branch( + &self, + traversal: &TraverseCoverageGraphWithLoops, + branches: &Vec, + ) -> BcbBranch { + let branch_needs_a_counter = + |branch: &BcbBranch| branch.counter(&self.basic_coverage_blocks).is_none(); + + let some_reloop_branch = self.find_some_reloop_branch(traversal, &branches); + if let Some(reloop_branch_without_counter) = + some_reloop_branch.filter(branch_needs_a_counter) + { + debug!( + "Selecting reloop_branch={:?} that still needs a counter, to get the \ + `Expression`", + reloop_branch_without_counter + ); + reloop_branch_without_counter + } else { + let &branch_without_counter = branches + .iter() + .find(|&&branch| branch.counter(&self.basic_coverage_blocks).is_none()) + .expect( + "needs_branch_counters was `true` so there should be at least one \ + branch", + ); + debug!( + "Selecting any branch={:?} that still needs a counter, to get the \ + `Expression` because there was no `reloop_branch`, or it already had a \ + counter", + branch_without_counter + ); + branch_without_counter + } + } + + /// At most one of the branches (or its edge, from the branching_bcb, + /// if the branch has multiple incoming edges) can have a counter computed by + /// expression. + /// + /// If at least one of the branches leads outside of a loop (`found_loop_exit` is + /// true), and at least one other branch does not exit the loop (the first of which + /// is captured in `some_reloop_branch`), it's likely any reloop branch will be + /// executed far more often than loop exit branch, making the reloop branch a better + /// candidate for an expression. + fn find_some_reloop_branch( + &self, + traversal: &TraverseCoverageGraphWithLoops, + branches: &Vec, + ) -> Option { + let branch_needs_a_counter = + |branch: &BcbBranch| branch.counter(&self.basic_coverage_blocks).is_none(); + + let mut some_reloop_branch: Option = None; + for context in traversal.context_stack.iter().rev() { + if let Some((backedge_from_bcbs, _)) = &context.loop_backedges { + let mut found_loop_exit = false; + for &branch in branches.iter() { + if backedge_from_bcbs.iter().any(|&backedge_from_bcb| { + self.bcb_is_dominated_by(backedge_from_bcb, branch.target_bcb) + }) { + if let Some(reloop_branch) = some_reloop_branch { + if reloop_branch.counter(&self.basic_coverage_blocks).is_none() { + // we already found a candidate reloop_branch that still + // needs a counter + continue; + } + } + // The path from branch leads back to the top of the loop. Set this + // branch as the `reloop_branch`. If this branch already has a + // counter, and we find another reloop branch that doesn't have a + // counter yet, that branch will be selected as the `reloop_branch` + // instead. + some_reloop_branch = Some(branch); + } else { + // The path from branch leads outside this loop + found_loop_exit = true; + } + if found_loop_exit + && some_reloop_branch.filter(branch_needs_a_counter).is_some() + { + // Found both a branch that exits the loop and a branch that returns + // to the top of the loop (`reloop_branch`), and the `reloop_branch` + // doesn't already have a counter. + break; + } + } + if !found_loop_exit { + debug!( + "No branches exit the loop, so any branch without an existing \ + counter can have the `Expression`." + ); + break; + } + if some_reloop_branch.is_some() { + debug!( + "Found a branch that exits the loop and a branch the loops back to \ + the top of the loop (`reloop_branch`). The `reloop_branch` will \ + get the `Expression`, as long as it still needs a counter." + ); + break; + } + // else all branches exited this loop context, so run the same checks with + // the outer loop(s) + } + } + some_reloop_branch + } + + #[inline] + fn bcb_predecessors(&self, bcb: BasicCoverageBlock) -> &Vec { + &self.basic_coverage_blocks.predecessors[bcb] + } + + #[inline] + fn bcb_successors(&self, bcb: BasicCoverageBlock) -> &Vec { + &self.basic_coverage_blocks.successors[bcb] + } + + #[inline] + fn bcb_branches(&self, from_bcb: BasicCoverageBlock) -> Vec { + self.bcb_successors(from_bcb) + .iter() + .map(|&to_bcb| BcbBranch::from_to(from_bcb, to_bcb, &self.basic_coverage_blocks)) + .collect::>() + } + + fn bcb_needs_branch_counters(&self, bcb: BasicCoverageBlock) -> bool { + let branch_needs_a_counter = + |branch: &BcbBranch| branch.counter(&self.basic_coverage_blocks).is_none(); + let branches = self.bcb_branches(bcb); + branches.len() > 1 && branches.iter().any(branch_needs_a_counter) + } + + /// Returns true if the BasicCoverageBlock has zero or one incoming edge. (If zero, it should be + /// the entry point for the function.) + #[inline] + fn bcb_has_one_path_to_target(&self, bcb: BasicCoverageBlock) -> bool { + self.bcb_predecessors(bcb).len() <= 1 + } + + #[inline] + fn bcb_is_dominated_by(&self, node: BasicCoverageBlock, dom: BasicCoverageBlock) -> bool { + self.basic_coverage_blocks.is_dominated_by(node, dom) + } + + #[inline] + fn format_counter(&self, counter_kind: &CoverageKind) -> String { + self.coverage_counters.debug_counters.format_counter(counter_kind) + } +} diff --git a/compiler/rustc_mir/src/transform/coverage/debug.rs b/compiler/rustc_mir/src/transform/coverage/debug.rs index fbf2ad224a82..7080975aee5c 100644 --- a/compiler/rustc_mir/src/transform/coverage/debug.rs +++ b/compiler/rustc_mir/src/transform/coverage/debug.rs @@ -13,6 +13,8 @@ use rustc_middle::ty::TyCtxt; use std::lazy::SyncOnceCell; +pub const NESTED_INDENT: &str = " "; + const RUSTC_COVERAGE_DEBUG_OPTIONS: &str = "RUSTC_COVERAGE_DEBUG_OPTIONS"; pub(crate) fn debug_options<'a>() -> &'a DebugOptions { @@ -24,20 +26,29 @@ pub(crate) fn debug_options<'a>() -> &'a DebugOptions { /// Parses and maintains coverage-specific debug options captured from the environment variable /// "RUSTC_COVERAGE_DEBUG_OPTIONS", if set. Options can be set on the command line by, for example: /// -/// $ RUSTC_COVERAGE_DEBUG_OPTIONS=counter-format=block cargo build +/// $ RUSTC_COVERAGE_DEBUG_OPTIONS=counter-format=block,allow_unused_expressions=n cargo build #[derive(Debug, Clone)] pub(crate) struct DebugOptions { + pub allow_unused_expressions: bool, counter_format: ExpressionFormat, } impl DebugOptions { fn new() -> Self { + let mut allow_unused_expressions = true; let mut counter_format = ExpressionFormat::default(); if let Ok(env_debug_options) = std::env::var(RUSTC_COVERAGE_DEBUG_OPTIONS) { for setting_str in env_debug_options.replace(" ", "").replace("-", "_").split(",") { let mut setting = setting_str.splitn(2, "="); match setting.next() { + Some(option) if option == "allow_unused_expressions" => { + allow_unused_expressions = bool_option_val(option, setting.next()); + debug!( + "{} env option `allow_unused_expressions` is set to {}", + RUSTC_COVERAGE_DEBUG_OPTIONS, allow_unused_expressions + ); + } Some(option) if option == "counter_format" => { if let Some(strval) = setting.next() { counter_format = counter_format_option_val(strval); @@ -66,7 +77,26 @@ impl DebugOptions { } } - Self { counter_format } + Self { allow_unused_expressions, counter_format } + } +} + +fn bool_option_val(option: &str, some_strval: Option<&str>) -> bool { + if let Some(val) = some_strval { + if vec!["yes", "y", "on", "true"].contains(&val) { + true + } else if vec!["no", "n", "off", "false"].contains(&val) { + false + } else { + bug!( + "Unsupported value `{}` for option `{}` in environment variable {}", + option, + val, + RUSTC_COVERAGE_DEBUG_OPTIONS + ) + } + } else { + true } } @@ -147,6 +177,14 @@ impl DebugCounters { } } + pub fn some_block_label(&self, operand: ExpressionOperandId) -> Option<&String> { + self.some_counters.as_ref().map_or(None, |counters| { + counters + .get(&operand) + .map_or(None, |debug_counter| debug_counter.some_block_label.as_ref()) + }) + } + pub fn format_counter(&self, counter_kind: &CoverageKind) -> String { match *counter_kind { CoverageKind::Counter { .. } => { @@ -242,16 +280,22 @@ impl DebugCounter { pub(crate) struct GraphvizData { some_bcb_to_coverage_spans_with_counters: Option>>, + some_bcb_to_dependency_counters: Option>>, some_edge_to_counter: Option>, } impl GraphvizData { pub fn new() -> Self { - Self { some_bcb_to_coverage_spans_with_counters: None, some_edge_to_counter: None } + Self { + some_bcb_to_coverage_spans_with_counters: None, + some_bcb_to_dependency_counters: None, + some_edge_to_counter: None, + } } pub fn enable(&mut self) { self.some_bcb_to_coverage_spans_with_counters = Some(FxHashMap::default()); + self.some_bcb_to_dependency_counters = Some(FxHashMap::default()); self.some_edge_to_counter = Some(FxHashMap::default()); } @@ -287,6 +331,187 @@ impl GraphvizData { None } } + + pub fn add_bcb_dependency_counter( + &mut self, + bcb: BasicCoverageBlock, + counter_kind: &CoverageKind, + ) { + if let Some(bcb_to_dependency_counters) = self.some_bcb_to_dependency_counters.as_mut() { + bcb_to_dependency_counters + .entry(bcb) + .or_insert_with(|| Vec::new()) + .push(counter_kind.clone()); + } + } + + pub fn get_bcb_dependency_counters( + &self, + bcb: BasicCoverageBlock, + ) -> Option<&Vec> { + if let Some(bcb_to_dependency_counters) = self.some_bcb_to_dependency_counters.as_ref() { + bcb_to_dependency_counters.get(&bcb) + } else { + None + } + } + + pub fn set_edge_counter( + &mut self, + from_bcb: BasicCoverageBlock, + to_bb: BasicBlock, + counter_kind: &CoverageKind, + ) { + if let Some(edge_to_counter) = self.some_edge_to_counter.as_mut() { + edge_to_counter.insert((from_bcb, to_bb), counter_kind.clone()).expect_none( + "invalid attempt to insert more than one edge counter for the same edge", + ); + } + } + + pub fn get_edge_counter( + &self, + from_bcb: BasicCoverageBlock, + to_bb: BasicBlock, + ) -> Option<&CoverageKind> { + if let Some(edge_to_counter) = self.some_edge_to_counter.as_ref() { + edge_to_counter.get(&(from_bcb, to_bb)) + } else { + None + } + } +} + +/// If enabled, this struct captures additional data used to track whether expressions were used, +/// directly or indirectly, to compute the coverage counts for all `CoverageSpan`s, and any that are +/// _not_ used are retained in the `unused_expressions` Vec, to be included in debug output (logs +/// and/or a `CoverageGraph` graphviz output). +pub(crate) struct UsedExpressions { + some_used_expression_operands: + Option>>, + some_unused_expressions: + Option, BasicCoverageBlock)>>, +} + +impl UsedExpressions { + pub fn new() -> Self { + Self { some_used_expression_operands: None, some_unused_expressions: None } + } + + pub fn enable(&mut self) { + self.some_used_expression_operands = Some(FxHashMap::default()); + self.some_unused_expressions = Some(Vec::new()); + } + + pub fn is_enabled(&mut self) -> bool { + self.some_used_expression_operands.is_some() + } + + pub fn add_expression_operands(&mut self, expression: &CoverageKind) { + if let Some(used_expression_operands) = self.some_used_expression_operands.as_mut() { + if let CoverageKind::Expression { id, lhs, rhs, .. } = *expression { + used_expression_operands.entry(lhs).or_insert_with(|| Vec::new()).push(id); + used_expression_operands.entry(rhs).or_insert_with(|| Vec::new()).push(id); + } + } + } + + pub fn expression_is_used(&mut self, expression: &CoverageKind) -> bool { + if let Some(used_expression_operands) = self.some_used_expression_operands.as_ref() { + used_expression_operands.contains_key(&expression.as_operand_id()) + } else { + false + } + } + + pub fn add_unused_expression_if_not_found( + &mut self, + expression: &CoverageKind, + edge_from_bcb: Option, + target_bcb: BasicCoverageBlock, + ) { + if let Some(used_expression_operands) = self.some_used_expression_operands.as_ref() { + if !used_expression_operands.contains_key(&expression.as_operand_id()) { + self.some_unused_expressions.as_mut().unwrap().push(( + expression.clone(), + edge_from_bcb, + target_bcb, + )); + } + } + } + + /// Return the list of unused counters (if any) as a tuple with the counter (`CoverageKind`), + /// optional `from_bcb` (if it was an edge counter), and `target_bcb`. + pub fn get_unused_expressions( + &self, + ) -> Vec<(CoverageKind, Option, BasicCoverageBlock)> { + if let Some(unused_expressions) = self.some_unused_expressions.as_ref() { + unused_expressions.clone() + } else { + Vec::new() + } + } + + /// If enabled, validate that every BCB or edge counter not directly associated with a coverage + /// span is at least indirectly associated (it is a dependency of a BCB counter that _is_ + /// associated with a coverage span). + pub fn validate( + &mut self, + bcb_counters_without_direct_coverage_spans: &Vec<( + Option, + BasicCoverageBlock, + CoverageKind, + )>, + ) { + if self.is_enabled() { + let mut not_validated = bcb_counters_without_direct_coverage_spans + .iter() + .map(|(_, _, counter_kind)| counter_kind) + .collect::>(); + let mut validating_count = 0; + while not_validated.len() != validating_count { + let to_validate = not_validated.split_off(0); + validating_count = to_validate.len(); + for counter_kind in to_validate { + if self.expression_is_used(counter_kind) { + self.add_expression_operands(counter_kind); + } else { + not_validated.push(counter_kind); + } + } + } + } + } + + pub fn alert_on_unused_expressions(&self, debug_counters: &DebugCounters) { + if let Some(unused_expressions) = self.some_unused_expressions.as_ref() { + for (counter_kind, edge_from_bcb, target_bcb) in unused_expressions { + let unused_counter_message = if let Some(from_bcb) = edge_from_bcb.as_ref() { + format!( + "non-coverage edge counter found without a dependent expression, in \ + {:?}->{:?}; counter={}", + from_bcb, + target_bcb, + debug_counters.format_counter(&counter_kind), + ) + } else { + format!( + "non-coverage counter found without a dependent expression, in {:?}; \ + counter={}", + target_bcb, + debug_counters.format_counter(&counter_kind), + ) + }; + + if debug_options().allow_unused_expressions { + debug!("WARNING: {}", unused_counter_message); + } else { + bug!("{}", unused_counter_message); + } + } + } + } } /// Generates the MIR pass `CoverageSpan`-specific spanview dump file. @@ -337,6 +562,8 @@ pub(crate) fn dump_coverage_graphviz( basic_coverage_blocks: &CoverageGraph, debug_counters: &DebugCounters, graphviz_data: &GraphvizData, + intermediate_expressions: &Vec, + debug_used_expressions: &UsedExpressions, ) { let mir_source = mir_body.source; let def_id = mir_source.def_id(); @@ -347,21 +574,62 @@ pub(crate) fn dump_coverage_graphviz( debug_counters, &basic_coverage_blocks[bcb], graphviz_data.get_bcb_coverage_spans_with_counters(bcb), + graphviz_data.get_bcb_dependency_counters(bcb), + // intermediate_expressions are injected into the mir::START_BLOCK, so + // include them in the first BCB. + if bcb.index() == 0 { Some(&intermediate_expressions) } else { None }, ) }; let edge_labels = |from_bcb| { let from_bcb_data = &basic_coverage_blocks[from_bcb]; let from_terminator = from_bcb_data.terminator(mir_body); - from_terminator - .kind - .fmt_successor_labels() + let mut edge_labels = from_terminator.kind.fmt_successor_labels(); + edge_labels.retain(|label| label.to_string() != "unreachable"); + let edge_counters = from_terminator + .successors() + .map(|&successor_bb| graphviz_data.get_edge_counter(from_bcb, successor_bb)); + edge_labels .iter() - .map(|label| label.to_string()) + .zip(edge_counters) + .map(|(label, some_counter)| { + if let Some(counter) = some_counter { + format!("{}\n{}", label, debug_counters.format_counter(counter)) + } else { + label.to_string() + } + }) .collect::>() }; let graphviz_name = format!("Cov_{}_{}", def_id.krate.index(), def_id.index.index()); - let graphviz_writer = + let mut graphviz_writer = GraphvizWriter::new(basic_coverage_blocks, &graphviz_name, node_content, edge_labels); + let unused_expressions = debug_used_expressions.get_unused_expressions(); + if unused_expressions.len() > 0 { + graphviz_writer.set_graph_label(&format!( + "Unused expressions:\n {}", + unused_expressions + .as_slice() + .iter() + .map(|(counter_kind, edge_from_bcb, target_bcb)| { + if let Some(from_bcb) = edge_from_bcb.as_ref() { + format!( + "{:?}->{:?}: {}", + from_bcb, + target_bcb, + debug_counters.format_counter(&counter_kind), + ) + } else { + format!( + "{:?}: {}", + target_bcb, + debug_counters.format_counter(&counter_kind), + ) + } + }) + .collect::>() + .join("\n ") + )); + } let mut file = pretty::create_dump_file(tcx, "dot", None, pass_name, &0, mir_source) .expect("Unexpected error creating BasicCoverageBlock graphviz DOT file"); graphviz_writer @@ -375,9 +643,22 @@ fn bcb_to_string_sections( debug_counters: &DebugCounters, bcb_data: &BasicCoverageBlockData, some_coverage_spans_with_counters: Option<&Vec<(CoverageSpan, CoverageKind)>>, + some_dependency_counters: Option<&Vec>, + some_intermediate_expressions: Option<&Vec>, ) -> Vec { let len = bcb_data.basic_blocks.len(); let mut sections = Vec::new(); + if let Some(collect_intermediate_expressions) = some_intermediate_expressions { + sections.push( + collect_intermediate_expressions + .iter() + .map(|expression| { + format!("Intermediate {}", debug_counters.format_counter(expression)) + }) + .collect::>() + .join("\n"), + ); + } if let Some(coverage_spans_with_counters) = some_coverage_spans_with_counters { sections.push( coverage_spans_with_counters @@ -393,6 +674,19 @@ fn bcb_to_string_sections( .join("\n"), ); } + if let Some(dependency_counters) = some_dependency_counters { + sections.push(format!( + "Non-coverage counters:\n {}", + dependency_counters + .iter() + .map(|counter| debug_counters.format_counter(counter)) + .collect::>() + .join(" \n"), + )); + } + if let Some(counter_kind) = &bcb_data.counter_kind { + sections.push(format!("{:?}", counter_kind)); + } let non_term_blocks = bcb_data.basic_blocks[0..len - 1] .iter() .map(|&bb| format!("{:?}: {}", bb, term_type(&mir_body[bb].terminator().kind))) diff --git a/compiler/rustc_mir/src/transform/coverage/graph.rs b/compiler/rustc_mir/src/transform/coverage/graph.rs index 3d3e76f907b6..840625417019 100644 --- a/compiler/rustc_mir/src/transform/coverage/graph.rs +++ b/compiler/rustc_mir/src/transform/coverage/graph.rs @@ -1,7 +1,11 @@ +use super::Error; + +use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::graph::dominators::{self, Dominators}; -use rustc_data_structures::graph::{self, GraphSuccessors, WithNumNodes}; +use rustc_data_structures::graph::{self, GraphSuccessors, WithNumNodes, WithStartNode}; use rustc_index::bit_set::BitSet; use rustc_index::vec::IndexVec; +use rustc_middle::mir::coverage::*; use rustc_middle::mir::{self, BasicBlock, BasicBlockData, Terminator, TerminatorKind}; use std::ops::{Index, IndexMut}; @@ -183,6 +187,13 @@ impl CoverageGraph { self.bcbs.iter_enumerated() } + #[inline(always)] + pub fn iter_enumerated_mut( + &mut self, + ) -> impl Iterator { + self.bcbs.iter_enumerated_mut() + } + #[inline(always)] pub fn bcb_from_bb(&self, bb: BasicBlock) -> Option { if bb.index() < self.bb_to_bcb.len() { self.bb_to_bcb[bb] } else { None } @@ -293,12 +304,14 @@ rustc_index::newtype_index! { #[derive(Debug, Clone)] pub(crate) struct BasicCoverageBlockData { pub basic_blocks: Vec, + pub counter_kind: Option, + edge_from_bcbs: Option>, } impl BasicCoverageBlockData { pub fn from(basic_blocks: Vec) -> Self { assert!(basic_blocks.len() > 0); - Self { basic_blocks } + Self { basic_blocks, counter_kind: None, edge_from_bcbs: None } } #[inline(always)] @@ -316,6 +329,91 @@ impl BasicCoverageBlockData { &mir_body[self.last_bb()].terminator() } + #[inline(always)] + pub fn set_counter( + &mut self, + counter_kind: CoverageKind, + ) -> Result { + debug_assert!( + // If the BCB has an edge counter (to be injected into a new `BasicBlock`), it can also + // have an expression (to be injected into an existing `BasicBlock` represented by this + // `BasicCoverageBlock`). + self.edge_from_bcbs.is_none() || counter_kind.is_expression(), + "attempt to add a `Counter` to a BCB target with existing incoming edge counters" + ); + let operand = counter_kind.as_operand_id(); + let expect_none = self.counter_kind.replace(counter_kind); + if expect_none.is_some() { + return Error::from_string(format!( + "attempt to set a BasicCoverageBlock coverage counter more than once; \ + {:?} already had counter {:?}", + self, + expect_none.unwrap(), + )); + } + Ok(operand) + } + + #[inline(always)] + pub fn counter(&self) -> Option<&CoverageKind> { + self.counter_kind.as_ref() + } + + #[inline(always)] + pub fn take_counter(&mut self) -> Option { + self.counter_kind.take() + } + + #[inline(always)] + pub fn set_edge_counter_from( + &mut self, + from_bcb: BasicCoverageBlock, + counter_kind: CoverageKind, + ) -> Result { + if level_enabled!(tracing::Level::DEBUG) { + // If the BCB has an edge counter (to be injected into a new `BasicBlock`), it can also + // have an expression (to be injected into an existing `BasicBlock` represented by this + // `BasicCoverageBlock`). + if !self.counter_kind.as_ref().map_or(true, |c| c.is_expression()) { + return Error::from_string(format!( + "attempt to add an incoming edge counter from {:?} when the target BCB already \ + has a `Counter`", + from_bcb + )); + } + } + let operand = counter_kind.as_operand_id(); + let expect_none = self + .edge_from_bcbs + .get_or_insert_with(|| FxHashMap::default()) + .insert(from_bcb, counter_kind); + if expect_none.is_some() { + return Error::from_string(format!( + "attempt to set an edge counter more than once; from_bcb: \ + {:?} already had counter {:?}", + from_bcb, + expect_none.unwrap(), + )); + } + Ok(operand) + } + + #[inline(always)] + pub fn edge_counter_from(&self, from_bcb: BasicCoverageBlock) -> Option<&CoverageKind> { + if let Some(edge_from_bcbs) = &self.edge_from_bcbs { + edge_from_bcbs.get(&from_bcb) + } else { + None + } + } + + #[inline(always)] + pub fn take_edge_counters( + &mut self, + ) -> Option> { + self.edge_from_bcbs.take().map_or(None, |m| Some(m.into_iter())) + } + pub fn id(&self) -> String { format!( "@{}", @@ -328,6 +426,56 @@ impl BasicCoverageBlockData { } } +/// Represents a successor from a branching BasicCoverageBlock (such as the arms of a `SwitchInt`) +/// as either the successor BCB itself, if it has only one incoming edge, or the successor _plus_ +/// the specific branching BCB, representing the edge between the two. The latter case +/// distinguishes this incoming edge from other incoming edges to the same `target_bcb`. +#[derive(Clone, Copy, PartialEq, Eq)] +pub(crate) struct BcbBranch { + pub edge_from_bcb: Option, + pub target_bcb: BasicCoverageBlock, +} + +impl BcbBranch { + pub fn from_to( + from_bcb: BasicCoverageBlock, + to_bcb: BasicCoverageBlock, + basic_coverage_blocks: &CoverageGraph, + ) -> Self { + let edge_from_bcb = if basic_coverage_blocks.predecessors[to_bcb].len() > 1 { + Some(from_bcb) + } else { + None + }; + Self { edge_from_bcb, target_bcb: to_bcb } + } + + pub fn counter<'a>( + &self, + basic_coverage_blocks: &'a CoverageGraph, + ) -> Option<&'a CoverageKind> { + if let Some(from_bcb) = self.edge_from_bcb { + basic_coverage_blocks[self.target_bcb].edge_counter_from(from_bcb) + } else { + basic_coverage_blocks[self.target_bcb].counter() + } + } + + pub fn is_only_path_to_target(&self) -> bool { + self.edge_from_bcb.is_none() + } +} + +impl std::fmt::Debug for BcbBranch { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + if let Some(from_bcb) = self.edge_from_bcb { + write!(fmt, "{:?}->{:?}", from_bcb, self.target_bcb) + } else { + write!(fmt, "{:?}", self.target_bcb) + } + } +} + fn bcb_filtered_successors<'a, 'tcx>( body: &'tcx &'a mir::Body<'tcx>, term_kind: &'tcx TerminatorKind<'tcx>, @@ -344,6 +492,175 @@ fn bcb_filtered_successors<'a, 'tcx>( .filter(move |&&successor| body[successor].terminator().kind != TerminatorKind::Unreachable) } +/// Maintains separate worklists for each loop in the BasicCoverageBlock CFG, plus one for the +/// CoverageGraph outside all loops. This supports traversing the BCB CFG in a way that +/// ensures a loop is completely traversed before processing Blocks after the end of the loop. +#[derive(Debug)] +pub(crate) struct TraversalContext { + /// From one or more backedges returning to a loop header. + pub loop_backedges: Option<(Vec, BasicCoverageBlock)>, + + /// worklist, to be traversed, of CoverageGraph in the loop with the given loop + /// backedges, such that the loop is the inner inner-most loop containing these + /// CoverageGraph + pub worklist: Vec, +} + +pub(crate) struct TraverseCoverageGraphWithLoops { + pub backedges: IndexVec>, + pub context_stack: Vec, + visited: BitSet, +} + +impl TraverseCoverageGraphWithLoops { + pub fn new(basic_coverage_blocks: &CoverageGraph) -> Self { + let start_bcb = basic_coverage_blocks.start_node(); + let backedges = find_loop_backedges(basic_coverage_blocks); + let mut context_stack = Vec::new(); + context_stack.push(TraversalContext { loop_backedges: None, worklist: vec![start_bcb] }); + // `context_stack` starts with a `TraversalContext` for the main function context (beginning + // with the `start` BasicCoverageBlock of the function). New worklists are pushed to the top + // of the stack as loops are entered, and popped off of the stack when a loop's worklist is + // exhausted. + let visited = BitSet::new_empty(basic_coverage_blocks.num_nodes()); + Self { backedges, context_stack, visited } + } + + pub fn next(&mut self, basic_coverage_blocks: &CoverageGraph) -> Option { + debug!( + "TraverseCoverageGraphWithLoops::next - context_stack: {:?}", + self.context_stack.iter().rev().collect::>() + ); + while let Some(next_bcb) = { + // Strip contexts with empty worklists from the top of the stack + while self.context_stack.last().map_or(false, |context| context.worklist.is_empty()) { + self.context_stack.pop(); + } + // Pop the next bcb off of the current context_stack. If none, all BCBs were visited. + self.context_stack.last_mut().map_or(None, |context| context.worklist.pop()) + } { + if !self.visited.insert(next_bcb) { + debug!("Already visited: {:?}", next_bcb); + continue; + } + debug!("Visiting {:?}", next_bcb); + if self.backedges[next_bcb].len() > 0 { + debug!("{:?} is a loop header! Start a new TraversalContext...", next_bcb); + self.context_stack.push(TraversalContext { + loop_backedges: Some((self.backedges[next_bcb].clone(), next_bcb)), + worklist: Vec::new(), + }); + } + self.extend_worklist(basic_coverage_blocks, next_bcb); + return Some(next_bcb); + } + None + } + + pub fn extend_worklist( + &mut self, + basic_coverage_blocks: &CoverageGraph, + bcb: BasicCoverageBlock, + ) { + let successors = &basic_coverage_blocks.successors[bcb]; + debug!("{:?} has {} successors:", bcb, successors.len()); + for &successor in successors { + if successor == bcb { + debug!( + "{:?} has itself as its own successor. (Note, the compiled code will \ + generate an infinite loop.)", + bcb + ); + // Don't re-add this successor to the worklist. We are already processing it. + break; + } + for context in self.context_stack.iter_mut().rev() { + // Add successors of the current BCB to the appropriate context. Successors that + // stay within a loop are added to the BCBs context worklist. Successors that + // exit the loop (they are not dominated by the loop header) must be reachable + // from other BCBs outside the loop, and they will be added to a different + // worklist. + // + // Branching blocks (with more than one successor) must be processed before + // blocks with only one successor, to prevent unnecessarily complicating + // `Expression`s by creating a Counter in a `BasicCoverageBlock` that the + // branching block would have given an `Expression` (or vice versa). + let (some_successor_to_add, some_loop_header) = + if let Some((_, loop_header)) = context.loop_backedges { + if basic_coverage_blocks.is_dominated_by(successor, loop_header) { + (Some(successor), Some(loop_header)) + } else { + (None, None) + } + } else { + (Some(successor), None) + }; + if let Some(successor_to_add) = some_successor_to_add { + if basic_coverage_blocks.successors[successor_to_add].len() > 1 { + debug!( + "{:?} successor is branching. Prioritize it at the beginning of \ + the {}", + successor_to_add, + if let Some(loop_header) = some_loop_header { + format!("worklist for the loop headed by {:?}", loop_header) + } else { + String::from("non-loop worklist") + }, + ); + context.worklist.insert(0, successor_to_add); + } else { + debug!( + "{:?} successor is non-branching. Defer it to the end of the {}", + successor_to_add, + if let Some(loop_header) = some_loop_header { + format!("worklist for the loop headed by {:?}", loop_header) + } else { + String::from("non-loop worklist") + }, + ); + context.worklist.push(successor_to_add); + } + break; + } + } + } + } + + pub fn is_complete(&self) -> bool { + self.visited.count() == self.visited.domain_size() + } + + pub fn unvisited(&self) -> Vec { + let mut unvisited_set: BitSet = + BitSet::new_filled(self.visited.domain_size()); + unvisited_set.subtract(&self.visited); + unvisited_set.iter().collect::>() + } +} + +fn find_loop_backedges( + basic_coverage_blocks: &CoverageGraph, +) -> IndexVec> { + let num_bcbs = basic_coverage_blocks.num_nodes(); + let mut backedges = IndexVec::from_elem_n(Vec::::new(), num_bcbs); + + // Identify loops by their backedges + for (bcb, _) in basic_coverage_blocks.iter_enumerated() { + for &successor in &basic_coverage_blocks.successors[bcb] { + if basic_coverage_blocks.is_dominated_by(bcb, successor) { + let loop_header = successor; + let backedge_from_bcb = bcb; + debug!( + "Found BCB backedge: {:?} -> loop_header: {:?}", + backedge_from_bcb, loop_header + ); + backedges[loop_header].push(backedge_from_bcb); + } + } + } + backedges +} + pub struct ShortCircuitPreorder< 'a, 'tcx, diff --git a/compiler/rustc_mir/src/transform/coverage/mod.rs b/compiler/rustc_mir/src/transform/coverage/mod.rs index d1d94092c9de..c84ccf19213b 100644 --- a/compiler/rustc_mir/src/transform/coverage/mod.rs +++ b/compiler/rustc_mir/src/transform/coverage/mod.rs @@ -6,7 +6,7 @@ mod graph; mod spans; use counters::CoverageCounters; -use graph::CoverageGraph; +use graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph}; use spans::{CoverageSpan, CoverageSpans}; use crate::transform::MirPass; @@ -21,11 +21,26 @@ use rustc_middle::hir; use rustc_middle::hir::map::blocks::FnLikeNode; use rustc_middle::ich::StableHashingContext; use rustc_middle::mir::coverage::*; -use rustc_middle::mir::{self, BasicBlock, Coverage, Statement, StatementKind}; +use rustc_middle::mir::{ + self, BasicBlock, BasicBlockData, Coverage, SourceInfo, Statement, StatementKind, Terminator, + TerminatorKind, +}; use rustc_middle::ty::TyCtxt; use rustc_span::def_id::DefId; use rustc_span::{CharPos, Pos, SourceFile, Span, Symbol}; +/// A simple error message wrapper for `coverage::Error`s. +#[derive(Debug)] +pub(crate) struct Error { + message: String, +} + +impl Error { + pub fn from_string(message: String) -> Result { + Err(Self { message }) + } +} + /// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected /// counters, via intrinsic `llvm.instrprof.increment`, and/or inject metadata used during codegen /// to construct the coverage map. @@ -104,6 +119,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span)); let mut graphviz_data = debug::GraphvizData::new(); + let mut debug_used_expressions = debug::UsedExpressions::new(); let dump_graphviz = tcx.sess.opts.debugging_opts.dump_mir_graphviz; if dump_graphviz { @@ -111,6 +127,10 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { self.coverage_counters.enable_debug(); } + if dump_graphviz || level_enabled!(tracing::Level::DEBUG) { + debug_used_expressions.enable(); + } + //////////////////////////////////////////////////// // Compute `CoverageSpan`s from the `CoverageGraph`. let coverage_spans = CoverageSpans::generate_coverage_spans( @@ -129,7 +149,53 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { ); } - self.inject_coverage_span_counters(coverage_spans, &mut graphviz_data); + //////////////////////////////////////////////////// + // Create an optimized mix of `Counter`s and `Expression`s for the `CoverageGraph`. Ensure + // every `CoverageSpan` has a `Counter` or `Expression` assigned to its `BasicCoverageBlock` + // and all `Expression` dependencies (operands) are also generated, for any other + // `BasicCoverageBlock`s not already associated with a `CoverageSpan`. + // + // Intermediate expressions (used to compute other `Expression` values), which have no + // direct associate to any `BasicCoverageBlock`, are returned in the method `Result`. + let intermediate_expressions_or_error = self + .coverage_counters + .make_bcb_counters(&mut self.basic_coverage_blocks, &coverage_spans); + + let (result, intermediate_expressions) = match intermediate_expressions_or_error { + Ok(intermediate_expressions) => { + // If debugging, add any intermediate expressions (which are not associated with any + // BCB) to the `debug_used_expressions` map. + if debug_used_expressions.is_enabled() { + for intermediate_expression in &intermediate_expressions { + debug_used_expressions.add_expression_operands(intermediate_expression); + } + } + + //////////////////////////////////////////////////// + // Remove the counter or edge counter from of each `CoverageSpan`s associated + // `BasicCoverageBlock`, and inject a `Coverage` statement into the MIR. + self.inject_coverage_span_counters( + coverage_spans, + &mut graphviz_data, + &mut debug_used_expressions, + ); + + //////////////////////////////////////////////////// + // For any remaining `BasicCoverageBlock` counters (that were not associated with + // any `CoverageSpan`), inject `Coverage` statements (_without_ code region `Span`s) + // to ensure `BasicCoverageBlock` counters that other `Expression`s may depend on + // are in fact counted, even though they don't directly contribute to counting + // their own independent code region's coverage. + self.inject_indirect_counters(&mut graphviz_data, &mut debug_used_expressions); + + // Intermediate expressions will be injected as the final step, after generating + // debug output, if any. + //////////////////////////////////////////////////// + + (Ok(()), intermediate_expressions) + } + Err(e) => (Err(e), Vec::new()), + }; if graphviz_data.is_enabled() { // Even if there was an error, a partial CoverageGraph can still generate a useful @@ -141,19 +207,40 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { &self.basic_coverage_blocks, &self.coverage_counters.debug_counters, &graphviz_data, + &intermediate_expressions, + &debug_used_expressions, ); } + + if let Err(e) = result { + bug!("Error processing: {:?}: {:?}", self.mir_body.source.def_id(), e) + }; + + // Depending on current `debug_options()`, `alert_on_unused_expressions()` could panic, so + // this check is performed as late as possible, to allow other debug output (logs and dump + // files), which might be helpful in analyzing unused expressions, to still be generated. + debug_used_expressions.alert_on_unused_expressions(&self.coverage_counters.debug_counters); + + //////////////////////////////////////////////////// + // Finally, inject the intermediate expressions collected along the way. + for intermediate_expression in intermediate_expressions { + inject_intermediate_expression(self.mir_body, intermediate_expression); + } } /// Inject a counter for each `CoverageSpan`. There can be multiple `CoverageSpan`s for a given - /// BCB, but only one actual counter needs to be incremented per BCB. `bcb_counters` maps each + /// BCB, but only one actual counter needs to be incremented per BCB. `bb_counters` maps each /// `bcb` to its `Counter`, when injected. Subsequent `CoverageSpan`s for a BCB that already has /// a `Counter` will inject an `Expression` instead, and compute its value by adding `ZERO` to /// the BCB `Counter` value. + /// + /// If debugging, add every BCB `Expression` associated with a `CoverageSpan`s to the + /// `used_expression_operands` map. fn inject_coverage_span_counters( &mut self, coverage_spans: Vec, graphviz_data: &mut debug::GraphvizData, + debug_used_expressions: &mut debug::UsedExpressions, ) { let tcx = self.tcx; let source_map = tcx.sess.source_map(); @@ -165,40 +252,194 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { for covspan in coverage_spans { let bcb = covspan.bcb; let span = covspan.span; - if let Some(&counter_operand) = bcb_counters[bcb].as_ref() { - let expression = self.coverage_counters.make_expression( - counter_operand, - Op::Add, - ExpressionOperandId::ZERO, - || Some(format!("{:?}", bcb)), - ); - debug!( - "Injecting counter expression {:?} at: {:?}:\n{}\n==========", - expression, - span, - source_map.span_to_snippet(span).expect("Error getting source for span"), - ); - graphviz_data.add_bcb_coverage_span_with_counter(bcb, &covspan, &expression); - let bb = self.basic_coverage_blocks[bcb].leader_bb(); - let code_region = make_code_region(file_name, &source_file, span, body_span); - inject_statement(self.mir_body, expression, bb, Some(code_region)); + let counter_kind = if let Some(&counter_operand) = bcb_counters[bcb].as_ref() { + self.coverage_counters.make_identity_counter(counter_operand) + } else if let Some(counter_kind) = self.bcb_data_mut(bcb).take_counter() { + bcb_counters[bcb] = Some(counter_kind.as_operand_id()); + debug_used_expressions.add_expression_operands(&counter_kind); + counter_kind } else { - let counter = self.coverage_counters.make_counter(|| Some(format!("{:?}", bcb))); - debug!( - "Injecting counter {:?} at: {:?}:\n{}\n==========", - counter, - span, - source_map.span_to_snippet(span).expect("Error getting source for span"), - ); - let counter_operand = counter.as_operand_id(); - bcb_counters[bcb] = Some(counter_operand); - graphviz_data.add_bcb_coverage_span_with_counter(bcb, &covspan, &counter); - let bb = self.basic_coverage_blocks[bcb].leader_bb(); - let code_region = make_code_region(file_name, &source_file, span, body_span); - inject_statement(self.mir_body, counter, bb, Some(code_region)); + bug!("Every BasicCoverageBlock should have a Counter or Expression"); + }; + graphviz_data.add_bcb_coverage_span_with_counter(bcb, &covspan, &counter_kind); + let some_code_region = if self.is_code_region_redundant(bcb, span, body_span) { + None + } else { + Some(make_code_region(file_name, &source_file, span, body_span)) + }; + inject_statement(self.mir_body, counter_kind, self.bcb_last_bb(bcb), some_code_region); + } + } + + /// Returns true if the type of `BasicCoverageBlock` (specifically, it's `BasicBlock`s + /// `TerminatorKind`) with the given `Span` (relative to the `body_span`) is known to produce + /// a redundant coverage count. + /// + /// There is at least one case for this, and if it's not handled, the last line in a function + /// will be double-counted. + /// + /// If this method returns `true`, the counter (which other `Expressions` may depend on) is + /// still injected, but without an associated code region. + fn is_code_region_redundant( + &self, + bcb: BasicCoverageBlock, + span: Span, + body_span: Span, + ) -> bool { + if span.hi() == body_span.hi() { + // All functions execute a `Return`-terminated `BasicBlock`, regardless of how the + // function returns; but only some functions also _can_ return after a `Goto` block + // that ends on the closing brace of the function (with the `Return`). When this + // happens, the last character is counted 2 (or possibly more) times, when we know + // the function returned only once (of course). By giving all `Goto` terminators at + // the end of a function a `non-reportable` code region, they are still counted + // if appropriate, but they don't increment the line counter, as long as their is + // also a `Return` on that last line. + if let TerminatorKind::Goto { .. } = self.bcb_terminator(bcb).kind { + return true; + } + } + false + } + + /// `inject_coverage_span_counters()` looped through the `CoverageSpan`s and injected the + /// counter from the `CoverageSpan`s `BasicCoverageBlock`, removing it from the BCB in the + /// process (via `take_counter()`). + /// + /// Any other counter associated with a `BasicCoverageBlock`, or its incoming edge, but not + /// associated with a `CoverageSpan`, should only exist if the counter is a `Expression` + /// dependency (one of the expression operands). Collect them, and inject the additional + /// counters into the MIR, without a reportable coverage span. + fn inject_indirect_counters( + &mut self, + graphviz_data: &mut debug::GraphvizData, + debug_used_expressions: &mut debug::UsedExpressions, + ) { + let mut bcb_counters_without_direct_coverage_spans = Vec::new(); + for (target_bcb, target_bcb_data) in self.basic_coverage_blocks.iter_enumerated_mut() { + if let Some(counter_kind) = target_bcb_data.take_counter() { + bcb_counters_without_direct_coverage_spans.push((None, target_bcb, counter_kind)); + } + if let Some(edge_counters) = target_bcb_data.take_edge_counters() { + for (from_bcb, counter_kind) in edge_counters { + bcb_counters_without_direct_coverage_spans.push(( + Some(from_bcb), + target_bcb, + counter_kind, + )); + } + } + } + + // If debug is enabled, validate that every BCB or edge counter not directly associated + // with a coverage span is at least indirectly associated (it is a dependency of a BCB + // counter that _is_ associated with a coverage span). + debug_used_expressions.validate(&bcb_counters_without_direct_coverage_spans); + + for (edge_from_bcb, target_bcb, counter_kind) in bcb_counters_without_direct_coverage_spans + { + debug_used_expressions.add_unused_expression_if_not_found( + &counter_kind, + edge_from_bcb, + target_bcb, + ); + + match counter_kind { + CoverageKind::Counter { .. } => { + let inject_to_bb = if let Some(from_bcb) = edge_from_bcb { + // The MIR edge starts `from_bb` (the outgoing / last BasicBlock in + // `from_bcb`) and ends at `to_bb` (the incoming / first BasicBlock in the + // `target_bcb`; also called the `leader_bb`). + let from_bb = self.bcb_last_bb(from_bcb); + let to_bb = self.bcb_leader_bb(target_bcb); + + let new_bb = inject_edge_counter_basic_block(self.mir_body, from_bb, to_bb); + graphviz_data.set_edge_counter(from_bcb, new_bb, &counter_kind); + debug!( + "Edge {:?} (last {:?}) -> {:?} (leader {:?}) requires a new MIR \ + BasicBlock {:?}, for unclaimed edge counter {}", + edge_from_bcb, + from_bb, + target_bcb, + to_bb, + new_bb, + self.format_counter(&counter_kind), + ); + new_bb + } else { + let target_bb = self.bcb_last_bb(target_bcb); + graphviz_data.add_bcb_dependency_counter(target_bcb, &counter_kind); + debug!( + "{:?} ({:?}) gets a new Coverage statement for unclaimed counter {}", + target_bcb, + target_bb, + self.format_counter(&counter_kind), + ); + target_bb + }; + + inject_statement(self.mir_body, counter_kind, inject_to_bb, None); + } + CoverageKind::Expression { .. } => { + inject_intermediate_expression(self.mir_body, counter_kind) + } + _ => bug!("CoverageKind should be a counter"), } } } + + #[inline] + fn bcb_leader_bb(&self, bcb: BasicCoverageBlock) -> BasicBlock { + self.bcb_data(bcb).leader_bb() + } + + #[inline] + fn bcb_last_bb(&self, bcb: BasicCoverageBlock) -> BasicBlock { + self.bcb_data(bcb).last_bb() + } + + #[inline] + fn bcb_terminator(&self, bcb: BasicCoverageBlock) -> &Terminator<'tcx> { + self.bcb_data(bcb).terminator(self.mir_body) + } + + #[inline] + fn bcb_data(&self, bcb: BasicCoverageBlock) -> &BasicCoverageBlockData { + &self.basic_coverage_blocks[bcb] + } + + #[inline] + fn bcb_data_mut(&mut self, bcb: BasicCoverageBlock) -> &mut BasicCoverageBlockData { + &mut self.basic_coverage_blocks[bcb] + } + + #[inline] + fn format_counter(&self, counter_kind: &CoverageKind) -> String { + self.coverage_counters.debug_counters.format_counter(counter_kind) + } +} + +fn inject_edge_counter_basic_block( + mir_body: &mut mir::Body<'tcx>, + from_bb: BasicBlock, + to_bb: BasicBlock, +) -> BasicBlock { + let span = mir_body[from_bb].terminator().source_info.span.shrink_to_hi(); + let new_bb = mir_body.basic_blocks_mut().push(BasicBlockData { + statements: vec![], // counter will be injected here + terminator: Some(Terminator { + source_info: SourceInfo::outermost(span), + kind: TerminatorKind::Goto { target: to_bb }, + }), + is_cleanup: false, + }); + let edge_ref = mir_body[from_bb] + .terminator_mut() + .successors_mut() + .find(|successor| **successor == to_bb) + .expect("from_bb should have a successor for to_bb"); + *edge_ref = new_bb; + new_bb } fn inject_statement( @@ -223,6 +464,20 @@ fn inject_statement( data.statements.push(statement); } +// Non-code expressions are injected into the coverage map, without generating executable code. +fn inject_intermediate_expression(mir_body: &mut mir::Body<'tcx>, expression: CoverageKind) { + debug_assert!(if let CoverageKind::Expression { .. } = expression { true } else { false }); + debug!(" injecting non-code expression {:?}", expression); + let inject_in_bb = mir::START_BLOCK; + let data = &mut mir_body[inject_in_bb]; + let source_info = data.terminator().source_info; + let statement = Statement { + source_info, + kind: StatementKind::Coverage(box Coverage { kind: expression, code_region: None }), + }; + data.statements.push(statement); +} + /// Convert the Span into its file name, start line and column, and end line and column fn make_code_region( file_name: Symbol, diff --git a/src/test/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot b/src/test/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot index df9f7aa627b2..efc06bdea57a 100644 --- a/src/test/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot +++ b/src/test/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot @@ -2,5 +2,5 @@ digraph Cov_0_4 { graph [fontname="Courier, monospace"]; node [fontname="Courier, monospace"]; edge [fontname="Courier, monospace"]; - bcb0__Cov_0_4 [shape="none", label=<
bcb0
Counter(bcb0) at 19:5-20:2
19:5-19:9: @0[0]: _0 = const true
20:2-20:2: @0.Return: return
bb0: Return
>]; + bcb0__Cov_0_4 [shape="none", label=<
bcb0
Counter(bcb0) at 19:5-20:2
19:5-19:9: @0[0]: _0 = const true
20:2-20:2: @0.Return: return
bb0: Return
>]; } diff --git a/src/test/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot b/src/test/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot index 051ef498fb7f..5ddd112fe62e 100644 --- a/src/test/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot +++ b/src/test/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot @@ -2,9 +2,9 @@ digraph Cov_0_3 { graph [fontname="Courier, monospace"]; node [fontname="Courier, monospace"]; edge [fontname="Courier, monospace"]; - bcb2__Cov_0_3 [shape="none", label=<
bcb2
Counter(bcb2) at 14:6-14:6
14:6-14:6: @4.Goto: goto -> bb0
bb4: Goto
>]; + bcb2__Cov_0_3 [shape="none", label=<
bcb2
Expression(bcb0 - bcb1) at 14:6-14:6
14:6-14:6: @4.Goto: goto -> bb0
bb4: Goto
>]; bcb1__Cov_0_3 [shape="none", label=<
bcb1
Counter(bcb1) at 12:13-12:18
12:13-12:18: @5[0]: _0 = const ()
Expression(bcb1 + 0) at 15:2-15:2
15:2-15:2: @5.Return: return
bb3: FalseEdge
bb5: Return
>]; - bcb0__Cov_0_3 [shape="none", label=<
bcb0
Counter(bcb0) at 11:12-11:17
11:12-11:17: @1.Call: _2 = bar() -> [return: bb2, unwind: bb6]
11:12-11:17: @2[0]: FakeRead(ForMatchedPlace, _2)
bb0: FalseUnwind
bb1: Call
bb2: SwitchInt
>]; + bcb0__Cov_0_3 [shape="none", label=<
bcb0
Counter(bcb0) at 11:12-11:17
11:12-11:17: @1.Call: _2 = bar() -> [return: bb2, unwind: bb6]
11:12-11:17: @2[0]: FakeRead(ForMatchedPlace, _2)
bb0: FalseUnwind
bb1: Call
bb2: SwitchInt
>]; bcb2__Cov_0_3 -> bcb0__Cov_0_3 [label=<>]; bcb0__Cov_0_3 -> bcb2__Cov_0_3 [label=]; bcb0__Cov_0_3 -> bcb1__Cov_0_3 [label=]; diff --git a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff index ddc65085e809..c67d0e2ffe65 100644 --- a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff +++ b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff @@ -8,7 +8,6 @@ let mut _3: !; // in scope 0 at /the/src/instrument_coverage.rs:12:18: 14:10 bb0: { -+ Coverage::Counter(1) for /the/src/instrument_coverage.rs:12:12 - 12:17; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 falseUnwind -> [real: bb1, cleanup: bb6]; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 } @@ -22,25 +21,26 @@ bb2: { FakeRead(ForMatchedPlace, _2); // scope 0 at /the/src/instrument_coverage.rs:12:12: 12:17 ++ Coverage::Counter(1) for /the/src/instrument_coverage.rs:12:12 - 12:17; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 switchInt(_2) -> [false: bb4, otherwise: bb3]; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 } bb3: { -+ Coverage::Counter(2) for /the/src/instrument_coverage.rs:13:13 - 13:18; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 -+ Coverage::Expression(4294967295) = 2 + 0 for /the/src/instrument_coverage.rs:16:1 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 falseEdge -> [real: bb5, imaginary: bb4]; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 } bb4: { _1 = const (); // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 StorageDead(_2); // scope 0 at /the/src/instrument_coverage.rs:15:5: 15:6 -+ Coverage::Counter(3) for /the/src/instrument_coverage.rs:15:6 - 15:7; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 ++ Coverage::Expression(4294967295) = 1 - 2 for /the/src/instrument_coverage.rs:15:6 - 15:7; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 goto -> bb0; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 } bb5: { _0 = const (); // scope 0 at /the/src/instrument_coverage.rs:13:13: 13:18 StorageDead(_2); // scope 0 at /the/src/instrument_coverage.rs:15:5: 15:6 ++ Coverage::Counter(2) for /the/src/instrument_coverage.rs:13:13 - 13:18; // scope 0 at /the/src/instrument_coverage.rs:16:2: 16:2 ++ Coverage::Expression(4294967294) = 2 + 0 for /the/src/instrument_coverage.rs:16:1 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:16:2: 16:2 return; // scope 0 at /the/src/instrument_coverage.rs:16:2: 16:2 } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json index 7a7e4c04f001..bd2e2d56d4a5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json @@ -21,8 +21,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 5, + "covered": 5, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 5, + "covered": 5, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json index 1025cd3de80d..a50f4657e20a 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json @@ -21,8 +21,8 @@ "percent": 100 }, "regions": { - "count": 7, - "covered": 7, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 7, - "covered": 7, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json index 2d2ad1dbe3f7..36f81ceae19b 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 29, - "covered": 21, - "percent": 72.41379310344827 + "count": 28, + "covered": 19, + "percent": 67.85714285714286 }, "regions": { - "count": 9, - "covered": 7, + "count": 7, + "covered": 5, "notcovered": 2, - "percent": 77.77777777777779 + "percent": 71.42857142857143 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 29, - "covered": 21, - "percent": 72.41379310344827 + "count": 28, + "covered": 19, + "percent": 67.85714285714286 }, "regions": { - "count": 9, - "covered": 7, + "count": 7, + "covered": 5, "notcovered": 2, - "percent": 77.77777777777779 + "percent": 71.42857142857143 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json index 39e17359eee7..929e769b50a9 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json @@ -21,10 +21,10 @@ "percent": 94.73684210526315 }, "regions": { - "count": 18, - "covered": 15, + "count": 17, + "covered": 14, "notcovered": 3, - "percent": 83.33333333333334 + "percent": 82.35294117647058 } } } @@ -46,10 +46,10 @@ "percent": 94.73684210526315 }, "regions": { - "count": 18, - "covered": 15, + "count": 17, + "covered": 14, "notcovered": 3, - "percent": 83.33333333333334 + "percent": 82.35294117647058 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json index 464bb614ea1b..d93458b61437 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json @@ -21,10 +21,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 70, - "covered": 19, + "count": 69, + "covered": 18, "notcovered": 51, - "percent": 27.142857142857142 + "percent": 26.08695652173913 } } } @@ -46,10 +46,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 70, - "covered": 19, + "count": 69, + "covered": 18, "notcovered": 51, - "percent": 27.142857142857142 + "percent": 26.08695652173913 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json index a116a91a60aa..a9e01604ccd5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json @@ -21,10 +21,10 @@ "percent": 88.23529411764706 }, "regions": { - "count": 10, - "covered": 8, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 80 + "percent": 77.77777777777779 } } } @@ -46,10 +46,10 @@ "percent": 88.23529411764706 }, "regions": { - "count": 10, - "covered": 8, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 80 + "percent": 77.77777777777779 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt index 43592df1059a..72aa020ca169 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt @@ -24,7 +24,7 @@ 24| | let _ = Firework { strength: 1000 }; 25| | 26| | Ok(()) - 27| 2|} + 27| 1|} 28| | 29| |// Expected program output: 30| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt index 11dc0aa65e2d..86199d747630 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt @@ -57,7 +57,7 @@ 35| | let _ = Firework { strength: 1000 }; 36| | 37| | Ok(()) - 38| 2|} + 38| 1|} 39| | 40| |// Expected program output: 41| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt index 64cbc262521b..5f899723e255 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt @@ -20,7 +20,7 @@ 20| 0| countdown 21| 0| = 22| 0| 100 - 23| 1| } + 23| | } 24| | 25| | if 26| 1| is_true @@ -36,6 +36,6 @@ 36| 0| = 37| 0| 100 38| 0| ; - 39| 1| } + 39| 0| } 40| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt index c43b492db605..94c63c9a2b90 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt @@ -33,5 +33,5 @@ 32| 5| } 33| 5| } 34| 0| Ok(()) - 35| 2|} + 35| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt index e0efe75043d4..173ff4aa4c48 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt @@ -65,5 +65,5 @@ 64| | } else { 65| 0| return; 66| | }; - 67| 2|} + 67| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt index e5c5b05a6fc8..26041136d2f4 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt @@ -33,7 +33,7 @@ 33| | ; 34| | } 35| 0| Ok(()) - 36| 2|} + 36| 1|} 37| | 38| |// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and 39| |// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt index 3eb07757c0da..ef43bbd78a6b 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt @@ -2,8 +2,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 20:21 -> 20:38, #1 Counter in file 0 21:20 -> 21:28, (#1 + 0) Counter in file 0 21:29 -> 23:18, #2 -Counter in file 0 23:18 -> 23:19, #3 -Counter in file 0 24:17 -> 25:14, #4 +Counter in file 0 23:18 -> 23:19, (#1 - #2) +Counter in file 0 24:17 -> 25:14, (#2 + (#1 - #2)) Counter in file 0 3:11 -> 18:13, #1 Counter in file 0 25:14 -> 33:9, (#1 + 0) Counter in file 0 40:6 -> 60:13, (#1 + 0) @@ -12,18 +12,18 @@ Counter in file 0 82:6 -> 93:2, (#1 + 0) Counter in file 0 77:13 -> 77:30, #1 Counter in file 0 78:12 -> 78:20, (#1 + 0) Counter in file 0 78:21 -> 80:10, #2 -Counter in file 0 80:10 -> 80:11, #3 -Counter in file 0 81:9 -> 82:6, #4 +Counter in file 0 80:10 -> 80:11, (#1 - #2) +Counter in file 0 81:9 -> 82:6, (#2 + (#1 - #2)) Counter in file 0 62:21 -> 62:38, #1 Counter in file 0 63:20 -> 63:28, (#1 + 0) Counter in file 0 63:29 -> 65:18, #2 -Counter in file 0 65:18 -> 65:19, #3 -Counter in file 0 66:17 -> 67:14, #4 +Counter in file 0 65:18 -> 65:19, (#1 - #2) +Counter in file 0 66:17 -> 67:14, (#2 + (#1 - #2)) Counter in file 0 35:13 -> 35:30, #1 Counter in file 0 36:12 -> 36:20, (#1 + 0) Counter in file 0 36:21 -> 38:10, #2 -Counter in file 0 38:10 -> 38:11, #3 -Counter in file 0 39:9 -> 40:6, #4 +Counter in file 0 38:10 -> 38:11, (#1 - #2) +Counter in file 0 39:9 -> 40:6, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/closure.rs Combined regions: 3:11 -> 18:13 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt index 2bafe7d88e24..9716284f5252 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt @@ -3,7 +3,7 @@ Counter in file 0 9:24 -> 11:6, #1 Counter in file 0 15:9 -> 17:42, #1 Counter in file 0 19:8 -> 19:12, (#1 + 0) Counter in file 0 20:9 -> 21:22, #2 -Counter in file 0 27:1 -> 27:2, #4 +Counter in file 0 27:1 -> 27:2, (#2 + 0) Emitting segments for file: ../coverage/drop_trait.rs Combined regions: 9:24 -> 11:6 (count=2) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt index a13b1f3d7861..5fbfe69b891c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt @@ -4,7 +4,7 @@ Counter in file 0 17:24 -> 19:6, #1 Counter in file 0 23:9 -> 28:28, #1 Counter in file 0 30:8 -> 30:12, (#1 + 0) Counter in file 0 31:9 -> 32:22, #2 -Counter in file 0 38:1 -> 38:2, #4 +Counter in file 0 38:1 -> 38:2, (#2 + 0) Counter in file 0 10:49 -> 12:6, #1 Counter in file 0 10:49 -> 12:6, #1 Emitting segments for file: ../coverage/generics.rs diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt index 2f063de5a395..48c9278a2391 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt @@ -2,8 +2,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 8:5 -> 18:10, #1 Counter in file 0 21:9 -> 21:16, (#1 + 0) Counter in file 0 22:5 -> 27:6, #2 -Counter in file 0 27:6 -> 27:7, #3 -Counter in file 0 28:1 -> 28:2, #4 +Counter in file 0 27:6 -> 27:7, (#1 - #2) +Counter in file 0 28:1 -> 28:2, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/if.rs Combined regions: 8:5 -> 18:10 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt index 270a6f2b14a3..1adf92300bfb 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt @@ -1,11 +1,11 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if_else.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if_else Counter in file 0 7:9 -> 11:16, #1 Counter in file 0 12:5 -> 17:6, #2 -Counter in file 0 20:9 -> 22:16, #3 -Counter in file 0 26:9 -> 26:16, #4 -Counter in file 0 27:5 -> 32:6, #5 -Counter in file 0 34:5 -> 39:6, #6 -Counter in file 0 40:1 -> 40:2, #7 +Counter in file 0 20:9 -> 22:16, (#1 - #2) +Counter in file 0 26:9 -> 26:16, (#2 + (#1 - #2)) +Counter in file 0 27:5 -> 32:6, #3 +Counter in file 0 34:5 -> 39:6, ((#2 + (#1 - #2)) - #3) +Counter in file 0 40:1 -> 40:2, (#3 + ((#2 + (#1 - #2)) - #3)) Emitting segments for file: ../coverage/if_else.rs Combined regions: 7:9 -> 11:16 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt index fb863c73a636..0678be30dc34 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt @@ -6,11 +6,11 @@ Counter in file 0 21:9 -> 22:6, (#2 + 0) Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 12:6, #2 -Counter in file 0 12:6 -> 12:7, #3 -Counter in file 0 48:8 -> 48:15, #4 -Counter in file 0 48:16 -> 50:6, #5 -Counter in file 0 50:6 -> 50:7, #6 -Counter in file 0 52:9 -> 57:2, #7 +Counter in file 0 12:6 -> 12:7, (#1 - #2) +Counter in file 0 48:8 -> 48:15, (#2 + (#1 - #2)) +Counter in file 0 48:16 -> 50:6, #3 +Counter in file 0 50:6 -> 50:7, ((#2 + (#1 - #2)) - #3) +Counter in file 0 52:9 -> 57:2, (#3 + ((#2 + (#1 - #2)) - #3)) Counter in file 0 33:42 -> 36:10, #1 Counter in file 0 41:37 -> 41:41, #1 Counter in file 0 42:13 -> 43:10, #2 diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt index 4561fcc5b36a..e955fcd8ba05 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt @@ -2,40 +2,40 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:42, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 14:6, #2 -Counter in file 0 14:6 -> 14:7, #3 -Counter in file 0 16:9 -> 16:17, #4 -Counter in file 0 18:13 -> 18:18, #5 -Counter in file 0 20:13 -> 20:18, #6 -Counter in file 0 20:18 -> 20:19, #7 -Counter in file 0 20:18 -> 20:19, #8 -Counter in file 0 23:9 -> 23:17, #9 -Counter in file 0 25:13 -> 25:18, (#4 + 0) -Counter in file 0 27:13 -> 27:18, #10 -Counter in file 0 27:18 -> 27:19, #11 -Counter in file 0 27:18 -> 27:19, #12 -Counter in file 0 29:9 -> 29:17, #13 -Counter in file 0 29:20 -> 29:25, (#9 + 0) -Counter in file 0 29:29 -> 29:34, #14 -Counter in file 0 29:34 -> 29:35, #15 -Counter in file 0 29:34 -> 29:35, #16 -Counter in file 0 30:9 -> 30:17, #17 -Counter in file 0 30:20 -> 30:25, (#13 + 0) -Counter in file 0 30:29 -> 30:34, #18 -Counter in file 0 30:34 -> 30:35, #19 -Counter in file 0 30:34 -> 30:35, #20 -Counter in file 0 33:9 -> 34:16, (#17 + 0) -Counter in file 0 35:5 -> 38:6, #21 -Counter in file 0 38:6 -> 38:7, #22 -Counter in file 0 41:9 -> 41:16, #23 -Counter in file 0 42:5 -> 45:6, #24 -Counter in file 0 47:5 -> 50:6, #25 -Counter in file 0 52:8 -> 52:16, #26 -Counter in file 0 52:17 -> 54:6, #27 -Counter in file 0 54:6 -> 54:7, #28 -Counter in file 0 56:8 -> 56:15, #29 -Counter in file 0 56:16 -> 58:6, #30 -Counter in file 0 58:12 -> 60:6, #31 -Counter in file 0 61:1 -> 61:2, #32 +Counter in file 0 14:6 -> 14:7, (#1 - #2) +Counter in file 0 16:9 -> 16:17, ((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) +Counter in file 0 18:13 -> 18:18, (#2 + (#1 - #2)) +Counter in file 0 20:13 -> 20:18, ((#2 + (#1 - #2)) - #3) +Counter in file 0 20:18 -> 20:19, (#3 + #4) +Counter in file 0 20:18 -> 20:19, (((#2 + (#1 - #2)) - #3) - #4) +Counter in file 0 23:9 -> 23:17, ((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) +Counter in file 0 25:13 -> 25:18, (((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) + 0) +Counter in file 0 27:13 -> 27:18, (((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) +Counter in file 0 27:18 -> 27:19, (#5 + #6) +Counter in file 0 27:18 -> 27:19, ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6) +Counter in file 0 29:9 -> 29:17, ((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) +Counter in file 0 29:20 -> 29:25, (((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) + 0) +Counter in file 0 29:29 -> 29:34, #7 +Counter in file 0 29:34 -> 29:35, ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8) +Counter in file 0 29:34 -> 29:35, (#7 - #8) +Counter in file 0 30:9 -> 30:17, ((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) +Counter in file 0 30:20 -> 30:25, (((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) + 0) +Counter in file 0 30:29 -> 30:34, #9 +Counter in file 0 30:34 -> 30:35, ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10) +Counter in file 0 30:34 -> 30:35, (#9 - #10) +Counter in file 0 33:9 -> 34:16, (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) + 0) +Counter in file 0 35:5 -> 38:6, #11 +Counter in file 0 38:6 -> 38:7, (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11) +Counter in file 0 41:9 -> 41:16, (#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) +Counter in file 0 42:5 -> 45:6, #12 +Counter in file 0 47:5 -> 50:6, ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12) +Counter in file 0 52:8 -> 52:16, (#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) +Counter in file 0 52:17 -> 54:6, #13 +Counter in file 0 54:6 -> 54:7, ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13) +Counter in file 0 56:8 -> 56:15, (#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) +Counter in file 0 56:16 -> 58:6, #14 +Counter in file 0 58:12 -> 60:6, ((#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) - #14) +Counter in file 0 61:1 -> 61:2, (#14 + ((#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) - #14)) Emitting segments for file: ../coverage/lazy_boolean.rs Combined regions: 7:9 -> 9:42 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt index 7cde2205cbfd..171b77c9cc74 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt @@ -1,12 +1,12 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loops_and_branches.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loops_and_branches Counter in file 0 10:12 -> 10:16, #1 Counter in file 0 11:16 -> 11:21, #2 -Counter in file 0 14:14 -> 14:15, #6 -Counter in file 0 15:13 -> 15:31, #7 -Counter in file 0 15:31 -> 15:32, #8 -Counter in file 0 17:10 -> 17:11, #10 -Counter in file 0 18:9 -> 18:15, #11 -Counter in file 0 19:5 -> 19:6, #12 +Counter in file 0 14:14 -> 14:15, (#2 - #5) +Counter in file 0 15:13 -> 15:31, (0 + (#2 - #5)) +Counter in file 0 15:31 -> 15:32, #4 +Counter in file 0 17:10 -> 17:11, #3 +Counter in file 0 18:9 -> 18:15, (#3 + 0) +Counter in file 0 19:5 -> 19:6, (#4 + (#3 + 0)) Counter in file 0 22:11 -> 25:2, #1 Emitting segments for file: ../coverage/loops_and_branches.rs Combined regions: diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt index 59fb5c366f2c..ac376c4f36a4 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt @@ -1,22 +1,22 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/nested_loops.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/nested_loops Counter in file 0 2:9 -> 3:27, #1 -Counter in file 0 5:19 -> 5:32, #2 -Counter in file 0 6:13 -> 7:24, #3 -Counter in file 0 8:13 -> 8:14, #4 -Counter in file 0 8:18 -> 8:23, #5 -Counter in file 0 9:16 -> 9:22, (#4 + 0) -Counter in file 0 10:17 -> 10:22, #6 -Counter in file 0 12:13 -> 12:19, #7 -Counter in file 0 13:13 -> 13:19, #8 -Counter in file 0 14:16 -> 14:22, (#8 + 0) -Counter in file 0 15:17 -> 16:27, #9 -Counter in file 0 17:21 -> 17:33, #10 -Counter in file 0 19:21 -> 21:14, #11 -Counter in file 0 21:14 -> 21:15, #12 -Counter in file 0 22:10 -> 22:11, #13 -Counter in file 0 23:9 -> 23:23, #14 -Counter in file 0 24:6 -> 24:7, #15 -Counter in file 0 25:1 -> 25:2, #16 +Counter in file 0 5:19 -> 5:32, (#1 + #2) +Counter in file 0 6:13 -> 7:24, ((#1 + #2) - #3) +Counter in file 0 8:13 -> 8:14, ((((#1 + #2) - #3) + (#5 + #6)) - #7) +Counter in file 0 8:18 -> 8:23, (((#1 + #2) - #3) + (#5 + #6)) +Counter in file 0 9:16 -> 9:22, (((((#1 + #2) - #3) + (#5 + #6)) - #7) + 0) +Counter in file 0 10:17 -> 10:22, #8 +Counter in file 0 12:13 -> 12:19, #9 +Counter in file 0 13:13 -> 13:19, #10 +Counter in file 0 14:16 -> 14:22, (#10 + 0) +Counter in file 0 15:17 -> 16:27, #11 +Counter in file 0 17:21 -> 17:33, #4 +Counter in file 0 19:21 -> 21:14, #5 +Counter in file 0 21:14 -> 21:15, #6 +Counter in file 0 22:10 -> 22:11, (#5 + #6) +Counter in file 0 23:9 -> 23:23, #2 +Counter in file 0 24:6 -> 24:7, #3 +Counter in file 0 25:1 -> 25:2, (#4 + #3) Emitting segments for file: ../coverage/nested_loops.rs Combined regions: 2:9 -> 3:27 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt index d828e40ca3fa..148768f423ba 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt @@ -2,12 +2,12 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 12:9 -> 12:16, (#1 + 0) Counter in file 0 13:5 -> 18:6, #2 -Counter in file 0 18:6 -> 18:7, #3 -Counter in file 0 23:13 -> 25:14, #4 -Counter in file 0 27:13 -> 27:18, #5 -Counter in file 0 30:9 -> 32:10, #6 -Counter in file 0 34:6 -> 34:7, #7 -Counter in file 0 35:1 -> 35:2, (#5 + 0) +Counter in file 0 18:6 -> 18:7, (#1 - #2) +Counter in file 0 23:13 -> 25:14, ((#2 + (#1 - #2)) + #3) +Counter in file 0 27:13 -> 27:18, #4 +Counter in file 0 30:9 -> 32:10, #3 +Counter in file 0 34:6 -> 34:7, (#2 + (#1 - #2)) +Counter in file 0 35:1 -> 35:2, (#4 + 0) Emitting segments for file: ../coverage/simple_loop.rs Combined regions: 7:9 -> 9:26 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt index e7932e0be047..2a3c004fa7ab 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt @@ -2,18 +2,18 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 12:6, #2 -Counter in file 0 12:6 -> 12:7, #3 -Counter in file 0 15:9 -> 15:10, #4 -Counter in file 0 17:9 -> 17:13, #5 -Counter in file 0 22:13 -> 22:22, (#4 + 0) -Counter in file 0 24:13 -> 24:14, #6 -Counter in file 0 26:17 -> 28:18, (#4 + 0) -Counter in file 0 28:18 -> 28:19, #7 -Counter in file 0 30:13 -> 37:14, (#6 + 0) -Counter in file 0 40:13 -> 40:15, #8 -Counter in file 0 42:6 -> 42:7, #9 -Counter in file 0 42:6 -> 42:7, #10 -Counter in file 0 43:1 -> 43:2, #11 +Counter in file 0 12:6 -> 12:7, (#1 - #2) +Counter in file 0 15:9 -> 15:10, (((#2 + (#1 - #2)) + (#3 + #4)) - #5) +Counter in file 0 17:9 -> 17:13, ((#2 + (#1 - #2)) + (#3 + #4)) +Counter in file 0 22:13 -> 22:22, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) + 0) +Counter in file 0 24:13 -> 24:14, #3 +Counter in file 0 26:17 -> 28:18, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) + 0) +Counter in file 0 28:18 -> 28:19, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) - #3) +Counter in file 0 30:13 -> 37:14, (#3 + 0) +Counter in file 0 40:13 -> 40:15, #4 +Counter in file 0 42:6 -> 42:7, (#2 + (#1 - #2)) +Counter in file 0 42:6 -> 42:7, (#3 + #4) +Counter in file 0 43:1 -> 43:2, #5 Emitting segments for file: ../coverage/simple_match.rs Combined regions: 7:9 -> 9:26 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt index a690874e3c00..5180ddd7de66 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt @@ -1,6 +1,6 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/tight_infinite_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/tight_infinite_loop Counter in file 0 2:8 -> 2:13, #1 -Counter in file 0 5:1 -> 5:2, #4 +Counter in file 0 5:1 -> 5:2, (#1 - #2) Emitting segments for file: ../coverage/tight_infinite_loop.rs Combined regions: 2:8 -> 2:13 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt index 7dea637551db..30109a1e2002 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt @@ -1,22 +1,21 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/try_error_result.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/try_error_result Counter in file 0 13:9 -> 14:23, #1 -Counter in file 0 17:9 -> 17:10, #2 -Counter in file 0 19:9 -> 19:14, #3 -Counter in file 0 21:9 -> 25:26, #4 -Counter in file 0 27:13 -> 27:41, #5 -Counter in file 0 27:41 -> 27:42, #6 -Counter in file 0 31:13 -> 31:42, #7 -Counter in file 0 31:42 -> 31:43, #8 -Counter in file 0 32:10 -> 32:11, #9 -Counter in file 0 32:10 -> 32:11, #10 -Counter in file 0 33:6 -> 33:7, #11 -Counter in file 0 34:5 -> 34:11, #12 -Counter in file 0 35:1 -> 35:2, #13 -Counter in file 0 35:1 -> 35:2, #14 +Counter in file 0 17:9 -> 17:10, ((#1 + (#2 + #3)) - #4) +Counter in file 0 19:9 -> 19:14, (#1 + (#2 + #3)) +Counter in file 0 21:9 -> 25:26, #7 +Counter in file 0 27:13 -> 27:41, #8 +Counter in file 0 27:41 -> 27:42, #5 +Counter in file 0 31:13 -> 31:42, (#7 - #8) +Counter in file 0 31:42 -> 31:43, #6 +Counter in file 0 32:10 -> 32:11, #2 +Counter in file 0 32:10 -> 32:11, #3 +Counter in file 0 33:6 -> 33:7, (#2 + #3) +Counter in file 0 34:5 -> 34:11, #4 +Counter in file 0 35:1 -> 35:2, ((#5 + #6) + #4) Counter in file 0 5:8 -> 5:20, #1 Counter in file 0 6:9 -> 6:16, #2 -Counter in file 0 8:9 -> 8:15, #3 -Counter in file 0 10:1 -> 10:2, #4 +Counter in file 0 8:9 -> 8:15, (#1 - #2) +Counter in file 0 10:1 -> 10:2, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/try_error_result.rs Combined regions: 5:8 -> 5:20 (count=6) @@ -34,7 +33,7 @@ Combined regions: 32:10 -> 32:11 (count=5) 33:6 -> 33:7 (count=5) 34:5 -> 34:11 (count=0) - 35:1 -> 35:2 (count=2) + 35:1 -> 35:2 (count=1) Segment at 5:8 (count = 6), RegionEntry Segment at 5:20 (count = 0), Skipped Segment at 6:9 (count = 1), RegionEntry @@ -63,5 +62,5 @@ Segment at 33:6 (count = 5), RegionEntry Segment at 33:7 (count = 0), Skipped Segment at 34:5 (count = 0), RegionEntry Segment at 34:11 (count = 0), Skipped -Segment at 35:1 (count = 2), RegionEntry +Segment at 35:1 (count = 1), RegionEntry Segment at 35:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt index 0fb135b2cc99..b229410a495a 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt @@ -2,73 +2,72 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 4:9 -> 4:26, #1 Counter in file 0 5:8 -> 5:12, (#1 + 0) Counter in file 0 5:13 -> 7:6, #2 -Counter in file 0 10:9 -> 10:10, #4 -Counter in file 0 10:16 -> 10:29, #5 -Counter in file 0 11:9 -> 12:10, #6 -Counter in file 0 13:15 -> 13:28, #7 -Counter in file 0 14:12 -> 14:25, #8 -Counter in file 0 14:29 -> 14:42, #9 -Counter in file 0 14:42 -> 14:43, #10 -Counter in file 0 14:42 -> 14:43, #11 -Counter in file 0 14:46 -> 14:60, #12 -Counter in file 0 14:60 -> 14:61, #13 -Counter in file 0 14:60 -> 14:61, #14 -Counter in file 0 14:61 -> 16:10, #15 -Counter in file 0 16:10 -> 16:11, #16 -Counter in file 0 17:9 -> 18:18, #17 -Counter in file 0 20:9 -> 20:15, #18 -Counter in file 0 23:9 -> 23:26, (#4 + 0) -Counter in file 0 24:8 -> 24:12, (#4 + 0) -Counter in file 0 24:13 -> 26:6, #19 -Counter in file 0 28:8 -> 28:21, #21 -Counter in file 0 29:9 -> 29:23, #22 -Counter in file 0 30:15 -> 30:28, #23 -Counter in file 0 31:12 -> 31:25, #24 -Counter in file 0 31:29 -> 31:42, #25 -Counter in file 0 31:42 -> 31:43, #26 -Counter in file 0 31:42 -> 31:43, #27 -Counter in file 0 31:46 -> 31:60, #28 -Counter in file 0 31:60 -> 31:61, #29 -Counter in file 0 31:60 -> 31:61, #30 -Counter in file 0 31:61 -> 33:10, #31 -Counter in file 0 33:10 -> 33:11, #32 -Counter in file 0 34:9 -> 34:23, #33 -Counter in file 0 36:9 -> 36:15, #34 -Counter in file 0 39:9 -> 39:26, #35 -Counter in file 0 40:8 -> 40:12, (#35 + 0) -Counter in file 0 40:13 -> 42:6, #36 -Counter in file 0 44:9 -> 44:10, #38 -Counter in file 0 44:16 -> 44:29, #39 -Counter in file 0 45:9 -> 45:23, #40 -Counter in file 0 46:15 -> 46:28, #41 -Counter in file 0 47:12 -> 47:25, #42 -Counter in file 0 47:29 -> 47:42, #43 -Counter in file 0 47:42 -> 47:43, #44 -Counter in file 0 47:42 -> 47:43, #45 -Counter in file 0 47:46 -> 47:60, #46 -Counter in file 0 47:60 -> 47:61, #47 -Counter in file 0 47:60 -> 47:61, #48 -Counter in file 0 47:61 -> 49:10, #49 -Counter in file 0 49:10 -> 49:11, #50 -Counter in file 0 50:9 -> 50:23, #51 -Counter in file 0 52:13 -> 54:15, #52 -Counter in file 0 57:9 -> 57:10, #53 -Counter in file 0 57:16 -> 57:29, (#38 + 0) -Counter in file 0 58:9 -> 58:23, #54 -Counter in file 0 59:15 -> 59:28, #55 -Counter in file 0 60:12 -> 60:25, #56 -Counter in file 0 60:29 -> 60:42, #57 -Counter in file 0 60:42 -> 60:43, #58 -Counter in file 0 60:42 -> 60:43, #59 -Counter in file 0 60:46 -> 60:60, #60 -Counter in file 0 60:60 -> 60:61, #61 -Counter in file 0 60:60 -> 60:61, #62 -Counter in file 0 60:61 -> 62:10, #63 -Counter in file 0 62:10 -> 62:11, #64 -Counter in file 0 63:9 -> 63:23, #65 -Counter in file 0 65:9 -> 65:15, #66 -Counter in file 0 67:1 -> 67:2, #67 -Counter in file 0 67:1 -> 67:2, #68 +Counter in file 0 10:9 -> 10:10, (#4 + #11) +Counter in file 0 10:16 -> 10:29, (#2 + 0) +Counter in file 0 11:9 -> 12:10, #4 +Counter in file 0 13:15 -> 13:28, ((#2 + 0) - #3) +Counter in file 0 14:12 -> 14:25, #5 +Counter in file 0 14:29 -> 14:42, (#5 - #13) +Counter in file 0 14:42 -> 14:43, (#13 + #14) +Counter in file 0 14:42 -> 14:43, ((#5 - #13) - #14) +Counter in file 0 14:46 -> 14:60, #21 +Counter in file 0 14:60 -> 14:61, (#17 + #18) +Counter in file 0 14:60 -> 14:61, (#21 - #18) +Counter in file 0 14:61 -> 16:10, #22 +Counter in file 0 16:10 -> 16:11, #23 +Counter in file 0 17:9 -> 18:18, #11 +Counter in file 0 20:9 -> 20:15, (((#2 + 0) - #3) - #5) +Counter in file 0 23:9 -> 23:26, ((#4 + #11) + 0) +Counter in file 0 24:8 -> 24:12, ((#4 + #11) + 0) +Counter in file 0 24:13 -> 26:6, #12 +Counter in file 0 28:8 -> 28:21, (#12 + 0) +Counter in file 0 29:9 -> 29:23, #16 +Counter in file 0 30:15 -> 30:28, ((#12 + 0) - #15) +Counter in file 0 31:12 -> 31:25, (((#12 + 0) - #15) - #8) +Counter in file 0 31:29 -> 31:42, ((((#12 + 0) - #15) - #8) - #24) +Counter in file 0 31:42 -> 31:43, (((((#12 + 0) - #15) - #8) - #24) - #25) +Counter in file 0 31:42 -> 31:43, (#24 + #25) +Counter in file 0 31:46 -> 31:60, #32 +Counter in file 0 31:60 -> 31:61, (#28 + #29) +Counter in file 0 31:60 -> 31:61, (#32 - #29) +Counter in file 0 31:61 -> 33:10, #33 +Counter in file 0 33:10 -> 33:11, #34 +Counter in file 0 34:9 -> 34:23, #19 +Counter in file 0 36:9 -> 36:15, #8 +Counter in file 0 39:9 -> 39:26, (#16 + #19) +Counter in file 0 40:8 -> 40:12, ((#16 + #19) + 0) +Counter in file 0 40:13 -> 42:6, #20 +Counter in file 0 44:9 -> 44:10, (#27 + #30) +Counter in file 0 44:16 -> 44:29, (#20 + 0) +Counter in file 0 45:9 -> 45:23, #27 +Counter in file 0 46:15 -> 46:28, ((#20 + 0) - #26) +Counter in file 0 47:12 -> 47:25, (((#20 + 0) - #26) - #7) +Counter in file 0 47:29 -> 47:42, ((((#20 + 0) - #26) - #7) - #35) +Counter in file 0 47:42 -> 47:43, (#35 + #36) +Counter in file 0 47:42 -> 47:43, (((((#20 + 0) - #26) - #7) - #35) - #36) +Counter in file 0 47:46 -> 47:60, #41 +Counter in file 0 47:60 -> 47:61, (#37 + #38) +Counter in file 0 47:60 -> 47:61, (#41 - #38) +Counter in file 0 47:61 -> 49:10, #42 +Counter in file 0 49:10 -> 49:11, #43 +Counter in file 0 50:9 -> 50:23, #30 +Counter in file 0 52:13 -> 54:15, #7 +Counter in file 0 57:9 -> 57:10, (#9 + #10) +Counter in file 0 57:16 -> 57:29, ((#27 + #30) + 0) +Counter in file 0 58:9 -> 58:23, #9 +Counter in file 0 59:15 -> 59:28, ((#27 + #30) - #31) +Counter in file 0 60:12 -> 60:25, (((#27 + #30) - #31) - #6) +Counter in file 0 60:29 -> 60:42, ((((#27 + #30) - #31) - #6) - #39) +Counter in file 0 60:42 -> 60:43, (#39 + #40) +Counter in file 0 60:42 -> 60:43, (((((#27 + #30) - #31) - #6) - #39) - #40) +Counter in file 0 60:46 -> 60:60, #46 +Counter in file 0 60:60 -> 60:61, (#46 - #45) +Counter in file 0 60:60 -> 60:61, (#44 + #45) +Counter in file 0 60:61 -> 62:10, #47 +Counter in file 0 62:10 -> 62:11, #48 +Counter in file 0 63:9 -> 63:23, #10 +Counter in file 0 65:9 -> 65:15, #6 +Counter in file 0 67:1 -> 67:2, ((#9 + #10) + (((#6 + #7) + #8) + (((#2 + 0) - #3) - #5))) Emitting segments for file: ../coverage/various_conditions.rs Combined regions: 4:9 -> 4:26 (count=1) @@ -131,7 +130,7 @@ Combined regions: 62:10 -> 62:11 (count=0) 63:9 -> 63:23 (count=0) 65:9 -> 65:15 (count=0) - 67:1 -> 67:2 (count=2) + 67:1 -> 67:2 (count=1) Segment at 4:9 (count = 1), RegionEntry Segment at 4:26 (count = 0), Skipped Segment at 5:8 (count = 1), RegionEntry @@ -236,5 +235,5 @@ Segment at 63:9 (count = 0), RegionEntry Segment at 63:23 (count = 0), Skipped Segment at 65:9 (count = 0), RegionEntry Segment at 65:15 (count = 0), Skipped -Segment at 67:1 (count = 2), RegionEntry +Segment at 67:1 (count = 1), RegionEntry Segment at 67:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt index a2be958660ed..d496805955f7 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt @@ -1,8 +1,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while Counter in file 0 2:9 -> 2:16, #1 -Counter in file 0 3:11 -> 3:20, #2 -Counter in file 0 3:21 -> 4:6, #3 -Counter in file 0 5:1 -> 5:2, #4 +Counter in file 0 3:11 -> 3:20, (#1 + #2) +Counter in file 0 3:21 -> 4:6, #2 +Counter in file 0 5:1 -> 5:2, ((#1 + #2) - #2) Emitting segments for file: ../coverage/while.rs Combined regions: 2:9 -> 2:16 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt index 02ab24050bad..a343f5056ac2 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt @@ -1,14 +1,13 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while_early_return.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while_early_return Counter in file 0 5:9 -> 5:27, #1 -Counter in file 0 7:9 -> 9:10, #2 -Counter in file 0 12:13 -> 14:14, #3 -Counter in file 0 18:21 -> 20:22, #4 -Counter in file 0 22:21 -> 22:27, #5 -Counter in file 0 26:21 -> 26:27, #6 -Counter in file 0 30:9 -> 32:10, #7 -Counter in file 0 35:5 -> 35:11, #8 -Counter in file 0 36:1 -> 36:2, #9 -Counter in file 0 36:1 -> 36:2, #10 +Counter in file 0 7:9 -> 9:10, (#1 + #2) +Counter in file 0 12:13 -> 14:14, ((#1 + #2) - #3) +Counter in file 0 18:21 -> 20:22, #6 +Counter in file 0 22:21 -> 22:27, #4 +Counter in file 0 26:21 -> 26:27, #5 +Counter in file 0 30:9 -> 32:10, #2 +Counter in file 0 35:5 -> 35:11, #3 +Counter in file 0 36:1 -> 36:2, ((#4 + #5) + #3) Emitting segments for file: ../coverage/while_early_return.rs Combined regions: 5:9 -> 5:27 (count=1) @@ -19,7 +18,7 @@ Combined regions: 26:21 -> 26:27 (count=1) 30:9 -> 32:10 (count=6) 35:5 -> 35:11 (count=0) - 36:1 -> 36:2 (count=2) + 36:1 -> 36:2 (count=1) Segment at 5:9 (count = 1), RegionEntry Segment at 5:27 (count = 0), Skipped Segment at 7:9 (count = 7), RegionEntry @@ -36,5 +35,5 @@ Segment at 30:9 (count = 6), RegionEntry Segment at 32:10 (count = 0), Skipped Segment at 35:5 (count = 0), RegionEntry Segment at 35:11 (count = 0), Skipped -Segment at 36:1 (count = 2), RegionEntry +Segment at 36:1 (count = 1), RegionEntry Segment at 36:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json index 7a7e4c04f001..bd2e2d56d4a5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json @@ -21,8 +21,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 5, + "covered": 5, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 5, + "covered": 5, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json index 1025cd3de80d..a50f4657e20a 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json @@ -21,8 +21,8 @@ "percent": 100 }, "regions": { - "count": 7, - "covered": 7, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 7, - "covered": 7, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json index 2d2ad1dbe3f7..36f81ceae19b 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 29, - "covered": 21, - "percent": 72.41379310344827 + "count": 28, + "covered": 19, + "percent": 67.85714285714286 }, "regions": { - "count": 9, - "covered": 7, + "count": 7, + "covered": 5, "notcovered": 2, - "percent": 77.77777777777779 + "percent": 71.42857142857143 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 29, - "covered": 21, - "percent": 72.41379310344827 + "count": 28, + "covered": 19, + "percent": 67.85714285714286 }, "regions": { - "count": 9, - "covered": 7, + "count": 7, + "covered": 5, "notcovered": 2, - "percent": 77.77777777777779 + "percent": 71.42857142857143 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json index 39e17359eee7..929e769b50a9 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json @@ -21,10 +21,10 @@ "percent": 94.73684210526315 }, "regions": { - "count": 18, - "covered": 15, + "count": 17, + "covered": 14, "notcovered": 3, - "percent": 83.33333333333334 + "percent": 82.35294117647058 } } } @@ -46,10 +46,10 @@ "percent": 94.73684210526315 }, "regions": { - "count": 18, - "covered": 15, + "count": 17, + "covered": 14, "notcovered": 3, - "percent": 83.33333333333334 + "percent": 82.35294117647058 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json index 464bb614ea1b..d93458b61437 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json @@ -21,10 +21,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 70, - "covered": 19, + "count": 69, + "covered": 18, "notcovered": 51, - "percent": 27.142857142857142 + "percent": 26.08695652173913 } } } @@ -46,10 +46,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 70, - "covered": 19, + "count": 69, + "covered": 18, "notcovered": 51, - "percent": 27.142857142857142 + "percent": 26.08695652173913 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json index a116a91a60aa..a9e01604ccd5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json @@ -21,10 +21,10 @@ "percent": 88.23529411764706 }, "regions": { - "count": 10, - "covered": 8, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 80 + "percent": 77.77777777777779 } } } @@ -46,10 +46,10 @@ "percent": 88.23529411764706 }, "regions": { - "count": 10, - "covered": 8, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 80 + "percent": 77.77777777777779 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt index 43592df1059a..72aa020ca169 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt @@ -24,7 +24,7 @@ 24| | let _ = Firework { strength: 1000 }; 25| | 26| | Ok(()) - 27| 2|} + 27| 1|} 28| | 29| |// Expected program output: 30| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt index 11dc0aa65e2d..86199d747630 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt @@ -57,7 +57,7 @@ 35| | let _ = Firework { strength: 1000 }; 36| | 37| | Ok(()) - 38| 2|} + 38| 1|} 39| | 40| |// Expected program output: 41| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt index 64cbc262521b..5f899723e255 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt @@ -20,7 +20,7 @@ 20| 0| countdown 21| 0| = 22| 0| 100 - 23| 1| } + 23| | } 24| | 25| | if 26| 1| is_true @@ -36,6 +36,6 @@ 36| 0| = 37| 0| 100 38| 0| ; - 39| 1| } + 39| 0| } 40| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt index c43b492db605..94c63c9a2b90 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt @@ -33,5 +33,5 @@ 32| 5| } 33| 5| } 34| 0| Ok(()) - 35| 2|} + 35| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt index e0efe75043d4..173ff4aa4c48 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt @@ -65,5 +65,5 @@ 64| | } else { 65| 0| return; 66| | }; - 67| 2|} + 67| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt index e5c5b05a6fc8..26041136d2f4 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt @@ -33,7 +33,7 @@ 33| | ; 34| | } 35| 0| Ok(()) - 36| 2|} + 36| 1|} 37| | 38| |// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and 39| |// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt index 39bf7bad9a1a..d443ba0aba3a 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt @@ -2,8 +2,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 20:21 -> 20:38, #1 Counter in file 0 21:20 -> 21:28, (#1 + 0) Counter in file 0 21:29 -> 23:18, #2 -Counter in file 0 23:18 -> 23:19, #3 -Counter in file 0 24:17 -> 25:14, #4 +Counter in file 0 23:18 -> 23:19, (#1 - #2) +Counter in file 0 24:17 -> 25:14, (#2 + (#1 - #2)) Counter in file 0 3:11 -> 18:13, #1 Counter in file 0 25:14 -> 33:9, (#1 + 0) Counter in file 0 40:6 -> 60:13, (#1 + 0) @@ -12,18 +12,18 @@ Counter in file 0 82:6 -> 93:2, (#1 + 0) Counter in file 0 77:13 -> 77:30, #1 Counter in file 0 78:12 -> 78:20, (#1 + 0) Counter in file 0 78:21 -> 80:10, #2 -Counter in file 0 80:10 -> 80:11, #3 -Counter in file 0 81:9 -> 82:6, #4 +Counter in file 0 80:10 -> 80:11, (#1 - #2) +Counter in file 0 81:9 -> 82:6, (#2 + (#1 - #2)) Counter in file 0 62:21 -> 62:38, #1 Counter in file 0 63:20 -> 63:28, (#1 + 0) Counter in file 0 63:29 -> 65:18, #2 -Counter in file 0 65:18 -> 65:19, #3 -Counter in file 0 66:17 -> 67:14, #4 +Counter in file 0 65:18 -> 65:19, (#1 - #2) +Counter in file 0 66:17 -> 67:14, (#2 + (#1 - #2)) Counter in file 0 35:13 -> 35:30, #1 Counter in file 0 36:12 -> 36:20, (#1 + 0) Counter in file 0 36:21 -> 38:10, #2 -Counter in file 0 38:10 -> 38:11, #3 -Counter in file 0 39:9 -> 40:6, #4 +Counter in file 0 38:10 -> 38:11, (#1 - #2) +Counter in file 0 39:9 -> 40:6, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/closure.rs Combined regions: 3:11 -> 18:13 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt index 124a01af3421..08fbbd13adbe 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt @@ -3,7 +3,7 @@ Counter in file 0 9:24 -> 11:6, #1 Counter in file 0 15:9 -> 17:42, #1 Counter in file 0 19:8 -> 19:12, (#1 + 0) Counter in file 0 20:9 -> 21:22, #2 -Counter in file 0 27:1 -> 27:2, #4 +Counter in file 0 27:1 -> 27:2, (#2 + 0) Emitting segments for file: ../coverage/drop_trait.rs Combined regions: 9:24 -> 11:6 (count=2) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt index a0e9146035ee..eb707c5e7acc 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt @@ -4,7 +4,7 @@ Counter in file 0 17:24 -> 19:6, #1 Counter in file 0 23:9 -> 28:28, #1 Counter in file 0 30:8 -> 30:12, (#1 + 0) Counter in file 0 31:9 -> 32:22, #2 -Counter in file 0 38:1 -> 38:2, #4 +Counter in file 0 38:1 -> 38:2, (#2 + 0) Counter in file 0 10:49 -> 12:6, #1 Counter in file 0 10:49 -> 12:6, #1 Emitting segments for file: ../coverage/generics.rs diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt index 325e6985e304..d186f440ddb1 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt @@ -2,8 +2,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 8:5 -> 18:10, #1 Counter in file 0 21:9 -> 21:16, (#1 + 0) Counter in file 0 22:5 -> 27:6, #2 -Counter in file 0 27:6 -> 27:7, #3 -Counter in file 0 28:1 -> 28:2, #4 +Counter in file 0 27:6 -> 27:7, (#1 - #2) +Counter in file 0 28:1 -> 28:2, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/if.rs Combined regions: 8:5 -> 18:10 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt index 9406b6a269d4..8220060f26ff 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt @@ -1,11 +1,11 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if_else.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if_else Counter in file 0 7:9 -> 11:16, #1 Counter in file 0 12:5 -> 17:6, #2 -Counter in file 0 20:9 -> 22:16, #3 -Counter in file 0 26:9 -> 26:16, #4 -Counter in file 0 27:5 -> 32:6, #5 -Counter in file 0 34:5 -> 39:6, #6 -Counter in file 0 40:1 -> 40:2, #7 +Counter in file 0 20:9 -> 22:16, (#1 - #2) +Counter in file 0 26:9 -> 26:16, (#2 + (#1 - #2)) +Counter in file 0 27:5 -> 32:6, #3 +Counter in file 0 34:5 -> 39:6, ((#2 + (#1 - #2)) - #3) +Counter in file 0 40:1 -> 40:2, (#3 + ((#2 + (#1 - #2)) - #3)) Emitting segments for file: ../coverage/if_else.rs Combined regions: 7:9 -> 11:16 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt index ea6db9452a75..c173cc20f815 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt @@ -6,11 +6,11 @@ Counter in file 0 21:9 -> 22:6, (#2 + 0) Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 12:6, #2 -Counter in file 0 12:6 -> 12:7, #3 -Counter in file 0 48:8 -> 48:15, #4 -Counter in file 0 48:16 -> 50:6, #5 -Counter in file 0 50:6 -> 50:7, #6 -Counter in file 0 52:9 -> 57:2, #7 +Counter in file 0 12:6 -> 12:7, (#1 - #2) +Counter in file 0 48:8 -> 48:15, (#2 + (#1 - #2)) +Counter in file 0 48:16 -> 50:6, #3 +Counter in file 0 50:6 -> 50:7, ((#2 + (#1 - #2)) - #3) +Counter in file 0 52:9 -> 57:2, (#3 + ((#2 + (#1 - #2)) - #3)) Counter in file 0 33:42 -> 36:10, #1 Counter in file 0 41:37 -> 41:41, #1 Counter in file 0 42:13 -> 43:10, #2 diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt index c95275c6223b..191a3a58355d 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt @@ -2,40 +2,40 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:42, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 14:6, #2 -Counter in file 0 14:6 -> 14:7, #3 -Counter in file 0 16:9 -> 16:17, #4 -Counter in file 0 18:13 -> 18:18, #5 -Counter in file 0 20:13 -> 20:18, #6 -Counter in file 0 20:18 -> 20:19, #7 -Counter in file 0 20:18 -> 20:19, #8 -Counter in file 0 23:9 -> 23:17, #9 -Counter in file 0 25:13 -> 25:18, (#4 + 0) -Counter in file 0 27:13 -> 27:18, #10 -Counter in file 0 27:18 -> 27:19, #11 -Counter in file 0 27:18 -> 27:19, #12 -Counter in file 0 29:9 -> 29:17, #13 -Counter in file 0 29:20 -> 29:25, (#9 + 0) -Counter in file 0 29:29 -> 29:34, #14 -Counter in file 0 29:34 -> 29:35, #15 -Counter in file 0 29:34 -> 29:35, #16 -Counter in file 0 30:9 -> 30:17, #17 -Counter in file 0 30:20 -> 30:25, (#13 + 0) -Counter in file 0 30:29 -> 30:34, #18 -Counter in file 0 30:34 -> 30:35, #19 -Counter in file 0 30:34 -> 30:35, #20 -Counter in file 0 33:9 -> 34:16, (#17 + 0) -Counter in file 0 35:5 -> 38:6, #21 -Counter in file 0 38:6 -> 38:7, #22 -Counter in file 0 41:9 -> 41:16, #23 -Counter in file 0 42:5 -> 45:6, #24 -Counter in file 0 47:5 -> 50:6, #25 -Counter in file 0 52:8 -> 52:16, #26 -Counter in file 0 52:17 -> 54:6, #27 -Counter in file 0 54:6 -> 54:7, #28 -Counter in file 0 56:8 -> 56:15, #29 -Counter in file 0 56:16 -> 58:6, #30 -Counter in file 0 58:12 -> 60:6, #31 -Counter in file 0 61:1 -> 61:2, #32 +Counter in file 0 14:6 -> 14:7, (#1 - #2) +Counter in file 0 16:9 -> 16:17, ((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) +Counter in file 0 18:13 -> 18:18, (#2 + (#1 - #2)) +Counter in file 0 20:13 -> 20:18, ((#2 + (#1 - #2)) - #3) +Counter in file 0 20:18 -> 20:19, (#3 + #4) +Counter in file 0 20:18 -> 20:19, (((#2 + (#1 - #2)) - #3) - #4) +Counter in file 0 23:9 -> 23:17, ((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) +Counter in file 0 25:13 -> 25:18, (((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) + 0) +Counter in file 0 27:13 -> 27:18, (((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) +Counter in file 0 27:18 -> 27:19, (#5 + #6) +Counter in file 0 27:18 -> 27:19, ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6) +Counter in file 0 29:9 -> 29:17, ((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) +Counter in file 0 29:20 -> 29:25, (((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) + 0) +Counter in file 0 29:29 -> 29:34, #7 +Counter in file 0 29:34 -> 29:35, ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8) +Counter in file 0 29:34 -> 29:35, (#7 - #8) +Counter in file 0 30:9 -> 30:17, ((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) +Counter in file 0 30:20 -> 30:25, (((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) + 0) +Counter in file 0 30:29 -> 30:34, #9 +Counter in file 0 30:34 -> 30:35, ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10) +Counter in file 0 30:34 -> 30:35, (#9 - #10) +Counter in file 0 33:9 -> 34:16, (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) + 0) +Counter in file 0 35:5 -> 38:6, #11 +Counter in file 0 38:6 -> 38:7, (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11) +Counter in file 0 41:9 -> 41:16, (#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) +Counter in file 0 42:5 -> 45:6, #12 +Counter in file 0 47:5 -> 50:6, ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12) +Counter in file 0 52:8 -> 52:16, (#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) +Counter in file 0 52:17 -> 54:6, #13 +Counter in file 0 54:6 -> 54:7, ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13) +Counter in file 0 56:8 -> 56:15, (#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) +Counter in file 0 56:16 -> 58:6, #14 +Counter in file 0 58:12 -> 60:6, ((#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) - #14) +Counter in file 0 61:1 -> 61:2, (#14 + ((#13 + ((#12 + ((#11 + (((#9 - #10) + ((((#7 - #8) + ((((#5 + #6) + ((((#3 + #4) + (((#2 + (#1 - #2)) - #3) - #4)) - #5) - #6)) - #7) + #8)) - #9) + #10)) - #11)) - #12)) - #13)) - #14)) Emitting segments for file: ../coverage/lazy_boolean.rs Combined regions: 7:9 -> 9:42 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt index 3e0bc6e49592..235557ba3495 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt @@ -1,12 +1,12 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loops_and_branches.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loops_and_branches Counter in file 0 10:12 -> 10:16, #1 Counter in file 0 11:16 -> 11:21, #2 -Counter in file 0 14:14 -> 14:15, #6 -Counter in file 0 15:13 -> 15:31, #7 -Counter in file 0 15:31 -> 15:32, #8 -Counter in file 0 17:10 -> 17:11, #10 -Counter in file 0 18:9 -> 18:15, #11 -Counter in file 0 19:5 -> 19:6, #12 +Counter in file 0 14:14 -> 14:15, (#2 - #5) +Counter in file 0 15:13 -> 15:31, (0 + (#2 - #5)) +Counter in file 0 15:31 -> 15:32, #4 +Counter in file 0 17:10 -> 17:11, #3 +Counter in file 0 18:9 -> 18:15, (#3 + 0) +Counter in file 0 19:5 -> 19:6, (#4 + (#3 + 0)) Counter in file 0 22:11 -> 25:2, #1 Emitting segments for file: ../coverage/loops_and_branches.rs Combined regions: diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt index a19f62533165..6bc26f94ac7c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt @@ -1,22 +1,22 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/nested_loops.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/nested_loops Counter in file 0 2:9 -> 3:27, #1 -Counter in file 0 5:19 -> 5:32, #2 -Counter in file 0 6:13 -> 7:24, #3 -Counter in file 0 8:13 -> 8:14, #4 -Counter in file 0 8:18 -> 8:23, #5 -Counter in file 0 9:16 -> 9:22, (#4 + 0) -Counter in file 0 10:17 -> 10:22, #6 -Counter in file 0 12:13 -> 12:19, #7 -Counter in file 0 13:13 -> 13:19, #8 -Counter in file 0 14:16 -> 14:22, (#8 + 0) -Counter in file 0 15:17 -> 16:27, #9 -Counter in file 0 17:21 -> 17:33, #10 -Counter in file 0 19:21 -> 21:14, #11 -Counter in file 0 21:14 -> 21:15, #12 -Counter in file 0 22:10 -> 22:11, #13 -Counter in file 0 23:9 -> 23:23, #14 -Counter in file 0 24:6 -> 24:7, #15 -Counter in file 0 25:1 -> 25:2, #16 +Counter in file 0 5:19 -> 5:32, (#1 + #2) +Counter in file 0 6:13 -> 7:24, ((#1 + #2) - #3) +Counter in file 0 8:13 -> 8:14, ((((#1 + #2) - #3) + (#5 + #6)) - #7) +Counter in file 0 8:18 -> 8:23, (((#1 + #2) - #3) + (#5 + #6)) +Counter in file 0 9:16 -> 9:22, (((((#1 + #2) - #3) + (#5 + #6)) - #7) + 0) +Counter in file 0 10:17 -> 10:22, #8 +Counter in file 0 12:13 -> 12:19, #9 +Counter in file 0 13:13 -> 13:19, #10 +Counter in file 0 14:16 -> 14:22, (#10 + 0) +Counter in file 0 15:17 -> 16:27, #11 +Counter in file 0 17:21 -> 17:33, #4 +Counter in file 0 19:21 -> 21:14, #5 +Counter in file 0 21:14 -> 21:15, #6 +Counter in file 0 22:10 -> 22:11, (#5 + #6) +Counter in file 0 23:9 -> 23:23, #2 +Counter in file 0 24:6 -> 24:7, #3 +Counter in file 0 25:1 -> 25:2, (#4 + #3) Emitting segments for file: ../coverage/nested_loops.rs Combined regions: 2:9 -> 3:27 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt index a444ea449017..5ab9a99d6868 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt @@ -1,8 +1,5 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/partial_eq_counter_without_region.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/partial_eq_counter_without_region -Counter in file 0 4:39 -> 4:49, #1 -Counter in file 0 4:39 -> 4:49, #2 -Counter in file 0 4:39 -> 4:49, #3 -Counter in file 0 4:48 -> 4:49, #4 +Counter in file 0 4:48 -> 4:49, ((#1 + #2) + ((#3 + #4) + ((#5 + #6) + #7))) Counter in file 0 8:5 -> 8:17, #1 Counter in file 0 21:11 -> 26:2, #1 Counter in file 0 4:39 -> 4:40, #1 @@ -11,15 +8,8 @@ Counter in file 0 7:5 -> 7:6, #1 Counter in file 0 8:5 -> 8:17, #1 Counter in file 0 4:39 -> 4:40, #1 Counter in file 0 4:48 -> 4:49, (#1 + 0) -Counter in file 0 4:24 -> 4:33, #1 -Counter in file 0 4:24 -> 4:33, #2 -Counter in file 0 4:24 -> 4:33, #3 -Counter in file 0 4:24 -> 4:33, #4 -Counter in file 0 4:32 -> 4:33, #5 -Counter in file 0 4:51 -> 4:54, #1 -Counter in file 0 4:51 -> 4:54, #2 -Counter in file 0 4:51 -> 4:54, #3 -Counter in file 0 4:53 -> 4:54, #4 +Counter in file 0 4:32 -> 4:33, ((#4 + #5) + #6) +Counter in file 0 4:53 -> 4:54, (#1 + (#2 + (#3 + #4))) Counter in file 0 13:9 -> 18:6, #1 Counter in file 0 7:5 -> 7:6, #1 Counter in file 0 4:39 -> 4:40, #1 @@ -33,9 +23,7 @@ Counter in file 0 4:17 -> 4:22, #1 Counter in file 0 8:5 -> 8:17, #1 Counter in file 0 4:39 -> 4:40, #1 Counter in file 0 4:48 -> 4:49, (#1 + 0) -Counter in file 0 4:24 -> 4:33, #1 -Counter in file 0 4:24 -> 4:33, #2 -Counter in file 0 4:32 -> 4:33, #3 +Counter in file 0 4:32 -> 4:33, (#3 + (#1 + #2)) Emitting segments for file: ../coverage/partial_eq_counter_without_region.rs Combined regions: 4:17 -> 4:22 (count=2) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt index 90e09099dcc4..60d861e9d2e1 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt @@ -2,12 +2,12 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 12:9 -> 12:16, (#1 + 0) Counter in file 0 13:5 -> 18:6, #2 -Counter in file 0 18:6 -> 18:7, #3 -Counter in file 0 23:13 -> 25:14, #4 -Counter in file 0 27:13 -> 27:18, #5 -Counter in file 0 30:9 -> 32:10, #6 -Counter in file 0 34:6 -> 34:7, #7 -Counter in file 0 35:1 -> 35:2, (#5 + 0) +Counter in file 0 18:6 -> 18:7, (#1 - #2) +Counter in file 0 23:13 -> 25:14, ((#2 + (#1 - #2)) + #3) +Counter in file 0 27:13 -> 27:18, #4 +Counter in file 0 30:9 -> 32:10, #3 +Counter in file 0 34:6 -> 34:7, (#2 + (#1 - #2)) +Counter in file 0 35:1 -> 35:2, (#4 + 0) Emitting segments for file: ../coverage/simple_loop.rs Combined regions: 7:9 -> 9:26 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt index 39a986332cd9..1683b68e9664 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt @@ -2,18 +2,18 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 7:9 -> 9:26, #1 Counter in file 0 10:8 -> 10:15, (#1 + 0) Counter in file 0 10:16 -> 12:6, #2 -Counter in file 0 12:6 -> 12:7, #3 -Counter in file 0 15:9 -> 15:10, #4 -Counter in file 0 17:9 -> 17:13, #5 -Counter in file 0 22:13 -> 22:22, (#4 + 0) -Counter in file 0 24:13 -> 24:14, #6 -Counter in file 0 26:17 -> 28:18, (#4 + 0) -Counter in file 0 28:18 -> 28:19, #7 -Counter in file 0 30:13 -> 37:14, (#6 + 0) -Counter in file 0 40:13 -> 40:15, #8 -Counter in file 0 42:6 -> 42:7, #9 -Counter in file 0 42:6 -> 42:7, #10 -Counter in file 0 43:1 -> 43:2, #11 +Counter in file 0 12:6 -> 12:7, (#1 - #2) +Counter in file 0 15:9 -> 15:10, (((#2 + (#1 - #2)) + (#3 + #4)) - #5) +Counter in file 0 17:9 -> 17:13, ((#2 + (#1 - #2)) + (#3 + #4)) +Counter in file 0 22:13 -> 22:22, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) + 0) +Counter in file 0 24:13 -> 24:14, #3 +Counter in file 0 26:17 -> 28:18, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) + 0) +Counter in file 0 28:18 -> 28:19, ((((#2 + (#1 - #2)) + (#3 + #4)) - #5) - #3) +Counter in file 0 30:13 -> 37:14, (#3 + 0) +Counter in file 0 40:13 -> 40:15, #4 +Counter in file 0 42:6 -> 42:7, (#2 + (#1 - #2)) +Counter in file 0 42:6 -> 42:7, (#3 + #4) +Counter in file 0 43:1 -> 43:2, #5 Emitting segments for file: ../coverage/simple_match.rs Combined regions: 7:9 -> 9:26 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt index a0687815fb96..39a3cf5458c6 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt @@ -1,6 +1,6 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/tight_infinite_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/tight_infinite_loop Counter in file 0 2:8 -> 2:13, #1 -Counter in file 0 5:1 -> 5:2, #4 +Counter in file 0 5:1 -> 5:2, (#1 - #2) Emitting segments for file: ../coverage/tight_infinite_loop.rs Combined regions: 2:8 -> 2:13 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt index 25e1c8930bca..9cfc05e874a5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt @@ -1,22 +1,21 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/try_error_result.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/try_error_result Counter in file 0 13:9 -> 14:23, #1 -Counter in file 0 17:9 -> 17:10, #2 -Counter in file 0 19:9 -> 19:14, #3 -Counter in file 0 21:9 -> 25:26, #4 -Counter in file 0 27:13 -> 27:41, #5 -Counter in file 0 27:41 -> 27:42, #6 -Counter in file 0 31:13 -> 31:42, #7 -Counter in file 0 31:42 -> 31:43, #8 -Counter in file 0 32:10 -> 32:11, #9 -Counter in file 0 32:10 -> 32:11, #10 -Counter in file 0 33:6 -> 33:7, #11 -Counter in file 0 34:5 -> 34:11, #12 -Counter in file 0 35:1 -> 35:2, #13 -Counter in file 0 35:1 -> 35:2, #14 +Counter in file 0 17:9 -> 17:10, ((#1 + (#2 + #3)) - #4) +Counter in file 0 19:9 -> 19:14, (#1 + (#2 + #3)) +Counter in file 0 21:9 -> 25:26, #7 +Counter in file 0 27:13 -> 27:41, #8 +Counter in file 0 27:41 -> 27:42, #5 +Counter in file 0 31:13 -> 31:42, (#7 - #8) +Counter in file 0 31:42 -> 31:43, #6 +Counter in file 0 32:10 -> 32:11, #2 +Counter in file 0 32:10 -> 32:11, #3 +Counter in file 0 33:6 -> 33:7, (#2 + #3) +Counter in file 0 34:5 -> 34:11, #4 +Counter in file 0 35:1 -> 35:2, ((#5 + #6) + #4) Counter in file 0 5:8 -> 5:20, #1 Counter in file 0 6:9 -> 6:16, #2 -Counter in file 0 8:9 -> 8:15, #3 -Counter in file 0 10:1 -> 10:2, #4 +Counter in file 0 8:9 -> 8:15, (#1 - #2) +Counter in file 0 10:1 -> 10:2, (#2 + (#1 - #2)) Emitting segments for file: ../coverage/try_error_result.rs Combined regions: 5:8 -> 5:20 (count=6) @@ -34,7 +33,7 @@ Combined regions: 32:10 -> 32:11 (count=5) 33:6 -> 33:7 (count=5) 34:5 -> 34:11 (count=0) - 35:1 -> 35:2 (count=2) + 35:1 -> 35:2 (count=1) Segment at 5:8 (count = 6), RegionEntry Segment at 5:20 (count = 0), Skipped Segment at 6:9 (count = 1), RegionEntry @@ -63,5 +62,5 @@ Segment at 33:6 (count = 5), RegionEntry Segment at 33:7 (count = 0), Skipped Segment at 34:5 (count = 0), RegionEntry Segment at 34:11 (count = 0), Skipped -Segment at 35:1 (count = 2), RegionEntry +Segment at 35:1 (count = 1), RegionEntry Segment at 35:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt index 567c8cd9b6df..ba80cadbd3c8 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt @@ -2,73 +2,72 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/ Counter in file 0 4:9 -> 4:26, #1 Counter in file 0 5:8 -> 5:12, (#1 + 0) Counter in file 0 5:13 -> 7:6, #2 -Counter in file 0 10:9 -> 10:10, #4 -Counter in file 0 10:16 -> 10:29, #5 -Counter in file 0 11:9 -> 12:10, #6 -Counter in file 0 13:15 -> 13:28, #7 -Counter in file 0 14:12 -> 14:25, #8 -Counter in file 0 14:29 -> 14:42, #9 -Counter in file 0 14:42 -> 14:43, #10 -Counter in file 0 14:42 -> 14:43, #11 -Counter in file 0 14:46 -> 14:60, #12 -Counter in file 0 14:60 -> 14:61, #13 -Counter in file 0 14:60 -> 14:61, #14 -Counter in file 0 14:61 -> 16:10, #15 -Counter in file 0 16:10 -> 16:11, #16 -Counter in file 0 17:9 -> 18:18, #17 -Counter in file 0 20:9 -> 20:15, #18 -Counter in file 0 23:9 -> 23:26, (#4 + 0) -Counter in file 0 24:8 -> 24:12, (#4 + 0) -Counter in file 0 24:13 -> 26:6, #19 -Counter in file 0 28:8 -> 28:21, #21 -Counter in file 0 29:9 -> 29:23, #22 -Counter in file 0 30:15 -> 30:28, #23 -Counter in file 0 31:12 -> 31:25, #24 -Counter in file 0 31:29 -> 31:42, #25 -Counter in file 0 31:42 -> 31:43, #26 -Counter in file 0 31:42 -> 31:43, #27 -Counter in file 0 31:46 -> 31:60, #28 -Counter in file 0 31:60 -> 31:61, #29 -Counter in file 0 31:60 -> 31:61, #30 -Counter in file 0 31:61 -> 33:10, #31 -Counter in file 0 33:10 -> 33:11, #32 -Counter in file 0 34:9 -> 34:23, #33 -Counter in file 0 36:9 -> 36:15, #34 -Counter in file 0 39:9 -> 39:26, #35 -Counter in file 0 40:8 -> 40:12, (#35 + 0) -Counter in file 0 40:13 -> 42:6, #36 -Counter in file 0 44:9 -> 44:10, #38 -Counter in file 0 44:16 -> 44:29, #39 -Counter in file 0 45:9 -> 45:23, #40 -Counter in file 0 46:15 -> 46:28, #41 -Counter in file 0 47:12 -> 47:25, #42 -Counter in file 0 47:29 -> 47:42, #43 -Counter in file 0 47:42 -> 47:43, #44 -Counter in file 0 47:42 -> 47:43, #45 -Counter in file 0 47:46 -> 47:60, #46 -Counter in file 0 47:60 -> 47:61, #47 -Counter in file 0 47:60 -> 47:61, #48 -Counter in file 0 47:61 -> 49:10, #49 -Counter in file 0 49:10 -> 49:11, #50 -Counter in file 0 50:9 -> 50:23, #51 -Counter in file 0 52:13 -> 54:15, #52 -Counter in file 0 57:9 -> 57:10, #53 -Counter in file 0 57:16 -> 57:29, (#38 + 0) -Counter in file 0 58:9 -> 58:23, #54 -Counter in file 0 59:15 -> 59:28, #55 -Counter in file 0 60:12 -> 60:25, #56 -Counter in file 0 60:29 -> 60:42, #57 -Counter in file 0 60:42 -> 60:43, #58 -Counter in file 0 60:42 -> 60:43, #59 -Counter in file 0 60:46 -> 60:60, #60 -Counter in file 0 60:60 -> 60:61, #61 -Counter in file 0 60:60 -> 60:61, #62 -Counter in file 0 60:61 -> 62:10, #63 -Counter in file 0 62:10 -> 62:11, #64 -Counter in file 0 63:9 -> 63:23, #65 -Counter in file 0 65:9 -> 65:15, #66 -Counter in file 0 67:1 -> 67:2, #67 -Counter in file 0 67:1 -> 67:2, #68 +Counter in file 0 10:9 -> 10:10, (#4 + #11) +Counter in file 0 10:16 -> 10:29, (#2 + 0) +Counter in file 0 11:9 -> 12:10, #4 +Counter in file 0 13:15 -> 13:28, ((#2 + 0) - #3) +Counter in file 0 14:12 -> 14:25, #5 +Counter in file 0 14:29 -> 14:42, (#5 - #13) +Counter in file 0 14:42 -> 14:43, (#13 + #14) +Counter in file 0 14:42 -> 14:43, ((#5 - #13) - #14) +Counter in file 0 14:46 -> 14:60, #21 +Counter in file 0 14:60 -> 14:61, (#17 + #18) +Counter in file 0 14:60 -> 14:61, (#21 - #18) +Counter in file 0 14:61 -> 16:10, #22 +Counter in file 0 16:10 -> 16:11, #23 +Counter in file 0 17:9 -> 18:18, #11 +Counter in file 0 20:9 -> 20:15, (((#2 + 0) - #3) - #5) +Counter in file 0 23:9 -> 23:26, ((#4 + #11) + 0) +Counter in file 0 24:8 -> 24:12, ((#4 + #11) + 0) +Counter in file 0 24:13 -> 26:6, #12 +Counter in file 0 28:8 -> 28:21, (#12 + 0) +Counter in file 0 29:9 -> 29:23, #16 +Counter in file 0 30:15 -> 30:28, ((#12 + 0) - #15) +Counter in file 0 31:12 -> 31:25, (((#12 + 0) - #15) - #8) +Counter in file 0 31:29 -> 31:42, ((((#12 + 0) - #15) - #8) - #24) +Counter in file 0 31:42 -> 31:43, (((((#12 + 0) - #15) - #8) - #24) - #25) +Counter in file 0 31:42 -> 31:43, (#24 + #25) +Counter in file 0 31:46 -> 31:60, #32 +Counter in file 0 31:60 -> 31:61, (#28 + #29) +Counter in file 0 31:60 -> 31:61, (#32 - #29) +Counter in file 0 31:61 -> 33:10, #33 +Counter in file 0 33:10 -> 33:11, #34 +Counter in file 0 34:9 -> 34:23, #19 +Counter in file 0 36:9 -> 36:15, #8 +Counter in file 0 39:9 -> 39:26, (#16 + #19) +Counter in file 0 40:8 -> 40:12, ((#16 + #19) + 0) +Counter in file 0 40:13 -> 42:6, #20 +Counter in file 0 44:9 -> 44:10, (#27 + #30) +Counter in file 0 44:16 -> 44:29, (#20 + 0) +Counter in file 0 45:9 -> 45:23, #27 +Counter in file 0 46:15 -> 46:28, ((#20 + 0) - #26) +Counter in file 0 47:12 -> 47:25, (((#20 + 0) - #26) - #7) +Counter in file 0 47:29 -> 47:42, ((((#20 + 0) - #26) - #7) - #35) +Counter in file 0 47:42 -> 47:43, (#35 + #36) +Counter in file 0 47:42 -> 47:43, (((((#20 + 0) - #26) - #7) - #35) - #36) +Counter in file 0 47:46 -> 47:60, #41 +Counter in file 0 47:60 -> 47:61, (#37 + #38) +Counter in file 0 47:60 -> 47:61, (#41 - #38) +Counter in file 0 47:61 -> 49:10, #42 +Counter in file 0 49:10 -> 49:11, #43 +Counter in file 0 50:9 -> 50:23, #30 +Counter in file 0 52:13 -> 54:15, #7 +Counter in file 0 57:9 -> 57:10, (#9 + #10) +Counter in file 0 57:16 -> 57:29, ((#27 + #30) + 0) +Counter in file 0 58:9 -> 58:23, #9 +Counter in file 0 59:15 -> 59:28, ((#27 + #30) - #31) +Counter in file 0 60:12 -> 60:25, (((#27 + #30) - #31) - #6) +Counter in file 0 60:29 -> 60:42, ((((#27 + #30) - #31) - #6) - #39) +Counter in file 0 60:42 -> 60:43, (#39 + #40) +Counter in file 0 60:42 -> 60:43, (((((#27 + #30) - #31) - #6) - #39) - #40) +Counter in file 0 60:46 -> 60:60, #46 +Counter in file 0 60:60 -> 60:61, (#46 - #45) +Counter in file 0 60:60 -> 60:61, (#44 + #45) +Counter in file 0 60:61 -> 62:10, #47 +Counter in file 0 62:10 -> 62:11, #48 +Counter in file 0 63:9 -> 63:23, #10 +Counter in file 0 65:9 -> 65:15, #6 +Counter in file 0 67:1 -> 67:2, ((#9 + #10) + (((#6 + #7) + #8) + (((#2 + 0) - #3) - #5))) Emitting segments for file: ../coverage/various_conditions.rs Combined regions: 4:9 -> 4:26 (count=1) @@ -131,7 +130,7 @@ Combined regions: 62:10 -> 62:11 (count=0) 63:9 -> 63:23 (count=0) 65:9 -> 65:15 (count=0) - 67:1 -> 67:2 (count=2) + 67:1 -> 67:2 (count=1) Segment at 4:9 (count = 1), RegionEntry Segment at 4:26 (count = 0), Skipped Segment at 5:8 (count = 1), RegionEntry @@ -236,5 +235,5 @@ Segment at 63:9 (count = 0), RegionEntry Segment at 63:23 (count = 0), Skipped Segment at 65:9 (count = 0), RegionEntry Segment at 65:15 (count = 0), Skipped -Segment at 67:1 (count = 2), RegionEntry +Segment at 67:1 (count = 1), RegionEntry Segment at 67:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt index b75a88b2e929..76cf1e92ecd3 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt @@ -1,8 +1,8 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while Counter in file 0 2:9 -> 2:16, #1 -Counter in file 0 3:11 -> 3:20, #2 -Counter in file 0 3:21 -> 4:6, #3 -Counter in file 0 5:1 -> 5:2, #4 +Counter in file 0 3:11 -> 3:20, (#1 + #2) +Counter in file 0 3:21 -> 4:6, #2 +Counter in file 0 5:1 -> 5:2, ((#1 + #2) - #2) Emitting segments for file: ../coverage/while.rs Combined regions: 2:9 -> 2:16 (count=1) diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt index 908613018a49..60f389fc9d46 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt @@ -1,14 +1,13 @@ Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while_early_return.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while_early_return Counter in file 0 5:9 -> 5:27, #1 -Counter in file 0 7:9 -> 9:10, #2 -Counter in file 0 12:13 -> 14:14, #3 -Counter in file 0 18:21 -> 20:22, #4 -Counter in file 0 22:21 -> 22:27, #5 -Counter in file 0 26:21 -> 26:27, #6 -Counter in file 0 30:9 -> 32:10, #7 -Counter in file 0 35:5 -> 35:11, #8 -Counter in file 0 36:1 -> 36:2, #9 -Counter in file 0 36:1 -> 36:2, #10 +Counter in file 0 7:9 -> 9:10, (#1 + #2) +Counter in file 0 12:13 -> 14:14, ((#1 + #2) - #3) +Counter in file 0 18:21 -> 20:22, #6 +Counter in file 0 22:21 -> 22:27, #4 +Counter in file 0 26:21 -> 26:27, #5 +Counter in file 0 30:9 -> 32:10, #2 +Counter in file 0 35:5 -> 35:11, #3 +Counter in file 0 36:1 -> 36:2, ((#4 + #5) + #3) Emitting segments for file: ../coverage/while_early_return.rs Combined regions: 5:9 -> 5:27 (count=1) @@ -19,7 +18,7 @@ Combined regions: 26:21 -> 26:27 (count=1) 30:9 -> 32:10 (count=6) 35:5 -> 35:11 (count=0) - 36:1 -> 36:2 (count=2) + 36:1 -> 36:2 (count=1) Segment at 5:9 (count = 1), RegionEntry Segment at 5:27 (count = 0), Skipped Segment at 7:9 (count = 7), RegionEntry @@ -36,5 +35,5 @@ Segment at 30:9 (count = 6), RegionEntry Segment at 32:10 (count = 0), Skipped Segment at 35:5 (count = 0), RegionEntry Segment at 35:11 (count = 0), Skipped -Segment at 36:1 (count = 2), RegionEntry +Segment at 36:1 (count = 1), RegionEntry Segment at 36:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html index 325b6c64345a..494e6f20ea76 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html @@ -114,6 +114,6 @@ Ok(())⦉@2,6,7,8 -}@1,3,4,5,9,10⦊‸⦉@1,3,4,5,9,10@2,6,7,8⦊‸⦉@2,6,7,8@11⦊‸⦉@11 +}@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html index 55d7e8bfbae1..6dc893d28ff5 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html @@ -162,6 +162,6 @@ Ok(())⦉@5,9,10,11 -}@4,6,7,8,12,13⦊‸⦉@4,6,7,8,12,13@5,9,10,11⦊‸⦉@5,9,10,11@14⦊‸⦉@14 +}@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html index 094dacde9868..b51c5c84c0d6 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html @@ -128,36 +128,36 @@ 20:9-22:16: @5[1]: _6 = const ()"> = 100⦉@5 - }@4,6⦊‸⦉@4,6 + } if - @7⦊is_true⦉@7 - @8,10⦊{ - countdown - = - 10 - ; - }⦉@8,10 else - @9⦊{ - countdown - = - 100 - ; - }⦉@9@8,10⦊‸⦉@8,10 + }⦉@9 }@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html index 8a0b1ae8dab1..9f9933423406 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html @@ -67,7 +67,7 @@ } else { @2⦊Ok(())⦉@2 - }@1,3⦊‸⦉@1,3 -}@4⦊‸⦉@4 + } +}@4⦊‸⦉@4 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html index 325b6c64345a..494e6f20ea76 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html @@ -114,6 +114,6 @@ Ok(())⦉@2,6,7,8 -}@1,3,4,5,9,10⦊‸⦉@1,3,4,5,9,10@2,6,7,8⦊‸⦉@2,6,7,8@11⦊‸⦉@11 +}@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html index 55d7e8bfbae1..6dc893d28ff5 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html @@ -162,6 +162,6 @@ Ok(())⦉@5,9,10,11 -}@4,6,7,8,12,13⦊‸⦉@4,6,7,8,12,13@5,9,10,11⦊‸⦉@5,9,10,11@14⦊‸⦉@14 +}@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html index 094dacde9868..b51c5c84c0d6 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html @@ -128,36 +128,36 @@ 20:9-22:16: @5[1]: _6 = const ()"> = 100⦉@5 - }@4,6⦊‸⦉@4,6 + } if - @7⦊is_true⦉@7 - @8,10⦊{ - countdown - = - 10 - ; - }⦉@8,10 else - @9⦊{ - countdown - = - 100 - ; - }⦉@9@8,10⦊‸⦉@8,10 + }⦉@9 }@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html index 8a0b1ae8dab1..9f9933423406 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html @@ -67,7 +67,7 @@ } else { @2⦊Ok(())⦉@2 - }@1,3⦊‸⦉@1,3 -}@4⦊‸⦉@4 + } +}@4⦊‸⦉@4