diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs index c1163a871cf..41827a91ba4 100644 --- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs +++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs @@ -129,7 +129,7 @@ impl CoverageMapGenerator { let (filenames_index, _) = self.filenames.insert_full(c_filename); virtual_file_mapping.push(filenames_index as u32); } - debug!("Adding counter {:?} to map for {:?}", counter, region,); + debug!("Adding counter {:?} to map for {:?}", counter, region); mapping_regions.push(CounterMappingRegion::code_region( counter, current_file_id, diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs index 7fdbe1a5512..c4b4032fd47 100644 --- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs +++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs @@ -12,7 +12,7 @@ use rustc_codegen_ssa::traits::{ use rustc_data_structures::fx::FxHashMap; use rustc_llvm::RustString; use rustc_middle::mir::coverage::{ - CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionIndex, Op, + CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionId, Op, }; use rustc_middle::ty::Instance; @@ -27,8 +27,8 @@ const COVMAP_VAR_ALIGN_BYTES: usize = 8; /// A context object for maintaining all state needed by the coverageinfo module. pub struct CrateCoverageContext<'tcx> { - // Coverage region data for each instrumented function identified by DefId. - pub(crate) function_coverage_map: RefCell, FunctionCoverage>>, + // Coverage data for each instrumented function identified by DefId. + pub(crate) function_coverage_map: RefCell, FunctionCoverage<'tcx>>>, } impl<'tcx> CrateCoverageContext<'tcx> { @@ -36,7 +36,7 @@ impl<'tcx> CrateCoverageContext<'tcx> { Self { function_coverage_map: Default::default() } } - pub fn take_function_coverage_map(&self) -> FxHashMap, FunctionCoverage> { + pub fn take_function_coverage_map(&self) -> FxHashMap, FunctionCoverage<'tcx>> { self.function_coverage_map.replace(FxHashMap::default()) } } @@ -58,7 +58,23 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> { unsafe { llvm::LLVMRustCoverageCreatePGOFuncNameVar(llfn, mangled_fn_name.as_ptr()) } } - fn add_counter_region( + 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={}", + instance, function_source_hash, + ); + let mut coverage_map = coverage_context.function_coverage_map.borrow_mut(); + coverage_map + .entry(instance) + .or_insert_with(|| FunctionCoverage::new(self.tcx, instance)) + .set_function_source_hash(function_source_hash); + } else { + false + } + } + + fn add_coverage_counter( &mut self, instance: Instance<'tcx>, function_source_hash: u64, @@ -67,59 +83,53 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> { ) -> bool { if let Some(coverage_context) = self.coverage_context() { debug!( - "adding counter to coverage_regions: instance={:?}, function_source_hash={}, id={:?}, \ + "adding counter to coverage_map: instance={:?}, function_source_hash={}, id={:?}, \ at {:?}", instance, function_source_hash, id, region, ); - let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut(); - coverage_regions + let mut coverage_map = coverage_context.function_coverage_map.borrow_mut(); + coverage_map .entry(instance) .or_insert_with(|| FunctionCoverage::new(self.tcx, instance)) .add_counter(function_source_hash, id, region); - true } else { false } } - fn add_counter_expression_region( + fn add_coverage_counter_expression( &mut self, instance: Instance<'tcx>, - id: InjectedExpressionIndex, + id: InjectedExpressionId, lhs: ExpressionOperandId, op: Op, rhs: ExpressionOperandId, - region: CodeRegion, - ) -> bool { - if let Some(coverage_context) = self.coverage_context() { + region: Option, + ) { + if let Some(coverage_context) = self.coverage_context() -> bool { debug!( - "adding counter expression to coverage_regions: instance={:?}, id={:?}, {:?} {:?} {:?}, \ - at {:?}", + "adding counter expression to coverage_map: instance={:?}, id={:?}, {:?} {:?} {:?}; \ + region: {:?}", instance, id, lhs, op, rhs, region, ); - let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut(); - coverage_regions + let mut coverage_map = coverage_context.function_coverage_map.borrow_mut(); + coverage_map .entry(instance) .or_insert_with(|| FunctionCoverage::new(self.tcx, instance)) .add_counter_expression(id, lhs, op, rhs, region); - true } else { false } } - fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool { + 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_regions: instance={:?}, at {:?}", - instance, region, - ); - let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut(); - coverage_regions + 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/coverageinfo/ffi.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs index a266d179a42..bcac2c90fdc 100644 --- a/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs +++ b/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs @@ -3,7 +3,7 @@ use rustc_middle::mir::coverage::{CounterValueReference, MappedExpressionIndex}; /// Aligns with [llvm::coverage::Counter::CounterKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L91) #[derive(Copy, Clone, Debug)] #[repr(C)] -enum CounterKind { +pub enum CounterKind { Zero = 0, CounterValueReference = 1, Expression = 2, @@ -23,8 +23,8 @@ enum CounterKind { #[repr(C)] pub struct Counter { // Important: The layout (order and types of fields) must match its C++ counterpart. - kind: CounterKind, - id: u32, + pub kind: CounterKind, + pub id: u32, } impl Counter { @@ -55,9 +55,9 @@ pub enum ExprKind { #[derive(Copy, Clone, Debug)] #[repr(C)] pub struct CounterExpression { - kind: ExprKind, - lhs: Counter, - rhs: Counter, + pub kind: ExprKind, + pub lhs: Counter, + pub rhs: Counter, } impl CounterExpression { diff --git a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs index d8bde8ee705..006d6662196 100644 --- a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs +++ b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs @@ -2,18 +2,18 @@ pub use super::ffi::*; use rustc_index::vec::IndexVec; use rustc_middle::mir::coverage::{ - CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionIndex, - MappedExpressionIndex, Op, + CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionId, + InjectedExpressionIndex, MappedExpressionIndex, Op, }; use rustc_middle::ty::Instance; use rustc_middle::ty::TyCtxt; #[derive(Clone, Debug)] -pub struct ExpressionRegion { +pub struct Expression { lhs: ExpressionOperandId, op: Op, rhs: ExpressionOperandId, - region: CodeRegion, + region: Option, } /// Collects all of the coverage regions associated with (a) injected counters, (b) counter @@ -28,17 +28,23 @@ pub struct ExpressionRegion { /// only whitespace or comments). According to LLVM Code Coverage Mapping documentation, "A count /// for a gap area is only used as the line execution count if there are no other regions on a /// line." -pub struct FunctionCoverage { +pub struct FunctionCoverage<'tcx> { + instance: Instance<'tcx>, source_hash: u64, counters: IndexVec>, - expressions: IndexVec>, + expressions: IndexVec>, unreachable_regions: Vec, } -impl FunctionCoverage { - pub fn new<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self { +impl<'tcx> FunctionCoverage<'tcx> { + pub fn new(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self { let coverageinfo = tcx.coverageinfo(instance.def_id()); + debug!( + "FunctionCoverage::new(instance={:?}) has coverageinfo={:?}", + instance, coverageinfo + ); Self { + instance, source_hash: 0, // will be set with the first `add_counter()` counters: IndexVec::from_elem_n(None, coverageinfo.num_counters as usize), expressions: IndexVec::from_elem_n(None, coverageinfo.num_expressions as usize), @@ -46,6 +52,19 @@ impl FunctionCoverage { } } + /// Although every function should have at least one `Counter`, the `Counter` isn't required to + /// have a `CodeRegion`. (The `CodeRegion` may be associated only with `Expressions`.) This + /// method supports the ability to ensure the `function_source_hash` is set from `Counters` that + /// do not trigger the call to `add_counter()` because they don't have an associated + /// `CodeRegion` to add. + pub fn set_function_source_hash(&mut self, source_hash: u64) { + if self.source_hash == 0 { + self.source_hash = source_hash; + } else { + debug_assert_eq!(source_hash, self.source_hash); + } + } + /// Adds a code region to be counted by an injected counter intrinsic. /// The source_hash (computed during coverage instrumentation) should also be provided, and /// should be the same for all counters in a given function. @@ -74,15 +93,19 @@ impl FunctionCoverage { /// counters and expressions have been added. pub fn add_counter_expression( &mut self, - expression_id: InjectedExpressionIndex, + expression_id: InjectedExpressionId, lhs: ExpressionOperandId, op: Op, rhs: ExpressionOperandId, - region: CodeRegion, + region: Option, ) { + debug!( + "add_counter_expression({:?}, lhs={:?}, op={:?}, rhs={:?} at {:?}", + expression_id, lhs, op, rhs, region + ); let expression_index = self.expression_index(u32::from(expression_id)); self.expressions[expression_index] - .replace(ExpressionRegion { lhs, op, rhs, region }) + .replace(Expression { lhs, op, rhs, region }) .expect_none("add_counter_expression called with duplicate `id_descending_from_max`"); } @@ -103,7 +126,11 @@ impl FunctionCoverage { pub fn get_expressions_and_counter_regions<'a>( &'a self, ) -> (Vec, impl Iterator) { - assert!(self.source_hash != 0); + assert!( + self.source_hash != 0, + "No counters provided the source_hash for function: {:?}", + self.instance + ); let counter_regions = self.counter_regions(); let (counter_expressions, expression_regions) = self.expressions_with_regions(); @@ -129,54 +156,60 @@ impl FunctionCoverage { ) -> (Vec, impl Iterator) { let mut counter_expressions = Vec::with_capacity(self.expressions.len()); let mut expression_regions = Vec::with_capacity(self.expressions.len()); - let mut new_indexes = - IndexVec::from_elem_n(MappedExpressionIndex::from(u32::MAX), self.expressions.len()); - // Note, the initial value shouldn't matter since every index in use in `self.expressions` - // will be set, and after that, `new_indexes` will only be accessed using those same - // indexes. - - // Note that an `ExpressionRegion`s at any given index can include other expressions as + let mut new_indexes = IndexVec::from_elem_n(None, self.expressions.len()); + // Note that an `Expression`s at any given index can include other expressions as // operands, but expression operands can only come from the subset of expressions having - // `expression_index`s lower than the referencing `ExpressionRegion`. Therefore, it is + // `expression_index`s lower than the referencing `Expression`. Therefore, it is // reasonable to look up the new index of an expression operand while the `new_indexes` // vector is only complete up to the current `ExpressionIndex`. let id_to_counter = - |new_indexes: &IndexVec, + |new_indexes: &IndexVec>, id: ExpressionOperandId| { if id == ExpressionOperandId::ZERO { Some(Counter::zero()) } else if id.index() < self.counters.len() { + // Note: Some codegen-injected Counters may be only referenced by `Expression`s, + // and may not have their own `CodeRegion`s, let index = CounterValueReference::from(id.index()); - self.counters - .get(index) - .unwrap() // pre-validated - .as_ref() - .map(|_| Counter::counter_value_reference(index)) + Some(Counter::counter_value_reference(index)) } else { let index = self.expression_index(u32::from(id)); self.expressions .get(index) .expect("expression id is out of range") .as_ref() - .map(|_| Counter::expression(new_indexes[index])) + // If an expression was optimized out, assume it would have produced a count + // of zero. This ensures that expressions dependent on optimized-out + // expressions are still valid. + .map_or(Some(Counter::zero()), |_| { + new_indexes[index].map(|new_index| Counter::expression(new_index)) + }) } }; - for (original_index, expression_region) in + for (original_index, expression) in self.expressions.iter_enumerated().filter_map(|(original_index, entry)| { // Option::map() will return None to filter out missing expressions. This may happen // if, for example, a MIR-instrumented expression is removed during an optimization. - entry.as_ref().map(|region| (original_index, region)) + entry.as_ref().map(|expression| (original_index, expression)) }) { - let region = &expression_region.region; - let ExpressionRegion { lhs, op, rhs, .. } = *expression_region; + let optional_region = &expression.region; + let Expression { lhs, op, rhs, .. } = *expression; if let Some(Some((lhs_counter, rhs_counter))) = id_to_counter(&new_indexes, lhs).map(|lhs_counter| { id_to_counter(&new_indexes, rhs).map(|rhs_counter| (lhs_counter, rhs_counter)) }) { + debug_assert!( + (lhs_counter.id as usize) + < usize::max(self.counters.len(), self.expressions.len()) + ); + debug_assert!( + (rhs_counter.id as usize) + < usize::max(self.counters.len(), self.expressions.len()) + ); // Both operands exist. `Expression` operands exist in `self.expressions` and have // been assigned a `new_index`. let mapped_expression_index = @@ -190,12 +223,20 @@ impl FunctionCoverage { rhs_counter, ); debug!( - "Adding expression {:?} = {:?} at {:?}", - mapped_expression_index, expression, region + "Adding expression {:?} = {:?}, region: {:?}", + mapped_expression_index, expression, optional_region ); counter_expressions.push(expression); - new_indexes[original_index] = mapped_expression_index; - expression_regions.push((Counter::expression(mapped_expression_index), region)); + new_indexes[original_index] = Some(mapped_expression_index); + if let Some(region) = optional_region { + expression_regions.push((Counter::expression(mapped_expression_index), region)); + } + } else { + debug!( + "Ignoring expression with one or more missing operands: \ + original_index={:?}, lhs={:?}, op={:?}, rhs={:?}, region={:?}", + original_index, lhs, op, rhs, optional_region, + ) } } (counter_expressions, expression_regions.into_iter()) diff --git a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs index 4811adea9ec..e52f952e932 100644 --- a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs +++ b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs @@ -10,7 +10,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { let Coverage { kind, code_region } = coverage; match kind { CoverageKind::Counter { function_source_hash, id } => { - if bx.add_counter_region(self.instance, function_source_hash, id, code_region) { + let covmap_updated = if let Some(code_region) = code_region { + // Note: Some counters do not have code regions, but may still be referenced from + // expressions. + bx.add_coverage_counter(self.instance, function_source_hash, id, code_region) + } else { + bx.set_function_source_hash(self.instance, function_source_hash) + }; + + if covmap_updated { let coverageinfo = bx.tcx().coverageinfo(self.instance.def_id()); let fn_name = bx.create_pgo_func_name_var(self.instance); @@ -21,14 +29,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { "codegen intrinsic instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})", fn_name, hash, num_counters, id, ); - bx.instrprof_increment(fn_name, hash, num_counters, id); + bx.instrprof_increment(fn_name, hash, num_counters, index); } } CoverageKind::Expression { id, lhs, op, rhs } => { - bx.add_counter_expression_region(self.instance, id, lhs, op, rhs, code_region); + bx.add_coverage_counter_expression(self.instance, id, lhs, op, rhs, code_region); } CoverageKind::Unreachable => { - bx.add_unreachable_region(self.instance, code_region); + bx.add_coverage_unreachable( + self.instance, + code_region.expect("unreachable regions always have code regions"), + ); } } } diff --git a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs index 3b1654f3ad4..5aa0950b399 100644 --- a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs +++ b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs @@ -9,9 +9,13 @@ pub trait CoverageInfoMethods: BackendTypes { pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes { fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value; + /// 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; + /// Returns true if the counter was added to the coverage map; false if `-Z instrument-coverage` /// is not enabled (a coverage map is not being generated). - fn add_counter_region( + fn add_coverage_counter( &mut self, instance: Instance<'tcx>, function_source_hash: u64, @@ -21,17 +25,17 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes { /// Returns true if the expression was added to the coverage map; false if /// `-Z instrument-coverage` is not enabled (a coverage map is not being generated). - fn add_counter_expression_region( + fn add_coverage_counter_expression( &mut self, instance: Instance<'tcx>, - id: InjectedExpressionIndex, + id: InjectedExpressionId, lhs: ExpressionOperandId, op: Op, rhs: ExpressionOperandId, - region: CodeRegion, - ) -> bool; + region: Option, + ); /// 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). - fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool; + fn add_coverage_unreachable(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool; } diff --git a/compiler/rustc_graphviz/src/lib.rs b/compiler/rustc_graphviz/src/lib.rs index d332466160c..9653ff022f1 100644 --- a/compiler/rustc_graphviz/src/lib.rs +++ b/compiler/rustc_graphviz/src/lib.rs @@ -643,6 +643,7 @@ where } if options.contains(&RenderOption::DarkTheme) { graph_attrs.push(r#"bgcolor="black""#); + graph_attrs.push(r#"fontcolor="white""#); content_attrs.push(r#"color="white""#); content_attrs.push(r#"fontcolor="white""#); } diff --git a/compiler/rustc_middle/src/mir/coverage.rs b/compiler/rustc_middle/src/mir/coverage.rs index 0421eabc2dc..ad0ba292d02 100644 --- a/compiler/rustc_middle/src/mir/coverage.rs +++ b/compiler/rustc_middle/src/mir/coverage.rs @@ -7,6 +7,10 @@ use std::cmp::Ord; use std::fmt::{self, Debug, Formatter}; rustc_index::newtype_index! { + /// An ExpressionOperandId value is assigned directly from either a + /// CounterValueReference.as_u32() (which ascend from 1) or an ExpressionOperandId.as_u32() + /// (which _*descend*_ from u32::MAX). Id value `0` (zero) represents a virtual counter with a + /// constant value of `0`. pub struct ExpressionOperandId { derive [HashStable] DEBUG_FORMAT = "ExpressionOperandId({})", @@ -42,6 +46,20 @@ impl CounterValueReference { } rustc_index::newtype_index! { + /// InjectedExpressionId.as_u32() converts to ExpressionOperandId.as_u32() + /// + /// Values descend from u32::MAX. + pub struct InjectedExpressionId { + derive [HashStable] + DEBUG_FORMAT = "InjectedExpressionId({})", + MAX = 0xFFFF_FFFF, + } +} + +rustc_index::newtype_index! { + /// InjectedExpressionIndex.as_u32() translates to u32::MAX - ExpressionOperandId.as_u32() + /// + /// Values ascend from 0. pub struct InjectedExpressionIndex { derive [HashStable] DEBUG_FORMAT = "InjectedExpressionIndex({})", @@ -50,6 +68,9 @@ rustc_index::newtype_index! { } rustc_index::newtype_index! { + /// MappedExpressionIndex values ascend from zero, and are recalculated indexes based on their + /// array position in the LLVM coverage map "Expressions" array, which is assembled during the + /// "mapgen" process. They cannot be computed algorithmically, from the other `newtype_index`s. pub struct MappedExpressionIndex { derive [HashStable] DEBUG_FORMAT = "MappedExpressionIndex({})", @@ -64,21 +85,35 @@ impl From for ExpressionOperandId { } } -impl From for ExpressionOperandId { +impl From<&mut CounterValueReference> for ExpressionOperandId { #[inline] - fn from(v: InjectedExpressionIndex) -> ExpressionOperandId { + fn from(v: &mut CounterValueReference) -> ExpressionOperandId { ExpressionOperandId::from(v.as_u32()) } } -#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] +impl From for ExpressionOperandId { + #[inline] + fn from(v: InjectedExpressionId) -> ExpressionOperandId { + ExpressionOperandId::from(v.as_u32()) + } +} + +impl From<&mut InjectedExpressionId> for ExpressionOperandId { + #[inline] + fn from(v: &mut InjectedExpressionId) -> ExpressionOperandId { + ExpressionOperandId::from(v.as_u32()) + } +} + +#[derive(Clone, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum CoverageKind { Counter { function_source_hash: u64, id: CounterValueReference, }, Expression { - id: InjectedExpressionIndex, + id: InjectedExpressionId, lhs: ExpressionOperandId, op: Op, rhs: ExpressionOperandId, @@ -88,12 +123,47 @@ pub enum CoverageKind { impl CoverageKind { pub fn as_operand_id(&self) -> ExpressionOperandId { + use CoverageKind::*; match *self { - CoverageKind::Counter { id, .. } => ExpressionOperandId::from(id), - CoverageKind::Expression { id, .. } => ExpressionOperandId::from(id), - CoverageKind::Unreachable => { - bug!("Unreachable coverage cannot be part of an expression") - } + Counter { id, .. } => ExpressionOperandId::from(id), + Expression { id, .. } => ExpressionOperandId::from(id), + Unreachable => bug!("Unreachable coverage cannot be part of an expression"), + } + } + + pub fn is_counter(&self) -> bool { + match self { + Self::Counter { .. } => true, + _ => false, + } + } + + pub fn is_expression(&self) -> bool { + match self { + Self::Expression { .. } => true, + _ => false, + } + } + + pub fn is_unreachable(&self) -> bool { + *self == Self::Unreachable + } +} + +impl Debug for CoverageKind { + fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result { + use CoverageKind::*; + match self { + Counter { id, .. } => write!(fmt, "Counter({:?})", id.index()), + Expression { id, lhs, op, rhs } => write!( + fmt, + "Expression({:?}) = {} {} {}", + id.index(), + lhs.index(), + if *op == Op::Add { "+" } else { "-" }, + rhs.index(), + ), + Unreachable => write!(fmt, "Unreachable"), } } } diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index bf091201e10..5fe7b0f647d 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -1585,21 +1585,10 @@ impl Debug for Statement<'_> { write!(fmt, "AscribeUserType({:?}, {:?}, {:?})", place, variance, c_ty) } Coverage(box ref coverage) => { - let rgn = &coverage.code_region; - match coverage.kind { - CoverageKind::Counter { id, .. } => { - write!(fmt, "Coverage::Counter({:?}) for {:?}", id.index(), rgn) - } - CoverageKind::Expression { id, lhs, op, rhs } => write!( - fmt, - "Coverage::Expression({:?}) = {} {} {} for {:?}", - id.index(), - lhs.index(), - if op == coverage::Op::Add { "+" } else { "-" }, - rhs.index(), - rgn - ), - CoverageKind::Unreachable => write!(fmt, "Coverage::Unreachable for {:?}", rgn), + if let Some(rgn) = &coverage.code_region { + write!(fmt, "Coverage::{:?} for {:?}", coverage.kind, rgn) + } else { + write!(fmt, "Coverage::{:?}", coverage.kind) } } Nop => write!(fmt, "nop"), @@ -1610,7 +1599,7 @@ impl Debug for Statement<'_> { #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct Coverage { pub kind: CoverageKind, - pub code_region: CodeRegion, + pub code_region: Option, } /////////////////////////////////////////////////////////////////////////// diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs index 431225e2767..89fd803fe51 100644 --- a/compiler/rustc_middle/src/ty/structural_impls.rs +++ b/compiler/rustc_middle/src/ty/structural_impls.rs @@ -300,6 +300,7 @@ CloneTypeFoldableAndLiftImpls! { ::rustc_target::spec::abi::Abi, crate::mir::coverage::ExpressionOperandId, crate::mir::coverage::CounterValueReference, + crate::mir::coverage::InjectedExpressionId, crate::mir::coverage::InjectedExpressionIndex, crate::mir::coverage::MappedExpressionIndex, crate::mir::Local, diff --git a/compiler/rustc_mir/src/transform/instrument_coverage.rs b/compiler/rustc_mir/src/transform/instrument_coverage.rs index 6824c73ab60..cb6798f2ee7 100644 --- a/compiler/rustc_mir/src/transform/instrument_coverage.rs +++ b/compiler/rustc_mir/src/transform/instrument_coverage.rs @@ -1,9 +1,10 @@ use crate::transform::MirPass; use crate::util::pretty; -use crate::util::spanview::{self, SpanViewable}; +use crate::util::spanview::{self, source_range_no_file, SpanViewable}; use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::graph::dominators::Dominators; +use rustc_data_structures::graph::WithNumNodes; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::sync::Lrc; use rustc_index::bit_set::BitSet; @@ -16,7 +17,7 @@ use rustc_middle::mir::coverage::*; use rustc_middle::mir::visit::Visitor; use rustc_middle::mir::{ AggregateKind, BasicBlock, BasicBlockData, Coverage, CoverageInfo, FakeReadCause, Location, - Rvalue, SourceInfo, Statement, StatementKind, Terminator, TerminatorKind, + Rvalue, Statement, StatementKind, Terminator, TerminatorKind, }; use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; @@ -28,11 +29,6 @@ use std::cmp::Ordering; const ID_SEPARATOR: &str = ","; -/// 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. -pub struct InstrumentCoverage; - /// The `query` provider for `CoverageInfo`, requested by `codegen_coverage()` (to inject each /// counter) and `FunctionCoverage::new()` (to extract the coverage map metadata from the MIR). pub(crate) fn provide(providers: &mut Providers) { @@ -54,23 +50,72 @@ pub(crate) fn provide(providers: &mut Providers) { /// are still included in the total `num_counters` or `num_expressions`.) Simply counting the /// calls may not work; but computing the number of counters or expressions by adding `1` to the /// highest ID (for a given instrumented function) is valid. +/// +/// This visitor runs twice, first with `add_missing_operands` set to `false`, to find the maximum +/// counter ID and maximum expression ID based on their enum variant `id` fields; then, as a +/// safeguard, with `add_missing_operands` set to `true`, to find any other counter or expression +/// IDs referenced by expression operands, if not already seen. +/// +/// Ideally, every expression operand in the MIR will have a corresponding Counter or Expression, +/// but since current or future MIR optimizations can theoretically optimize out segments of a +/// MIR, it may not be possible to guarantee this, so the second pass ensures the `CoverageInfo` +/// counts include all referenced IDs. struct CoverageVisitor { info: CoverageInfo, + add_missing_operands: bool, +} + +impl CoverageVisitor { + // If an expression operand is encountered with an ID outside the range of known counters and + // expressions, the only way to determine if the ID is a counter ID or an expression ID is to + // assume a maximum possible counter ID value. + const MAX_COUNTER_GUARD: u32 = (u32::MAX / 2) + 1; + + #[inline(always)] + fn update_num_counters(&mut self, counter_id: u32) { + self.info.num_counters = std::cmp::max(self.info.num_counters, counter_id + 1); + } + + #[inline(always)] + fn update_num_expressions(&mut self, expression_id: u32) { + let expression_index = u32::MAX - expression_id; + self.info.num_expressions = std::cmp::max(self.info.num_expressions, expression_index + 1); + } + + fn update_from_expression_operand(&mut self, operand_id: u32) { + if operand_id >= self.info.num_counters { + let operand_as_expression_index = u32::MAX - operand_id; + if operand_as_expression_index >= self.info.num_expressions { + if operand_id <= Self::MAX_COUNTER_GUARD { + self.update_num_counters(operand_id) + } else { + self.update_num_expressions(operand_id) + } + } + } + } } impl Visitor<'_> for CoverageVisitor { fn visit_coverage(&mut self, coverage: &Coverage, _location: Location) { - match coverage.kind { - CoverageKind::Counter { id, .. } => { - let counter_id = u32::from(id); - self.info.num_counters = std::cmp::max(self.info.num_counters, counter_id + 1); + if self.add_missing_operands { + match coverage.kind { + CoverageKind::Expression { lhs, rhs, .. } => { + self.update_from_expression_operand(u32::from(lhs)); + self.update_from_expression_operand(u32::from(rhs)); + } + _ => {} } - CoverageKind::Expression { id, .. } => { - let expression_index = u32::MAX - u32::from(id); - self.info.num_expressions = - std::cmp::max(self.info.num_expressions, expression_index + 1); + } else { + match coverage.kind { + CoverageKind::Counter { id, .. } => { + self.update_num_counters(u32::from(id)); + } + CoverageKind::Expression { id, .. } => { + self.update_num_expressions(u32::from(id)); + } + _ => {} } - _ => {} } } } @@ -78,45 +123,58 @@ impl Visitor<'_> for CoverageVisitor { fn coverageinfo_from_mir<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> CoverageInfo { let mir_body = tcx.optimized_mir(def_id); - let mut coverage_visitor = - CoverageVisitor { info: CoverageInfo { num_counters: 0, num_expressions: 0 } }; + let mut coverage_visitor = CoverageVisitor { + info: CoverageInfo { num_counters: 0, num_expressions: 0 }, + add_missing_operands: false, + }; coverage_visitor.visit_body(mir_body); + + coverage_visitor.add_missing_operands = true; + coverage_visitor.visit_body(mir_body); + coverage_visitor.info } +/// 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. +pub struct InstrumentCoverage; impl<'tcx> MirPass<'tcx> for InstrumentCoverage { fn run_pass(&self, tcx: TyCtxt<'tcx>, mir_body: &mut mir::Body<'tcx>) { + let mir_source = mir_body.source; + // If the InstrumentCoverage pass is called on promoted MIRs, skip them. // See: https://github.com/rust-lang/rust/pull/73011#discussion_r438317601 - if mir_body.source.promoted.is_some() { + if mir_source.promoted.is_some() { trace!( "InstrumentCoverage skipped for {:?} (already promoted for Miri evaluation)", - mir_body.source.def_id() + mir_source.def_id() ); return; } - let hir_id = tcx.hir().local_def_id_to_hir_id(mir_body.source.def_id().expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(mir_source.def_id().expect_local()); let is_fn_like = FnLikeNode::from_node(tcx.hir().get(hir_id)).is_some(); // Only instrument functions, methods, and closures (not constants since they are evaluated // at compile time by Miri). - // FIXME(#73156): Handle source code coverage in const eval + // FIXME(#73156): Handle source code coverage in const eval, but note, if and when const + // expressions get coverage spans, we will probably have to "carve out" space for const + // expressions from coverage spans in enclosing MIR's, like we do for closures. (That might + // be tricky if const expressions have no corresponding statements in the enclosing MIR. + // Closures are carved out by their initial `Assign` statement.) if !is_fn_like { - trace!( - "InstrumentCoverage skipped for {:?} (not an FnLikeNode)", - mir_body.source.def_id(), - ); + trace!("InstrumentCoverage skipped for {:?} (not an FnLikeNode)", mir_source.def_id()); return; } // FIXME(richkadel): By comparison, the MIR pass `ConstProp` includes associated constants, // with functions, methods, and closures. I assume Miri is used for associated constants as // well. If not, we may need to include them here too. - trace!("InstrumentCoverage starting for {:?}", mir_body.source.def_id()); + trace!("InstrumentCoverage starting for {:?}", mir_source.def_id()); Instrumentor::new(&self.name(), tcx, mir_body).inject_counters(); - trace!("InstrumentCoverage starting for {:?}", mir_body.source.def_id()); + trace!("InstrumentCoverage starting for {:?}", mir_source.def_id()); } } @@ -184,12 +242,16 @@ impl BasicCoverageBlocks { } pub fn iter(&self) -> impl Iterator { - self.vec.iter().filter_map(|option| option.as_ref()) + self.vec.iter().filter_map(|bcb| bcb.as_ref()) } - fn extract_from_mir(&mut self, mir_body: &mir::Body<'tcx>) { + pub fn num_nodes(&self) -> usize { + self.vec.len() + } + + pub fn extract_from_mir(&mut self, mir_body: &mir::Body<'tcx>) { // Traverse the CFG but ignore anything following an `unwind` - let cfg_without_unwind = ShortCircuitPreorder::new(mir_body, |term_kind| { + let cfg_without_unwind = ShortCircuitPreorder::new(&mir_body, |term_kind| { let mut successors = term_kind.successors(); match &term_kind { // SwitchInt successors are never unwind, and all of them should be traversed. @@ -337,20 +399,20 @@ impl CoverageStatement { pub fn format(&self, tcx: TyCtxt<'tcx>, mir_body: &'a mir::Body<'tcx>) -> String { match *self { Self::Statement(bb, span, stmt_index) => { - let stmt = &mir_body.basic_blocks()[bb].statements[stmt_index]; + let stmt = &mir_body[bb].statements[stmt_index]; format!( "{}: @{}[{}]: {:?}", - spanview::source_range_no_file(tcx, &span), + source_range_no_file(tcx, &span), bb.index(), stmt_index, stmt ) } Self::Terminator(bb, span) => { - let term = mir_body.basic_blocks()[bb].terminator(); + let term = mir_body[bb].terminator(); format!( "{}: @{}.{}: {:?}", - spanview::source_range_no_file(tcx, &span), + source_range_no_file(tcx, &span), bb.index(), term_type(&term.kind), term.kind @@ -366,6 +428,8 @@ impl CoverageStatement { } } +/// Returns a simple string representation of a `TerminatorKind` variant, indenpendent of any +/// values it might hold. fn term_type(kind: &TerminatorKind<'tcx>) -> &'static str { match kind { TerminatorKind::Goto { .. } => "Goto", @@ -398,10 +462,10 @@ fn term_type(kind: &TerminatorKind<'tcx>) -> &'static str { /// `is_dominated_by()` the `BasicBlock`s in this `CoverageSpan`. #[derive(Debug, Clone)] struct CoverageSpan { - span: Span, - bcb_leader_bb: BasicBlock, - coverage_statements: Vec, - is_closure: bool, + pub span: Span, + pub bcb_leader_bb: BasicBlock, + pub coverage_statements: Vec, + pub is_closure: bool, } impl CoverageSpan { @@ -428,7 +492,7 @@ impl CoverageSpan { } } - pub fn for_terminator(span: Span, bcb: &'a BasicCoverageBlock, bb: BasicBlock) -> Self { + pub fn for_terminator(span: Span, bcb: &BasicCoverageBlock, bb: BasicBlock) -> Self { Self { span, bcb_leader_bb: bcb.leader_bb(), @@ -455,52 +519,208 @@ impl CoverageSpan { } } - pub fn is_dominated_by( - &self, - other: &CoverageSpan, - dominators: &Dominators, - ) -> bool { - debug_assert!(!self.is_in_same_bcb(other)); - dominators.is_dominated_by(self.bcb_leader_bb, other.bcb_leader_bb) - } - + #[inline] pub fn is_mergeable(&self, other: &Self) -> bool { self.is_in_same_bcb(other) && !(self.is_closure || other.is_closure) } + #[inline] pub fn is_in_same_bcb(&self, other: &Self) -> bool { self.bcb_leader_bb == other.bcb_leader_bb } + + pub fn format_coverage_statements( + &self, + tcx: TyCtxt<'tcx>, + mir_body: &'a mir::Body<'tcx>, + ) -> String { + let mut sorted_coverage_statements = self.coverage_statements.clone(); + sorted_coverage_statements.sort_unstable_by_key(|covstmt| match *covstmt { + CoverageStatement::Statement(bb, _, index) => (bb, index), + CoverageStatement::Terminator(bb, _) => (bb, usize::MAX), + }); + sorted_coverage_statements + .iter() + .map(|covstmt| covstmt.format(tcx, mir_body)) + .collect::>() + .join("\n") + } } struct Instrumentor<'a, 'tcx> { pass_name: &'a str, tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>, - hir_body: &'tcx rustc_hir::Body<'tcx>, - dominators: Option>, - basic_coverage_blocks: Option, - function_source_hash: Option, - next_counter_id: u32, - num_expressions: u32, + body_span: Span, + basic_coverage_blocks: BasicCoverageBlocks, + coverage_counters: CoverageCounters, } impl<'a, 'tcx> Instrumentor<'a, 'tcx> { fn new(pass_name: &'a str, tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self { let hir_body = hir_body(tcx, mir_body.source.def_id()); + let body_span = hir_body.value.span; + let function_source_hash = hash_mir_source(tcx, hir_body); + let basic_coverage_blocks = BasicCoverageBlocks::from_mir(mir_body); Self { pass_name, tcx, mir_body, - hir_body, - dominators: None, - basic_coverage_blocks: None, - function_source_hash: None, + body_span, + basic_coverage_blocks, + coverage_counters: CoverageCounters::new(function_source_hash), + } + } + + fn inject_counters(&'a mut self) { + let tcx = self.tcx; + let source_map = tcx.sess.source_map(); + let mir_source = self.mir_body.source; + let def_id = mir_source.def_id(); + let body_span = self.body_span; + + debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span)); + + //////////////////////////////////////////////////// + // Compute `CoverageSpan`s from the `BasicCoverageBlocks`. + let coverage_spans = CoverageSpans::generate_coverage_spans( + &self.mir_body, + body_span, + &self.basic_coverage_blocks, + ); + + if pretty::dump_enabled(tcx, self.pass_name, def_id) { + dump_coverage_spanview( + tcx, + self.mir_body, + &self.basic_coverage_blocks, + self.pass_name, + &coverage_spans, + ); + } + + self.inject_coverage_span_counters(coverage_spans); + } + + /// 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` 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. + fn inject_coverage_span_counters(&mut self, coverage_spans: Vec) { + let tcx = self.tcx; + let source_map = tcx.sess.source_map(); + let body_span = self.body_span; + let source_file = source_map.lookup_source_file(body_span.lo()); + let file_name = Symbol::intern(&source_file.name.to_string()); + + let mut bb_counters = IndexVec::from_elem_n(None, self.mir_body.basic_blocks().len()); + for CoverageSpan { span, bcb_leader_bb: bb, .. } in coverage_spans { + if let Some(&counter_operand) = bb_counters[bb].as_ref() { + let expression = self.coverage_counters.make_expression( + counter_operand, + Op::Add, + ExpressionOperandId::ZERO, + ); + debug!( + "Injecting counter expression {:?} at: {:?}:\n{}\n==========", + expression, + span, + source_map.span_to_snippet(span).expect("Error getting source for span"), + ); + let code_region = make_code_region(file_name, &source_file, span, body_span); + inject_statement(self.mir_body, expression, bb, Some(code_region)); + } else { + let counter = self.coverage_counters.make_counter(); + 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(); + bb_counters[bb] = Some(counter_operand); + let code_region = make_code_region(file_name, &source_file, span, body_span); + inject_statement(self.mir_body, counter, bb, Some(code_region)); + } + } + } +} + +/// Generates the MIR pass `CoverageSpan`-specific spanview dump file. +fn dump_coverage_spanview( + tcx: TyCtxt<'tcx>, + mir_body: &mir::Body<'tcx>, + basic_coverage_blocks: &BasicCoverageBlocks, + pass_name: &str, + coverage_spans: &Vec, +) { + let mir_source = mir_body.source; + let def_id = mir_source.def_id(); + + let span_viewables = span_viewables(tcx, mir_body, basic_coverage_blocks, &coverage_spans); + let mut file = pretty::create_dump_file(tcx, "html", None, pass_name, &0, mir_source) + .expect("Unexpected error creating MIR spanview HTML file"); + let crate_name = tcx.crate_name(def_id.krate); + let item_name = tcx.def_path(def_id).to_filename_friendly_no_crate(); + let title = format!("{}.{} - Coverage Spans", crate_name, item_name); + spanview::write_document(tcx, def_id, span_viewables, &title, &mut file) + .expect("Unexpected IO error dumping coverage spans as HTML"); +} + +/// Converts the computed `BasicCoverageBlock`s into `SpanViewable`s. +fn span_viewables( + tcx: TyCtxt<'tcx>, + mir_body: &mir::Body<'tcx>, + basic_coverage_blocks: &BasicCoverageBlocks, + coverage_spans: &Vec, +) -> Vec { + let mut span_viewables = Vec::new(); + for coverage_span in coverage_spans { + let tooltip = coverage_span.format_coverage_statements(tcx, mir_body); + let CoverageSpan { span, bcb_leader_bb: bb, .. } = coverage_span; + let bcb = &basic_coverage_blocks[*bb]; + let id = bcb.id(); + let leader_bb = bcb.leader_bb(); + span_viewables.push(SpanViewable { bb: leader_bb, span: *span, id, tooltip }); + } + span_viewables +} + +/// Manages the counter and expression indexes/IDs to generate `CoverageKind` components for MIR +/// `Coverage` statements. +struct CoverageCounters { + function_source_hash: u64, + next_counter_id: u32, + num_expressions: u32, +} + +impl CoverageCounters { + pub fn new(function_source_hash: u64) -> Self { + Self { + function_source_hash, next_counter_id: CounterValueReference::START.as_u32(), num_expressions: 0, } } + pub fn make_counter(&mut self) -> CoverageKind { + CoverageKind::Counter { + function_source_hash: self.function_source_hash, + id: self.next_counter(), + } + } + + pub fn make_expression( + &mut self, + lhs: ExpressionOperandId, + op: Op, + rhs: ExpressionOperandId, + ) -> CoverageKind { + let id = self.next_expression(); + CoverageKind::Expression { id, lhs, op, rhs } + } + /// Counter IDs start from one and go up. fn next_counter(&mut self) -> CounterValueReference { assert!(self.next_counter_id < u32::MAX - self.num_expressions); @@ -509,206 +729,123 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { CounterValueReference::from(next) } - /// Expression IDs start from u32::MAX and go down because a CounterExpression can reference - /// (add or subtract counts) of both Counter regions and CounterExpression regions. The counter + /// Expression IDs start from u32::MAX and go down because a Expression can reference + /// (add or subtract counts) of both Counter regions and Expression regions. The counter /// expression operand IDs must be unique across both types. - fn next_expression(&mut self) -> InjectedExpressionIndex { + fn next_expression(&mut self) -> InjectedExpressionId { assert!(self.next_counter_id < u32::MAX - self.num_expressions); let next = u32::MAX - self.num_expressions; self.num_expressions += 1; - InjectedExpressionIndex::from(next) + InjectedExpressionId::from(next) } +} +fn inject_statement( + mir_body: &mut mir::Body<'tcx>, + counter_kind: CoverageKind, + bb: BasicBlock, + some_code_region: Option, +) { + debug!( + " injecting statement {:?} for {:?} at code region: {:?}", + counter_kind, bb, some_code_region + ); + let data = &mut mir_body[bb]; + let source_info = data.terminator().source_info; + let statement = Statement { + source_info, + kind: StatementKind::Coverage(box Coverage { + kind: counter_kind, + code_region: some_code_region, + }), + }; + data.statements.push(statement); +} - fn dominators(&self) -> &Dominators { - self.dominators.as_ref().expect("dominators must be initialized before calling") - } +/// Converts the initial set of `CoverageSpan`s (one per MIR `Statement` or `Terminator`) into a +/// minimal set of `CoverageSpan`s, using the BCB CFG to determine where it is safe and useful to: +/// +/// * Remove duplicate source code coverage regions +/// * Merge spans that represent continuous (both in source code and control flow), non-branching +/// execution +/// * Carve out (leave uncovered) any span that will be counted by another MIR (notably, closures) +pub struct CoverageSpans<'a, 'tcx> { + /// The MIR, used to look up `BasicBlockData`. + mir_body: &'a mir::Body<'tcx>, - fn basic_coverage_blocks(&self) -> &BasicCoverageBlocks { - self.basic_coverage_blocks - .as_ref() - .expect("basic_coverage_blocks must be initialized before calling") - } + /// A snapshot of the MIR CFG dominators before injecting any coverage statements. + dominators: Dominators, - fn function_source_hash(&mut self) -> u64 { - match self.function_source_hash { - Some(hash) => hash, - None => { - let hash = hash_mir_source(self.tcx, self.hir_body); - self.function_source_hash.replace(hash); - hash - } - } - } + /// A `Span` covering the function body of the MIR (typically from left curly brace to right + /// curly brace). + body_span: Span, - fn inject_counters(&mut self) { - let tcx = self.tcx; - let source_map = tcx.sess.source_map(); - let def_id = self.mir_body.source.def_id(); - let mir_body = &self.mir_body; - let body_span = self.body_span(); - let source_file = source_map.lookup_source_file(body_span.lo()); - let file_name = Symbol::intern(&source_file.name.to_string()); + /// The BasicCoverageBlock Control Flow Graph (BCB CFG). + basic_coverage_blocks: &'a BasicCoverageBlocks, - debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span)); + /// The initial set of `CoverageSpan`s, sorted by `Span` (`lo` and `hi`) and by relative + /// dominance between the `BasicCoverageBlock`s of equal `Span`s. + sorted_spans_iter: Option>, - self.dominators.replace(mir_body.dominators()); - self.basic_coverage_blocks.replace(BasicCoverageBlocks::from_mir(mir_body)); + /// The current `CoverageSpan` to compare to its `prev`, to possibly merge, discard, force the + /// discard of the `prev` (and or `pending_dups`), or keep both (with `prev` moved to + /// `pending_dups`). If `curr` is not discarded or merged, it becomes `prev` for the next + /// iteration. + some_curr: Option, - let coverage_spans = self.coverage_spans(); + /// The original `span` for `curr`, in case the `curr` span is modified. + curr_original_span: Span, - let span_viewables = if pretty::dump_enabled(tcx, self.pass_name, def_id) { - Some(self.span_viewables(&coverage_spans)) - } else { - None + /// The CoverageSpan from a prior iteration; typically assigned from that iteration's `curr`. + /// If that `curr` was discarded, `prev` retains its value from the previous iteration. + some_prev: Option, + + /// Assigned from `curr_original_span` from the previous iteration. + prev_original_span: Span, + + /// One or more `CoverageSpan`s with the same `Span` but different `BasicCoverageBlock`s, and + /// no `BasicCoverageBlock` in this list dominates another `BasicCoverageBlock` in the list. + /// If a new `curr` span also fits this criteria (compared to an existing list of + /// `pending_dups`), that `curr` `CoverageSpan` moves to `prev` before possibly being added to + /// the `pending_dups` list, on the next iteration. As a result, if `prev` and `pending_dups` + /// have the same `Span`, the criteria for `pending_dups` holds for `prev` as well: a `prev` + /// with a matching `Span` does not dominate any `pending_dup` and no `pending_dup` dominates a + /// `prev` with a matching `Span`) + pending_dups: Vec, + + /// The final `CoverageSpan`s to add to the coverage map. A `Counter` or `Expression` + /// will also be injected into the MIR for each `CoverageSpan`. + refined_spans: Vec, +} + +impl<'a, 'tcx> CoverageSpans<'a, 'tcx> { + fn generate_coverage_spans( + mir_body: &'a mir::Body<'tcx>, + body_span: Span, + basic_coverage_blocks: &'a BasicCoverageBlocks, + ) -> Vec { + let dominators = mir_body.dominators(); + let mut coverage_spans = CoverageSpans { + mir_body, + dominators, + body_span, + basic_coverage_blocks, + sorted_spans_iter: None, + refined_spans: Vec::with_capacity(basic_coverage_blocks.num_nodes() * 2), + some_curr: None, + curr_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)), + some_prev: None, + prev_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)), + pending_dups: Vec::new(), }; - // 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. `bb_counters` - // maps each `bcb_leader_bb` to its `Counter`, when injected. Subsequent `CoverageSpan`s - // for a BCB that already has a `Counter` will inject a `CounterExpression` instead, and - // compute its value by adding `ZERO` to the BCB `Counter` value. - let mut bb_counters = IndexVec::from_elem_n(None, mir_body.basic_blocks().len()); - for CoverageSpan { span, bcb_leader_bb: bb, .. } in coverage_spans { - if let Some(&counter_operand) = bb_counters[bb].as_ref() { - let expression = - self.make_expression(counter_operand, Op::Add, ExpressionOperandId::ZERO); - debug!( - "Injecting counter expression {:?} at: {:?}:\n{}\n==========", - expression, - span, - source_map.span_to_snippet(span).expect("Error getting source for span"), - ); - self.inject_statement(file_name, &source_file, expression, span, bb); - } else { - let counter = self.make_counter(); - 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(); - bb_counters[bb] = Some(counter_operand); - self.inject_statement(file_name, &source_file, counter, span, bb); - } - } + let sorted_spans = coverage_spans.mir_to_initial_sorted_coverage_spans(); - if let Some(span_viewables) = span_viewables { - let mut file = pretty::create_dump_file( - tcx, - "html", - None, - self.pass_name, - &0, - self.mir_body.source, - ) - .expect("Unexpected error creating MIR spanview HTML file"); - let crate_name = tcx.crate_name(def_id.krate); - let item_name = tcx.def_path(def_id).to_filename_friendly_no_crate(); - let title = format!("{}.{} - Coverage Spans", crate_name, item_name); - spanview::write_document(tcx, def_id, span_viewables, &title, &mut file) - .expect("Unexpected IO error dumping coverage spans as HTML"); - } - } + coverage_spans.sorted_spans_iter = Some(sorted_spans.into_iter()); + coverage_spans.some_prev = coverage_spans.sorted_spans_iter.as_mut().unwrap().next(); + coverage_spans.prev_original_span = + coverage_spans.some_prev.as_ref().expect("at least one span").span; - fn make_counter(&mut self) -> CoverageKind { - CoverageKind::Counter { - function_source_hash: self.function_source_hash(), - id: self.next_counter(), - } - } - - fn make_expression( - &mut self, - lhs: ExpressionOperandId, - op: Op, - rhs: ExpressionOperandId, - ) -> CoverageKind { - CoverageKind::Expression { id: self.next_expression(), lhs, op, rhs } - } - - fn inject_statement( - &mut self, - file_name: Symbol, - source_file: &Lrc, - coverage_kind: CoverageKind, - span: Span, - block: BasicBlock, - ) { - let code_region = make_code_region(file_name, source_file, span); - debug!(" injecting statement {:?} covering {:?}", coverage_kind, code_region); - - let data = &mut self.mir_body[block]; - let source_info = data.terminator().source_info; - let statement = Statement { - source_info, - kind: StatementKind::Coverage(box Coverage { kind: coverage_kind, code_region }), - }; - data.statements.push(statement); - } - - /// Converts the computed `BasicCoverageBlock`s into `SpanViewable`s. - fn span_viewables(&self, coverage_spans: &Vec) -> Vec { - let tcx = self.tcx; - let mir_body = &self.mir_body; - let mut span_viewables = Vec::new(); - for coverage_span in coverage_spans { - let bcb = self.bcb_from_coverage_span(coverage_span); - let CoverageSpan { span, bcb_leader_bb: bb, coverage_statements, .. } = coverage_span; - let id = bcb.id(); - let mut sorted_coverage_statements = coverage_statements.clone(); - sorted_coverage_statements.sort_unstable_by_key(|covstmt| match *covstmt { - CoverageStatement::Statement(bb, _, index) => (bb, index), - CoverageStatement::Terminator(bb, _) => (bb, usize::MAX), - }); - let tooltip = sorted_coverage_statements - .iter() - .map(|covstmt| covstmt.format(tcx, mir_body)) - .collect::>() - .join("\n"); - span_viewables.push(SpanViewable { bb: *bb, span: *span, id, tooltip }); - } - span_viewables - } - - #[inline(always)] - fn bcb_from_coverage_span(&self, coverage_span: &CoverageSpan) -> &BasicCoverageBlock { - &self.basic_coverage_blocks()[coverage_span.bcb_leader_bb] - } - - #[inline(always)] - fn body_span(&self) -> Span { - self.hir_body.value.span - } - - // Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of - // the `BasicBlock`(s) in the given `BasicCoverageBlock`. One `CoverageSpan` is generated for - // each `Statement` and `Terminator`. (Note that subsequent stages of coverage analysis will - // merge some `CoverageSpan`s, at which point a `CoverageSpan` may represent multiple - // `Statement`s and/or `Terminator`s.) - fn extract_spans(&self, bcb: &'a BasicCoverageBlock) -> Vec { - let body_span = self.body_span(); - let mir_basic_blocks = self.mir_body.basic_blocks(); - bcb.blocks - .iter() - .map(|bbref| { - let bb = *bbref; - let data = &mir_basic_blocks[bb]; - data.statements - .iter() - .enumerate() - .filter_map(move |(index, statement)| { - filtered_statement_span(statement, body_span).map(|span| { - CoverageSpan::for_statement(statement, span, bcb, bb, index) - }) - }) - .chain( - filtered_terminator_span(data.terminator(), body_span) - .map(|span| CoverageSpan::for_terminator(span, bcb, bb)), - ) - }) - .flatten() - .collect() + coverage_spans.to_refined_spans() } /// Generate a minimal set of `CoverageSpan`s, each representing a contiguous code region to be @@ -732,11 +869,10 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { /// /// Note the resulting vector of `CoverageSpan`s does may not be fully sorted (and does not need /// to be). - fn coverage_spans(&self) -> Vec { - let mut initial_spans = - Vec::::with_capacity(self.mir_body.basic_blocks().len() * 2); - for bcb in self.basic_coverage_blocks().iter() { - for coverage_span in self.extract_spans(bcb) { + fn mir_to_initial_sorted_coverage_spans(&self) -> Vec { + let mut initial_spans = Vec::::with_capacity(self.mir_body.num_nodes() * 2); + for bcb in self.basic_coverage_blocks.iter() { + for coverage_span in self.bcb_to_initial_coverage_spans(bcb) { initial_spans.push(coverage_span); } } @@ -757,14 +893,14 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { // dominators always come after the dominated equal spans). When later // comparing two spans in order, the first will either dominate the second, // or they will have no dominator relationship. - self.dominators().rank_partial_cmp(b.bcb_leader_bb, a.bcb_leader_bb) + self.dominators.rank_partial_cmp(b.bcb_leader_bb, a.bcb_leader_bb) } } else { // Sort hi() in reverse order so shorter spans are attempted after longer spans. - // This guarantees that, if a `prev` span overlaps, and is not equal to, a `curr` - // span, the prev span either extends further left of the curr span, or they - // start at the same position and the prev span extends further right of the end - // of the curr span. + // This guarantees that, if a `prev` span overlaps, and is not equal to, a + // `curr` span, the prev span either extends further left of the curr span, or + // they start at the same position and the prev span extends further right of + // the end of the curr span. b.span.hi().partial_cmp(&a.span.hi()) } } else { @@ -773,41 +909,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { .unwrap() }); - let refinery = CoverageSpanRefinery::from_sorted_spans(initial_spans, self.dominators()); - refinery.to_refined_spans() - } -} - -struct CoverageSpanRefinery<'a> { - sorted_spans_iter: std::vec::IntoIter, - dominators: &'a Dominators, - some_curr: Option, - curr_original_span: Span, - some_prev: Option, - prev_original_span: Span, - pending_dups: Vec, - refined_spans: Vec, -} - -impl<'a> CoverageSpanRefinery<'a> { - fn from_sorted_spans( - sorted_spans: Vec, - dominators: &'a Dominators, - ) -> Self { - let refined_spans = Vec::with_capacity(sorted_spans.len()); - let mut sorted_spans_iter = sorted_spans.into_iter(); - let prev = sorted_spans_iter.next().expect("at least one span"); - let prev_original_span = prev.span; - Self { - sorted_spans_iter, - dominators, - refined_spans, - some_curr: None, - curr_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)), - some_prev: Some(prev), - prev_original_span, - pending_dups: Vec::new(), - } + initial_spans } /// Iterate through the sorted `CoverageSpan`s, and return the refined list of merged and @@ -826,7 +928,7 @@ impl<'a> CoverageSpanRefinery<'a> { self.prev() ); let prev = self.take_prev(); - self.add_refined_span(prev); + self.refined_spans.push(prev); } else if self.prev().is_closure { // drop any equal or overlapping span (`curr`) and keep `prev` to test again in the // next iter @@ -839,38 +941,72 @@ impl<'a> CoverageSpanRefinery<'a> { } else if self.curr().is_closure { self.carve_out_span_for_closure(); } else if self.prev_original_span == self.curr().span { + // Note that this compares the new span to `prev_original_span`, which may not + // be the full `prev.span` (if merged during the previous iteration). self.hold_pending_dups_unless_dominated(); } else { self.cutoff_prev_at_overlapping_curr(); } } + debug!(" AT END, adding last prev={:?}", self.prev()); - let pending_dups = self.pending_dups.split_off(0); - for dup in pending_dups.into_iter() { - debug!(" ...adding at least one pending dup={:?}", dup); - self.add_refined_span(dup); - } let prev = self.take_prev(); - self.add_refined_span(prev); + let CoverageSpans { + mir_body, basic_coverage_blocks, pending_dups, mut refined_spans, .. + } = self; + for dup in pending_dups { + debug!(" ...adding at least one pending dup={:?}", dup); + refined_spans.push(dup); + } + refined_spans.push(prev); - // FIXME(richkadel): Replace some counters with expressions if they can be calculated based - // on branching. (For example, one branch of a SwitchInt can be computed from the counter - // for the CoverageSpan just prior to the SwitchInt minus the sum of the counters of all - // other branches). + // Remove `CoverageSpan`s with empty spans ONLY if the empty `CoverageSpan`s BCB also has at + // least one other non-empty `CoverageSpan`. + let mut has_coverage = BitSet::new_empty(basic_coverage_blocks.num_nodes()); + for covspan in &refined_spans { + if !covspan.span.is_empty() { + has_coverage.insert(covspan.bcb_leader_bb); + } + } + refined_spans.retain(|covspan| { + !(covspan.span.is_empty() + && is_goto(&mir_body[covspan.bcb_leader_bb].terminator().kind) + && has_coverage.contains(covspan.bcb_leader_bb)) + }); - self.to_refined_spans_without_closures() + // Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage + // regions for the current function leave room for the closure's own coverage regions + // (injected separately, from the closure's own MIR). + refined_spans.retain(|covspan| !covspan.is_closure); + refined_spans } - fn add_refined_span(&mut self, coverage_span: CoverageSpan) { - self.refined_spans.push(coverage_span); - } - - /// Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage - /// regions for the current function leave room for the closure's own coverage regions - /// (injected separately, from the closure's own MIR). - fn to_refined_spans_without_closures(mut self) -> Vec { - self.refined_spans.retain(|covspan| !covspan.is_closure); - self.refined_spans + // Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of + // the `BasicBlock`(s) in the given `BasicCoverageBlock`. One `CoverageSpan` is generated + // for each `Statement` and `Terminator`. (Note that subsequent stages of coverage analysis will + // merge some `CoverageSpan`s, at which point a `CoverageSpan` may represent multiple + // `Statement`s and/or `Terminator`s.) + fn bcb_to_initial_coverage_spans(&self, bcb: &BasicCoverageBlock) -> Vec { + bcb.blocks + .iter() + .map(|bbref| { + let bb = *bbref; + let data = &self.mir_body[bb]; + data.statements + .iter() + .enumerate() + .filter_map(move |(index, statement)| { + filtered_statement_span(statement, self.body_span).map(|span| { + CoverageSpan::for_statement(statement, span, bcb, bb, index) + }) + }) + .chain( + filtered_terminator_span(data.terminator(), self.body_span) + .map(|span| CoverageSpan::for_terminator(span, bcb, bb)), + ) + }) + .flatten() + .collect() } fn curr(&self) -> &CoverageSpan { @@ -904,9 +1040,10 @@ impl<'a> CoverageSpanRefinery<'a> { /// If there are `pending_dups` but `prev` is not a matching dup (`prev.span` doesn't match the /// `pending_dups` spans), then one of the following two things happened during the previous /// iteration: - /// * the `span` of prev was modified (by `curr_mut().merge_from(prev)`); or - /// * the `span` of prev advanced past the end of the span of pending_dups - /// (`prev().span.hi() <= curr().span.lo()`) + /// * the previous `curr` span (which is now `prev`) was not a duplicate of the pending_dups + /// (in which case there should be at least two spans in `pending_dups`); or + /// * the `span` of `prev` was modified by `curr_mut().merge_from(prev)` (in which case + /// `pending_dups` could have as few as one span) /// In either case, no more spans will match the span of `pending_dups`, so /// add the `pending_dups` if they don't overlap `curr`, and clear the list. fn check_pending_dups(&mut self) { @@ -920,7 +1057,7 @@ impl<'a> CoverageSpanRefinery<'a> { let pending_dups = self.pending_dups.split_off(0); for dup in pending_dups.into_iter() { debug!(" ...adding at least one pending={:?}", dup); - self.add_refined_span(dup); + self.refined_spans.push(dup); } } else { self.pending_dups.clear(); @@ -935,7 +1072,7 @@ impl<'a> CoverageSpanRefinery<'a> { self.some_prev = Some(curr); self.prev_original_span = self.curr_original_span; } - while let Some(curr) = self.sorted_spans_iter.next() { + while let Some(curr) = self.sorted_spans_iter.as_mut().unwrap().next() { debug!("FOR curr={:?}", curr); if self.prev_starts_after_next(&curr) { debug!( @@ -994,10 +1131,10 @@ impl<'a> CoverageSpanRefinery<'a> { for mut dup in pending_dups.iter().cloned() { dup.span = dup.span.with_hi(left_cutoff); debug!(" ...and at least one pre_closure dup={:?}", dup); - self.add_refined_span(dup); + self.refined_spans.push(dup); } } - self.add_refined_span(pre_closure); + self.refined_spans.push(pre_closure); } if has_post_closure_span { // Update prev.span to start after the closure (and discard curr) @@ -1013,33 +1150,56 @@ impl<'a> CoverageSpanRefinery<'a> { } } + /// Called if `curr.span` equals `prev_original_span` (and potentially equal to all + /// `pending_dups` spans, if any); but keep in mind, `prev.span` may start at a `Span.lo()` that + /// is less than (further left of) `prev_original_span.lo()`. + /// /// When two `CoverageSpan`s have the same `Span`, dominated spans can be discarded; but if /// neither `CoverageSpan` dominates the other, both (or possibly more than two) are held, /// until their disposition is determined. In this latter case, the `prev` dup is moved into /// `pending_dups` so the new `curr` dup can be moved to `prev` for the next iteration. fn hold_pending_dups_unless_dominated(&mut self) { - // equal coverage spans are ordered by dominators before dominated (if any) - debug_assert!(!self.prev().is_dominated_by(self.curr(), self.dominators)); + // Equal coverage spans are ordered by dominators before dominated (if any), so it should be + // impossible for `curr` to dominate any previous `CoverageSpan`. + debug_assert!(!self.span_bcb_is_dominated_by(self.prev(), self.curr())); - if self.curr().is_dominated_by(&self.prev(), self.dominators) { - // If one span dominates the other, assocate the span with the dominator only. - // - // For example: - // match somenum { - // x if x < 1 => { ... } - // }... - // The span for the first `x` is referenced by both the pattern block (every - // time it is evaluated) and the arm code (only when matched). The counter - // will be applied only to the dominator block. - // - // The dominator's (`prev`) execution count may be higher than the dominated - // block's execution count, so drop `curr`. + let initial_pending_count = self.pending_dups.len(); + if initial_pending_count > 0 { + let mut pending_dups = self.pending_dups.split_off(0); + pending_dups.retain(|dup| !self.span_bcb_is_dominated_by(self.curr(), dup)); + self.pending_dups.append(&mut pending_dups); + if self.pending_dups.len() < initial_pending_count { + debug!( + " discarded {} of {} pending_dups that dominated curr", + initial_pending_count - self.pending_dups.len(), + initial_pending_count + ); + } + } + + if self.span_bcb_is_dominated_by(self.curr(), self.prev()) { debug!( - " different bcbs but SAME spans, and prev dominates curr. Drop curr and \ - keep prev for next iter. prev={:?}", + " different bcbs but SAME spans, and prev dominates curr. Discard prev={:?}", self.prev() ); - self.discard_curr(); + self.cutoff_prev_at_overlapping_curr(); + // If one span dominates the other, assocate the span with the code from the dominated + // block only (`curr`), and discard the overlapping portion of the `prev` span. (Note + // that if `prev.span` is wider than `prev_original_span`, a `CoverageSpan` will still + // be created for `prev`s block, for the non-overlapping portion, left of `curr.span`.) + // + // For example: + // match somenum { + // x if x < 1 => { ... } + // }... + // + // The span for the first `x` is referenced by both the pattern block (every time it is + // evaluated) and the arm code (only when matched). The counter will be applied only to + // the dominated block. This allows coverage to track and highlight things like the + // assignment of `x` above, if the branch is matched, making `x` available to the arm + // code; and to track and highlight the question mark `?` "try" operator at the end of + // a function call returning a `Result`, so the `?` is covered when the function returns + // an `Err`, and not counted as covered if the function always returns `Ok`. } else { // Save `prev` in `pending_dups`. (`curr` will become `prev` in the next iteration.) // If the `curr` CoverageSpan is later discarded, `pending_dups` can be discarded as @@ -1064,7 +1224,7 @@ impl<'a> CoverageSpanRefinery<'a> { fn cutoff_prev_at_overlapping_curr(&mut self) { debug!( " different bcbs, overlapping spans, so ignore/drop pending and only add prev \ - if it has statements that end before curr={:?}", + if it has statements that end before curr; prev={:?}", self.prev() ); if self.pending_dups.is_empty() { @@ -1075,13 +1235,17 @@ impl<'a> CoverageSpanRefinery<'a> { } else { debug!(" ... adding modified prev={:?}", self.prev()); let prev = self.take_prev(); - self.add_refined_span(prev); + self.refined_spans.push(prev); } } else { // with `pending_dups`, `prev` cannot have any statements that don't overlap self.pending_dups.clear(); } } + + fn span_bcb_is_dominated_by(&self, covspan: &CoverageSpan, dom_covspan: &CoverageSpan) -> bool { + self.dominators.is_dominated_by(covspan.bcb_leader_bb, dom_covspan.bcb_leader_bb) + } } fn filtered_statement_span(statement: &'a Statement<'tcx>, body_span: Span) -> Option { @@ -1126,7 +1290,7 @@ fn filtered_statement_span(statement: &'a Statement<'tcx>, body_span: Span) -> O | StatementKind::LlvmInlineAsm(_) | StatementKind::Retag(_, _) | StatementKind::AscribeUserType(_, _) => { - Some(source_info_span(&statement.source_info, body_span)) + Some(function_source_span(statement.source_info.span, body_span)) } } } @@ -1138,15 +1302,43 @@ fn filtered_terminator_span(terminator: &'a Terminator<'tcx>, body_span: Span) - // an `if condition { block }` has a span that includes the executed block, if true, // but for coverage, the code region executed, up to *and* through the SwitchInt, // actually stops before the if's block.) - TerminatorKind::Unreachable // Unreachable blocks are not connected to the CFG + TerminatorKind::Unreachable // Unreachable blocks are not connected to the MIR CFG | TerminatorKind::Assert { .. } | TerminatorKind::Drop { .. } | TerminatorKind::DropAndReplace { .. } | TerminatorKind::SwitchInt { .. } - | TerminatorKind::Goto { .. } // For `FalseEdge`, only the `real` branch is taken, so it is similar to a `Goto`. + // FIXME(richkadel): Note that `Goto` was moved to it's own match arm, for the reasons + // described below. Add tests to confirm whether or not similar cases also apply to + // `FalseEdge`. | TerminatorKind::FalseEdge { .. } => None, + // FIXME(richkadel): Note that `Goto` was initially filtered out (by returning `None`, as + // with the `TerminatorKind`s above) because its `Span` was way to broad to be beneficial, + // and, at the time, `Goto` didn't seem to provide any additional contributions to the + // coverage analysis. Upon further review, `Goto` terminated blocks do appear to benefit + // the coverage analysis, and the BCB CFG. To overcome the issues with the `Spans`, the + // coverage algorithms--and the final coverage map generation--include some exceptional + // behaviors. + // + // `Goto`s are often the targets of `SwitchInt` branches, and certain important + // optimizations to replace some `Counter`s with `Expression`s require a separate + // `BasicCoverageBlock` for each branch, to support the `Counter`, when needed. + // + // Also, some test cases showed that `Goto` terminators, and to some degree their `Span`s, + // provided useful context for coverage, such as to count and show when `if` blocks + // _without_ `else` blocks execute the `false` case (counting when the body of the `if` + // was _not_ taken). In these cases, the `Goto` span is ultimately given a `CoverageSpan` + // of 1 character, at the end of it's original `Span`. + // + // However, in other cases, a visible `CoverageSpan` is not wanted, but the `Goto` + // block must still be counted (for example, to contribute its count to an `Expression` + // that reports the execution count for some other block). In these cases, the code region + // is set to `None`. + TerminatorKind::Goto { .. } => { + Some(function_source_span(terminator.source_info.span.shrink_to_hi(), body_span)) + } + // Retain spans from all other terminators TerminatorKind::Resume | TerminatorKind::Abort @@ -1156,25 +1348,38 @@ fn filtered_terminator_span(terminator: &'a Terminator<'tcx>, body_span: Span) - | TerminatorKind::GeneratorDrop | TerminatorKind::FalseUnwind { .. } | TerminatorKind::InlineAsm { .. } => { - Some(source_info_span(&terminator.source_info, body_span)) + Some(function_source_span(terminator.source_info.span, body_span)) } } } #[inline(always)] -fn source_info_span(source_info: &SourceInfo, body_span: Span) -> Span { - let span = original_sp(source_info.span, body_span).with_ctxt(SyntaxContext::root()); +fn function_source_span(span: Span, body_span: Span) -> Span { + let span = original_sp(span, body_span).with_ctxt(SyntaxContext::root()); if body_span.contains(span) { span } else { body_span } } +#[inline(always)] +fn is_goto(term_kind: &TerminatorKind<'tcx>) -> bool { + match term_kind { + TerminatorKind::Goto { .. } => true, + _ => false, + } +} + /// Convert the Span into its file name, start line and column, and end line and column -fn make_code_region(file_name: Symbol, source_file: &Lrc, span: Span) -> CodeRegion { +fn make_code_region( + file_name: Symbol, + source_file: &Lrc, + span: Span, + body_span: Span, +) -> CodeRegion { let (start_line, mut start_col) = source_file.lookup_file_pos(span.lo()); let (end_line, end_col) = if span.hi() == span.lo() { let (end_line, mut end_col) = (start_line, start_col); // Extend an empty span by one character so the region will be counted. let CharPos(char_pos) = start_col; - if char_pos > 0 { + if span.hi() == body_span.hi() { start_col = CharPos(char_pos - 1); } else { end_col = CharPos(char_pos + 1); diff --git a/compiler/rustc_mir/src/util/graphviz.rs b/compiler/rustc_mir/src/util/graphviz.rs index e04f07774ed..625f1a3e684 100644 --- a/compiler/rustc_mir/src/util/graphviz.rs +++ b/compiler/rustc_mir/src/util/graphviz.rs @@ -62,6 +62,7 @@ where let dark_mode = tcx.sess.opts.debugging_opts.graphviz_dark_mode; if dark_mode { graph_attrs.push(r#"bgcolor="black""#); + graph_attrs.push(r#"fontcolor="white""#); content_attrs.push(r#"color="white""#); content_attrs.push(r#"fontcolor="white""#); } @@ -112,7 +113,8 @@ where // Basic block number at the top. let (blk, bgcolor) = if data.is_cleanup { - (format!("{} (cleanup)", block.index()), "lightblue") + let color = if dark_mode { "royalblue" } else { "lightblue" }; + (format!("{} (cleanup)", block.index()), color) } else { let color = if dark_mode { "dimgray" } else { "gray" }; (format!("{}", block.index()), color) diff --git a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff index 598727e677c..ddc65085e80 100644 --- a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff +++ b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff @@ -26,13 +26,15 @@ } bb3: { -+ Coverage::Counter(2) for /the/src/instrument_coverage.rs:13:13 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10 ++ 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 goto -> bb0; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6 } diff --git a/src/test/mir-opt/instrument_coverage.rs b/src/test/mir-opt/instrument_coverage.rs index d9c8e8d43a4..18863edac97 100644 --- a/src/test/mir-opt/instrument_coverage.rs +++ b/src/test/mir-opt/instrument_coverage.rs @@ -1,10 +1,10 @@ -// Test that the initial version of Rust coverage injects Coverage statements at the top of each -// function. The Coverage Counter statements are later converted into LLVM instrprof.increment -// intrinsics, during codegen. +// Test that `-Z instrument-coverage` injects Coverage statements. The Coverage Counter statements +// are later converted into LLVM instrprof.increment intrinsics, during codegen. // needs-profiler-support // ignore-windows -// compile-flags: -Zinstrument-coverage --remap-path-prefix={{src-base}}=/the/src +// compile-flags: -Z instrument-coverage --remap-path-prefix={{src-base}}=/the/src + // EMIT_MIR instrument_coverage.main.InstrumentCoverage.diff // EMIT_MIR instrument_coverage.bar.InstrumentCoverage.diff fn main() { diff --git a/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt index 0a3c4aedd55..bd2a2475d9e 100644 --- a/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt +++ b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt @@ -34,7 +34,7 @@ CHECK-SAME: section "llvm.metadata" CHECK: [[DEFINE_INTERNAL]] { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} { CHECK-NEXT: start: -CHECK-NOT: bb{{[0-9]+}}: +CHECK-NOT: [[DEFINE_INTERNAL]] CHECK: %pgocount = load i64, i64* getelementptr inbounds CHECK-SAME: * @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called, diff --git a/src/test/run-make-fulldeps/coverage-reports-base/Makefile b/src/test/run-make-fulldeps/coverage-reports-base/Makefile index 880d7fdb1b0..bfecc5fd7f5 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/Makefile +++ b/src/test/run-make-fulldeps/coverage-reports-base/Makefile @@ -21,6 +21,7 @@ clear_expected_if_blessed: ifdef RUSTC_BLESS_TEST rm -f expected_export_coverage.*.json rm -f expected_show_coverage.*.txt + rm -f expected_show_coverage_counters.*.txt endif -include clear_expected_if_blessed @@ -54,14 +55,19 @@ endif # when comparing the JSON `export`, the `show` output may be useful when # debugging. "$(LLVM_BIN_DIR)"/llvm-cov show \ + --debug \ --Xdemangler="$(RUST_DEMANGLER)" \ --show-line-counts-or-regions \ --instr-profile="$(TMPDIR)"/$@.profdata \ $(call BIN,"$(TMPDIR)"/$@) \ - > "$(TMPDIR)"/actual_show_coverage.$@.txt + > "$(TMPDIR)"/actual_show_coverage.$@.txt \ + 2> "$(TMPDIR)"/actual_show_coverage_counters.$@.txt ifdef RUSTC_BLESS_TEST - cp "$(TMPDIR)"/actual_show_coverage.$@.txt expected_show_coverage.$@.txt + cp "$(TMPDIR)"/actual_show_coverage.$@.txt \ + expected_show_coverage.$@.txt + cp "$(TMPDIR)"/actual_show_coverage_counters.$@.txt \ + expected_show_coverage_counters.$@.txt else # Compare the show coverage output (`--bless` refreshes `typical` files) # Note `llvm-cov show` output for some programs can vary, but can be ignored @@ -75,6 +81,14 @@ else false \ ) + $(DIFF) expected_show_coverage_counters.$@.txt "$(TMPDIR)"/actual_show_coverage_counters.$@.txt || \ + ( grep -q '^\/\/ ignore-llvm-cov-show-diffs' $(SOURCEDIR)/$@.rs && \ + >&2 echo 'diff failed, but suppressed with `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs' \ + ) || \ + ( >&2 echo 'diff failed, and not suppressed without `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs'; \ + false \ + ) + endif # Generate a coverage report in JSON, using `llvm-cov export`, and fail if diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json index 8c6edae2803..bff55300b3c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json @@ -17,14 +17,14 @@ }, "lines": { "count": 91, - "covered": 75, - "percent": 82.41758241758241 + "covered": 77, + "percent": 84.61538461538461 }, "regions": { - "count": 21, - "covered": 11, - "notcovered": 10, - "percent": 52.38095238095239 + "count": 25, + "covered": 13, + "notcovered": 12, + "percent": 52 } } } @@ -42,14 +42,14 @@ }, "lines": { "count": 91, - "covered": 75, - "percent": 82.41758241758241 + "covered": 77, + "percent": 84.61538461538461 }, "regions": { - "count": 21, - "covered": 11, - "notcovered": 10, - "percent": 52.38095238095239 + "count": 25, + "covered": 13, + "notcovered": 12, + "percent": 52 } } } 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 bd2e2d56d4a..7a7e4c04f00 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": 5, - "covered": 5, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 5, - "covered": 5, + "count": 6, + "covered": 6, "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 a50f4657e20..1025cd3de80 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": 6, - "covered": 6, + "count": 7, + "covered": 7, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 7, + "covered": 7, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json index 2ff53ad33fa..84dcc251f3f 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json @@ -21,10 +21,10 @@ "percent": 100 }, "regions": { - "count": 4, + "count": 5, "covered": 4, - "notcovered": 0, - "percent": 100 + "notcovered": 1, + "percent": 80 } } } @@ -46,10 +46,10 @@ "percent": 100 }, "regions": { - "count": 4, + "count": 5, "covered": 4, - "notcovered": 0, - "percent": 100 + "notcovered": 1, + "percent": 80 } } } 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 36f81ceae19..2d2ad1dbe3f 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": 28, - "covered": 19, - "percent": 67.85714285714286 + "count": 29, + "covered": 21, + "percent": 72.41379310344827 }, "regions": { - "count": 7, - "covered": 5, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 71.42857142857143 + "percent": 77.77777777777779 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 28, - "covered": 19, - "percent": 67.85714285714286 + "count": 29, + "covered": 21, + "percent": 72.41379310344827 }, "regions": { - "count": 7, - "covered": 5, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 71.42857142857143 + "percent": 77.77777777777779 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json index a24e6a33a33..c178e7f9347 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json @@ -21,10 +21,10 @@ "percent": 100 }, "regions": { - "count": 13, + "count": 15, "covered": 13, - "notcovered": 0, - "percent": 100 + "notcovered": 2, + "percent": 86.66666666666667 } } } @@ -46,10 +46,10 @@ "percent": 100 }, "regions": { - "count": 13, + "count": 15, "covered": 13, - "notcovered": 0, - "percent": 100 + "notcovered": 2, + "percent": 86.66666666666667 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json index 585346dc32a..95a1dcd3b8e 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 21, - "covered": 19, - "percent": 90.47619047619048 + "count": 40, + "covered": 32, + "percent": 80 }, "regions": { - "count": 16, - "covered": 14, - "notcovered": 2, - "percent": 87.5 + "count": 39, + "covered": 28, + "notcovered": 11, + "percent": 71.7948717948718 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 21, - "covered": 19, - "percent": 90.47619047619048 + "count": 40, + "covered": 32, + "percent": 80 }, "regions": { - "count": 16, - "covered": 14, - "notcovered": 2, - "percent": 87.5 + "count": 39, + "covered": 28, + "notcovered": 11, + "percent": 71.7948717948718 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json new file mode 100644 index 00000000000..aec85cd0329 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/loops_and_branches.rs", + "summary": { + "functions": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "instantiations": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "lines": { + "count": 11, + "covered": 11, + "percent": 100 + }, + "regions": { + "count": 10, + "covered": 8, + "notcovered": 2, + "percent": 80 + } + } + } + ], + "totals": { + "functions": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "instantiations": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "lines": { + "count": 11, + "covered": 11, + "percent": 100 + }, + "regions": { + "count": 10, + "covered": 8, + "notcovered": 2, + "percent": 80 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json new file mode 100644 index 00000000000..dbe4f9ca6fd --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/nested_loops.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 21, + "covered": 17, + "percent": 80.95238095238095 + }, + "regions": { + "count": 20, + "covered": 16, + "notcovered": 4, + "percent": 80 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 21, + "covered": 17, + "percent": 80.95238095238095 + }, + "regions": { + "count": 20, + "covered": 16, + "notcovered": 4, + "percent": 80 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json new file mode 100644 index 00000000000..8081fba9e22 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/partial_eq_counter_without_region.rs", + "summary": { + "functions": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "instantiations": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "lines": { + "count": 15, + "covered": 15, + "percent": 100 + }, + "regions": { + "count": 6, + "covered": 6, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "totals": { + "functions": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "instantiations": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "lines": { + "count": 15, + "covered": 15, + "percent": 100 + }, + "regions": { + "count": 6, + "covered": 6, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json index 38bc96898ea..ada6bb062dd 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 18, - "covered": 18, + "count": 19, + "covered": 19, "percent": 100 }, "regions": { - "count": 7, - "covered": 7, - "notcovered": 0, - "percent": 100 + "count": 9, + "covered": 8, + "notcovered": 1, + "percent": 88.88888888888889 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 18, - "covered": 18, + "count": 19, + "covered": 19, "percent": 100 }, "regions": { - "count": 7, - "covered": 7, - "notcovered": 0, - "percent": 100 + "count": 9, + "covered": 8, + "notcovered": 1, + "percent": 88.88888888888889 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json index f9d91d66f1d..63d1ae74c5f 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 26, - "covered": 26, + "count": 24, + "covered": 24, "percent": 100 }, "regions": { - "count": 9, - "covered": 9, - "notcovered": 0, - "percent": 100 + "count": 15, + "covered": 14, + "notcovered": 1, + "percent": 93.33333333333333 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 26, - "covered": 26, + "count": 24, + "covered": 24, "percent": 100 }, "regions": { - "count": 9, - "covered": 9, - "notcovered": 0, - "percent": 100 + "count": 15, + "covered": 14, + "notcovered": 1, + "percent": 93.33333333333333 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json new file mode 100644 index 00000000000..3fa6821cd1d --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/tight_infinite_loop.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "regions": { + "count": 2, + "covered": 2, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "regions": { + "count": 2, + "covered": 2, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} 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 e6ef2c1ab89..e845ee29fa4 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 @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 16, - "covered": 15, - "percent": 93.75 + "count": 20, + "covered": 19, + "percent": 95 }, "regions": { - "count": 13, - "covered": 12, - "notcovered": 1, - "percent": 92.3076923076923 + "count": 20, + "covered": 17, + "notcovered": 3, + "percent": 85 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 16, - "covered": 15, - "percent": 93.75 + "count": 20, + "covered": 19, + "percent": 95 }, "regions": { - "count": 13, - "covered": 12, - "notcovered": 1, - "percent": 92.3076923076923 + "count": 20, + "covered": 17, + "notcovered": 3, + "percent": 85 } } } 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 410821ea335..464bb614ea1 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": 51, + "count": 70, "covered": 19, - "notcovered": 32, - "percent": 37.254901960784316 + "notcovered": 51, + "percent": 27.142857142857142 } } } @@ -46,10 +46,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 51, + "count": 70, "covered": 19, - "notcovered": 32, - "percent": 37.254901960784316 + "notcovered": 51, + "percent": 27.142857142857142 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json new file mode 100644 index 00000000000..27862087ed5 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/while.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 4, + "covered": 3, + "percent": 75 + }, + "regions": { + "count": 5, + "covered": 3, + "notcovered": 2, + "percent": 60 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 4, + "covered": 3, + "percent": 75 + }, + "regions": { + "count": 5, + "covered": 3, + "notcovered": 2, + "percent": 60 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} 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 865b705fa20..555ac745d53 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 @@ -17,14 +17,14 @@ }, "lines": { "count": 18, - "covered": 16, - "percent": 88.88888888888889 + "covered": 15, + "percent": 83.33333333333334 }, "regions": { - "count": 9, - "covered": 7, - "notcovered": 2, - "percent": 77.77777777777779 + "count": 11, + "covered": 8, + "notcovered": 3, + "percent": 72.72727272727273 } } } @@ -42,14 +42,14 @@ }, "lines": { "count": 18, - "covered": 16, - "percent": 88.88888888888889 + "covered": 15, + "percent": 83.33333333333334 }, "regions": { - "count": 9, - "covered": 7, - "notcovered": 2, - "percent": 77.77777777777779 + "count": 11, + "covered": 8, + "notcovered": 3, + "percent": 72.72727272727273 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt index 17054490e9b..aef26a62e25 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt @@ -62,7 +62,7 @@ 62| 1| let mut countdown = 0; 63| 1| if is_false { 64| 0| countdown = 10; - 65| 0| } + 65| 1| } 66| 1| "alt string 3".to_owned() 67| 1| } 68| 1| ) @@ -77,7 +77,7 @@ 77| 1| let mut countdown = 0; 78| 1| if is_false { 79| 0| countdown = 10; - 80| 0| } + 80| 1| } 81| 1| "alt string 4".to_owned() 82| 1| }; 83| 1| println!( 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 72aa020ca16..43592df1059 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| 1|} + 27| 2|} 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 86199d74763..11dc0aa65e2 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| 1|} + 38| 2|} 39| | 40| |// Expected program output: 41| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt index bc2f9b108b2..85e6440ab37 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt @@ -25,5 +25,6 @@ 25| 1| 10 26| 1| ; 27| 1| } + ^0 28| 1|} 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 5f899723e25..64cbc262521 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| | } + 23| 1| } 24| | 25| | if 26| 1| is_true @@ -36,6 +36,6 @@ 36| 0| = 37| 0| 100 38| 0| ; - 39| 0| } + 39| 1| } 40| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt index b13ca83d018..4a51f842a4b 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt @@ -10,6 +10,7 @@ 10| 1| if is_true { 11| 1| countdown = 10; 12| 1| } + ^0 13| | 14| | mod in_mod { 15| | const IN_MOD_CONST: u32 = 1000; @@ -48,6 +49,7 @@ 48| 1| if is_true { 49| 1| in_func(countdown); 50| 1| } + ^0 51| | 52| 1| let mut val = InStruct { 53| 1| in_struct_field: 101, diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt index ded43697515..f01f69f2496 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt @@ -12,12 +12,14 @@ 12| 1| b = 10; 13| 1| c = 100; 14| 1| } + ^0 15| | let 16| 1| somebool 17| | = 18| 1| a < b 19| | || - 20| 0| b < c + 20| 1| b < c + ^0 21| | ; 22| | let 23| 1| somebool @@ -26,19 +28,38 @@ 26| | || 27| 1| b < c 28| | ; - 29| | let - 30| 1| somebool - 31| | = - 32| 1| a < b - 33| | && - 34| 1| b < c - 35| | ; - 36| | let - 37| 1| somebool - 38| | = - 39| 1| b < a - 40| | && - 41| 0| b < c - 42| | ; - 43| 1|} + 29| 1| let somebool = a < b && b < c; + 30| 1| let somebool = b < a && b < c; + ^0 + 31| | + 32| | if + 33| 1| ! + 34| 1| is_true + 35| 0| { + 36| 0| a = 2 + 37| 0| ; + 38| 1| } + 39| | + 40| | if + 41| 1| is_true + 42| 1| { + 43| 1| b = 30 + 44| 1| ; + 45| 1| } + 46| | else + 47| 0| { + 48| 0| c = 400 + 49| 0| ; + 50| 1| } + 51| | + 52| 1| if !is_true { + 53| 0| a = 2; + 54| 1| } + 55| | + 56| 1| if is_true { + 57| 1| b = 30; + 58| 1| } else { + 59| 0| c = 400; + 60| 1| } + 61| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt new file mode 100644 index 00000000000..3a969a6b898 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt @@ -0,0 +1,38 @@ + 1| |#![allow(unused_assignments)] + 2| | + 3| |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the + 4| |// structure of this `fmt` function. + 5| | + 6| |struct DebugTest; + 7| | + 8| |impl std::fmt::Debug for DebugTest { + 9| | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + 10| 1| if true { + 11| 1| if false { + 12| | while true { + 13| | } + 14| 1| } + 15| 1| write!(f, "error")?; + ^0 + 16| | } else { + 17| 1| } + 18| 1| Ok(()) + 19| 1| } + 20| |} + 21| | + 22| 1|fn main() { + 23| 1| let debug_test = DebugTest; + 24| 1| println!("{:?}", debug_test); + 25| 1|} + 26| | + 27| |/* + 28| | + 29| |This is the error message generated, before the issue was fixed: + 30| | + 31| |error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42: + 32| |Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt): + 33| |Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s: + 34| |[bcb6, bcb7, bcb9]" } + 35| | + 36| |*/ + diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt new file mode 100644 index 00000000000..e0545c76f78 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt @@ -0,0 +1,26 @@ + 1| |fn main() { + 2| 1| let is_true = std::env::args().len() == 1; + 3| 1| let mut countdown = 10; + 4| | + 5| 1| 'outer: while countdown > 0 { + 6| 1| let mut a = 100; + 7| 1| let mut b = 100; + 8| 3| for _ in 0..50 { + 9| 3| if a < 30 { + 10| 0| break; + 11| | } + 12| 3| a -= 5; + 13| 3| b -= 5; + 14| 3| if b < 90 { + 15| 1| a -= 10; + 16| 1| if is_true { + 17| 1| break 'outer; + 18| | } else { + 19| 0| a -= 2; + 20| 0| } + 21| 2| } + 22| 3| } + 23| 0| countdown -= 1; + 24| 1| } + 25| 1|} + diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt new file mode 100644 index 00000000000..310bf13a695 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt @@ -0,0 +1,101 @@ + 1| |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the + 2| |// structure of this test. + 3| | + 4| 2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + ^1 ^1 + 5| |pub struct Version { + 6| | major: usize, + 7| 1| minor: usize, + 8| | patch: usize, + 9| |} + 10| | + 11| |impl Version { + 12| | pub fn new(major: usize, minor: usize, patch: usize) -> Self { + 13| 2| Self { + 14| 2| major, + 15| 2| minor, + 16| 2| patch, + 17| 2| } + 18| 2| } + 19| |} + 20| | + 21| 1|fn main() { + 22| 1| let version_3_2_1 = Version::new(3, 2, 1); + 23| 1| let version_3_3_0 = Version::new(3, 3, 0); + 24| 1| + 25| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); + 26| 1|} + 27| | + 28| |/* + 29| | + 30| |This test verifies a bug was fixed that otherwise generated this error: + 31| | + 32| |thread 'rustc' panicked at 'No counters provided the source_hash for function: + 33| | Instance { + 34| | def: Item(WithOptConstParam { + 35| | did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp), + 36| | const_param_did: None + 37| | }), + 38| | substs: [] + 39| | }' + 40| |The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage + 41| |without a code region associated with any `Counter`. Code regions were associated with at least + 42| |one expression, which is allowed, but the `function_source_hash` was only passed to the codegen + 43| |(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the + 44| |`function_source_hash` without a code region, if necessary. + 45| | + 46| |*/ + 47| | + 48| |// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces + 49| |// the following results: + 50| | + 51| |/* + 52| | + 53| |1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17? + 54| | + 55| |2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing + 56| | line count with a different instance? Or was it really only called once? + 57| | + 58| |3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of + 59| | its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a + 60| | problem computing the file position here, for some reason. + 61| | + 62| | + 63| | 16| | + 64| | 17| 2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + 65| | ^1 ^1 + 66| |------------------ + 67| ||Unexecuted instantiation: ::gt + 68| |------------------ + 69| ||Unexecuted instantiation: ::le + 70| |------------------ + 71| ||Unexecuted instantiation: ::ge + 72| |------------------ + 73| ||::lt: + 74| || 17| 1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + 75| |------------------ + 76| | 18| |pub struct Version { + 77| | 19| | major: usize, + 78| | 20| 1| minor: usize, + 79| | 21| | patch: usize, + 80| | 22| |} + 81| | 23| | + 82| | 24| |impl Version { + 83| | 25| | pub fn new(major: usize, minor: usize, patch: usize) -> Self { + 84| | 26| 2| Version { + 85| | 27| 2| major, + 86| | 28| 2| minor, + 87| | 29| 2| patch, + 88| | 30| 2| } + 89| | 31| 2| } + 90| | 32| |} + 91| | 33| | + 92| | 34| 1|fn main() { + 93| | 35| 1| let version_3_2_1 = Version::new(3, 2, 1); + 94| | 36| 1| let version_3_3_0 = Version::new(3, 3, 0); + 95| | 37| 1| + 96| | 38| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version + 97| |_3_3_0); + 98| | 39| 1|} + 99| |*/ + diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt index f1acb7c5459..064930dd75c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt @@ -16,6 +16,7 @@ 16| 1| 10 17| 1| ; 18| 1| } + ^0 19| | 20| | loop 21| | { @@ -31,6 +32,6 @@ 31| 10| -= 32| 10| 1 33| | ; - 34| | } + 34| 1| } 35| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt index e42f22cd047..1f7e71d3eb0 100644 --- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt @@ -10,22 +10,24 @@ 10| 1| if is_true { 11| 1| countdown = 0; 12| 1| } + ^0 13| | - 14| 3| for - 15| 3| _ + 14| | for + 15| 2| _ 16| | in - 17| 1| 0..2 + 17| 3| 0..2 18| | { 19| | let z 20| | ; 21| | match 22| 2| countdown - 23| 2| { - 24| 2| x - 25| 2| if + 23| | { + 24| 1| x + 25| | if 26| 2| x 27| 2| < 28| 2| 1 + ^1 29| | => 30| 1| { 31| 1| z = countdown @@ -39,6 +41,6 @@ 39| | => 40| 1| {} 41| | } - 42| | } + 42| 3| } 43| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt new file mode 100644 index 00000000000..e02eac03a6b --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt @@ -0,0 +1,6 @@ + 1| |fn main() { + 2| 1| if false { + 3| | loop {} + 4| | } + 5| 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 ae288d7d7a0..05d72d0de46 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 @@ -6,22 +6,22 @@ 6| 1| Err(()) 7| | } else { 8| 5| Ok(()) - 9| | } + 9| 1| } 10| 6|} 11| | 12| |fn main() -> Result<(),()> { 13| 1| let mut 14| 1| countdown = 10 15| | ; - 16| 6| for + 16| | for 17| 6| _ 18| | in - 19| 1| 0..10 + 19| 6| 0..10 20| | { 21| 6| countdown 22| 6| -= 1 - 23| | ; - 24| | if + 23| 6| ; + 24| 6| if 25| 6| countdown < 5 26| | { 27| 1| call(/*return_error=*/ true)?; @@ -29,8 +29,9 @@ 29| | else 30| | { 31| 5| call(/*return_error=*/ false)?; - 32| | } - 33| | } + ^0 + 32| 5| } + 33| 6| } 34| 0| Ok(()) - 35| 1|} + 35| 2|} 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 173ff4aa4c4..e0efe75043d 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| 1|} + 67| 2|} diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt new file mode 100644 index 00000000000..194325b6b9e --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt @@ -0,0 +1,6 @@ + 1| |fn main() { + 2| 1| let num = 9; + 3| 1| while num >= 10 { + 4| 0| } + 5| 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 7dce94f25f3..2e0c4022bed 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 @@ -3,7 +3,7 @@ 3| | 4| |fn main() -> Result<(),u8> { 5| 1| let mut countdown = 10; - 6| 7| while + 6| | while 7| 7| countdown 8| 7| > 9| 7| 0 @@ -24,7 +24,7 @@ 24| | else 25| | { 26| 1| Err(1) - 27| | } + 27| 0| } 28| | ; 29| | } 30| 6| countdown @@ -33,7 +33,7 @@ 33| | ; 34| | } 35| 0| Ok(()) - 36| 1|} + 36| 2|} 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 new file mode 100644 index 00000000000..3eb07757c0d --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt @@ -0,0 +1,95 @@ +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/closure.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/closure +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 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) +Counter in file 0 67:14 -> 75:9, (#1 + 0) +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 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 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 +Emitting segments for file: ../coverage/closure.rs +Combined regions: + 3:11 -> 18:13 (count=1) + 20:21 -> 20:38 (count=0) + 21:20 -> 21:28 (count=0) + 21:29 -> 23:18 (count=0) + 23:18 -> 23:19 (count=0) + 24:17 -> 25:14 (count=0) + 25:14 -> 33:9 (count=1) + 35:13 -> 35:30 (count=0) + 36:12 -> 36:20 (count=0) + 36:21 -> 38:10 (count=0) + 38:10 -> 38:11 (count=0) + 39:9 -> 40:6 (count=0) + 40:6 -> 60:13 (count=1) + 62:21 -> 62:38 (count=1) + 63:20 -> 63:28 (count=1) + 63:29 -> 65:18 (count=0) + 65:18 -> 65:19 (count=1) + 66:17 -> 67:14 (count=1) + 67:14 -> 75:9 (count=1) + 77:13 -> 77:30 (count=1) + 78:12 -> 78:20 (count=1) + 78:21 -> 80:10 (count=0) + 80:10 -> 80:11 (count=1) + 81:9 -> 82:6 (count=1) + 82:6 -> 93:2 (count=1) +Segment at 3:11 (count = 1), RegionEntry +Segment at 18:13 (count = 0), Skipped +Segment at 20:21 (count = 0), RegionEntry +Segment at 20:38 (count = 0), Skipped +Segment at 21:20 (count = 0), RegionEntry +Segment at 21:28 (count = 0), Skipped +Segment at 21:29 (count = 0), RegionEntry +Segment at 23:18 (count = 0), RegionEntry +Segment at 23:19 (count = 0), Skipped +Segment at 24:17 (count = 0), RegionEntry +Segment at 25:14 (count = 1), RegionEntry +Segment at 33:9 (count = 0), Skipped +Segment at 35:13 (count = 0), RegionEntry +Segment at 35:30 (count = 0), Skipped +Segment at 36:12 (count = 0), RegionEntry +Segment at 36:20 (count = 0), Skipped +Segment at 36:21 (count = 0), RegionEntry +Segment at 38:10 (count = 0), RegionEntry +Segment at 38:11 (count = 0), Skipped +Segment at 39:9 (count = 0), RegionEntry +Segment at 40:6 (count = 1), RegionEntry +Segment at 60:13 (count = 0), Skipped +Segment at 62:21 (count = 1), RegionEntry +Segment at 62:38 (count = 0), Skipped +Segment at 63:20 (count = 1), RegionEntry +Segment at 63:28 (count = 0), Skipped +Segment at 63:29 (count = 0), RegionEntry +Segment at 65:18 (count = 1), RegionEntry +Segment at 65:19 (count = 0), Skipped +Segment at 66:17 (count = 1), RegionEntry +Segment at 67:14 (count = 1), RegionEntry +Segment at 75:9 (count = 0), Skipped +Segment at 77:13 (count = 1), RegionEntry +Segment at 77:30 (count = 0), Skipped +Segment at 78:12 (count = 1), RegionEntry +Segment at 78:20 (count = 0), Skipped +Segment at 78:21 (count = 0), RegionEntry +Segment at 80:10 (count = 1), RegionEntry +Segment at 80:11 (count = 0), Skipped +Segment at 81:9 (count = 1), RegionEntry +Segment at 82:6 (count = 1), RegionEntry +Segment at 93:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..447c3c89562 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt @@ -0,0 +1,24 @@ +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/drop_trait.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/drop_trait +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) + 15:9 -> 17:42 (count=1) + 19:8 -> 19:12 (count=1) + 20:9 -> 21:22 (count=1) + 27:1 -> 27:2 (count=2) +Segment at 9:24 (count = 2), RegionEntry +Segment at 11:6 (count = 0), Skipped +Segment at 15:9 (count = 1), RegionEntry +Segment at 17:42 (count = 0), Skipped +Segment at 19:8 (count = 1), RegionEntry +Segment at 19:12 (count = 0), Skipped +Segment at 20:9 (count = 1), RegionEntry +Segment at 21:22 (count = 0), Skipped +Segment at 27:1 (count = 2), RegionEntry +Segment at 27:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..5843b917588 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt @@ -0,0 +1,50 @@ +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/generics.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/generics +Counter in file 0 17:24 -> 19:6, #1 +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 +Combined regions: + 10:49 -> 12:6 (count=3) + 17:24 -> 19:6 (count=2) + 23:9 -> 28:28 (count=1) + 30:8 -> 30:12 (count=1) + 31:9 -> 32:22 (count=1) + 38:1 -> 38:2 (count=2) +Segment at 10:49 (count = 3), RegionEntry +Segment at 12:6 (count = 0), Skipped +Segment at 17:24 (count = 2), RegionEntry +Segment at 19:6 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 28:28 (count = 0), Skipped +Segment at 30:8 (count = 1), RegionEntry +Segment at 30:12 (count = 0), Skipped +Segment at 31:9 (count = 1), RegionEntry +Segment at 32:22 (count = 0), Skipped +Segment at 38:1 (count = 2), RegionEntry +Segment at 38:2 (count = 0), Skipped +Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworkdE12set_strengthB2_ +Combined regions: + 10:49 -> 12:6 (count=2) +Segment at 10:49 (count = 2), RegionEntry +Segment at 12:6 (count = 0), Skipped +Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworklE12set_strengthB2_ +Combined regions: + 10:49 -> 12:6 (count=1) +Segment at 10:49 (count = 1), RegionEntry +Segment at 12:6 (count = 0), Skipped +Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworklENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_ +Combined regions: + 17:24 -> 19:6 (count=1) +Segment at 17:24 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped +Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworkdENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_ +Combined regions: + 17:24 -> 19:6 (count=1) +Segment at 17:24 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped 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 new file mode 100644 index 00000000000..2f063de5a39 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt @@ -0,0 +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/if.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if +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 +Emitting segments for file: ../coverage/if.rs +Combined regions: + 8:5 -> 18:10 (count=1) + 21:9 -> 21:16 (count=1) + 22:5 -> 27:6 (count=1) + 27:6 -> 27:7 (count=0) + 28:1 -> 28:2 (count=1) +Segment at 8:5 (count = 1), RegionEntry +Segment at 18:10 (count = 0), Skipped +Segment at 21:9 (count = 1), RegionEntry +Segment at 21:16 (count = 0), Skipped +Segment at 22:5 (count = 1), RegionEntry +Segment at 27:6 (count = 0), RegionEntry +Segment at 27:7 (count = 0), Skipped +Segment at 28:1 (count = 1), RegionEntry +Segment at 28:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..660e85f91f5 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt @@ -0,0 +1,38 @@ +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 23:6 -> 23:7, (#2 + 0) +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 39:6 -> 39:7, (#5 + 0) +Counter in file 0 40:1 -> 40:2, #7 +Emitting segments for file: ../coverage/if_else.rs +Combined regions: + 7:9 -> 11:16 (count=1) + 12:5 -> 17:6 (count=1) + 20:9 -> 22:16 (count=0) + 23:6 -> 23:7 (count=1) + 26:9 -> 26:16 (count=1) + 27:5 -> 32:6 (count=1) + 34:5 -> 39:6 (count=0) + 39:6 -> 39:7 (count=1) + 40:1 -> 40:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 11:16 (count = 0), Skipped +Segment at 12:5 (count = 1), RegionEntry +Segment at 17:6 (count = 0), Skipped +Segment at 20:9 (count = 0), RegionEntry +Segment at 22:16 (count = 0), Skipped +Segment at 23:6 (count = 1), RegionEntry +Segment at 23:7 (count = 0), Skipped +Segment at 26:9 (count = 1), RegionEntry +Segment at 26:16 (count = 0), Skipped +Segment at 27:5 (count = 1), RegionEntry +Segment at 32:6 (count = 0), Skipped +Segment at 34:5 (count = 0), RegionEntry +Segment at 39:6 (count = 1), RegionEntry +Segment at 39:7 (count = 0), Skipped +Segment at 40:1 (count = 1), RegionEntry +Segment at 40:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..fb863c73a63 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt @@ -0,0 +1,61 @@ +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/inner_items.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/inner_items +Counter in file 0 19:13 -> 19:18, #1 +Counter in file 0 20:13 -> 20:14, #2 +Counter in file 0 20:17 -> 20:22, (#1 + 0) +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 33:42 -> 36:10, #1 +Counter in file 0 41:37 -> 41:41, #1 +Counter in file 0 42:13 -> 43:10, #2 +Emitting segments for file: ../coverage/inner_items.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 12:6 (count=1) + 12:6 -> 12:7 (count=0) + 19:13 -> 19:18 (count=3) + 20:13 -> 20:14 (count=3) + 20:17 -> 20:22 (count=3) + 21:9 -> 22:6 (count=3) + 33:42 -> 36:10 (count=1) + 41:37 -> 41:41 (count=1) + 42:13 -> 43:10 (count=1) + 48:8 -> 48:15 (count=1) + 48:16 -> 50:6 (count=1) + 50:6 -> 50:7 (count=0) + 52:9 -> 57:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 12:6 (count = 0), RegionEntry +Segment at 12:7 (count = 0), Skipped +Segment at 19:13 (count = 3), RegionEntry +Segment at 19:18 (count = 0), Skipped +Segment at 20:13 (count = 3), RegionEntry +Segment at 20:14 (count = 0), Skipped +Segment at 20:17 (count = 3), RegionEntry +Segment at 20:22 (count = 0), Skipped +Segment at 21:9 (count = 3), RegionEntry +Segment at 22:6 (count = 0), Skipped +Segment at 33:42 (count = 1), RegionEntry +Segment at 36:10 (count = 0), Skipped +Segment at 41:37 (count = 1), RegionEntry +Segment at 41:41 (count = 0), Skipped +Segment at 42:13 (count = 1), RegionEntry +Segment at 43:10 (count = 0), Skipped +Segment at 48:8 (count = 1), RegionEntry +Segment at 48:15 (count = 0), Skipped +Segment at 48:16 (count = 1), RegionEntry +Segment at 50:6 (count = 0), RegionEntry +Segment at 50:7 (count = 0), Skipped +Segment at 52:9 (count = 1), RegionEntry +Segment at 57:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..dd93c3a9392 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt @@ -0,0 +1,138 @@ +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/lazy_boolean.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/lazy_boolean +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 50:6 -> 50:7, (#24 + 0) +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 60:6 -> 60:7, (#30 + 0) +Counter in file 0 61:1 -> 61:2, #32 +Emitting segments for file: ../coverage/lazy_boolean.rs +Combined regions: + 7:9 -> 9:42 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 14:6 (count=1) + 14:6 -> 14:7 (count=0) + 16:9 -> 16:17 (count=1) + 18:13 -> 18:18 (count=1) + 20:13 -> 20:18 (count=0) + 20:18 -> 20:19 (count=1) + 23:9 -> 23:17 (count=1) + 25:13 -> 25:18 (count=1) + 27:13 -> 27:18 (count=1) + 27:18 -> 27:19 (count=1) + 29:9 -> 29:17 (count=1) + 29:20 -> 29:25 (count=1) + 29:29 -> 29:34 (count=1) + 29:34 -> 29:35 (count=1) + 30:9 -> 30:17 (count=1) + 30:20 -> 30:25 (count=1) + 30:29 -> 30:34 (count=0) + 30:34 -> 30:35 (count=1) + 33:9 -> 34:16 (count=1) + 35:5 -> 38:6 (count=0) + 38:6 -> 38:7 (count=1) + 41:9 -> 41:16 (count=1) + 42:5 -> 45:6 (count=1) + 47:5 -> 50:6 (count=0) + 50:6 -> 50:7 (count=1) + 52:8 -> 52:16 (count=1) + 52:17 -> 54:6 (count=0) + 54:6 -> 54:7 (count=1) + 56:8 -> 56:15 (count=1) + 56:16 -> 58:6 (count=1) + 58:12 -> 60:6 (count=0) + 60:6 -> 60:7 (count=1) + 61:1 -> 61:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:42 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 14:6 (count = 0), RegionEntry +Segment at 14:7 (count = 0), Skipped +Segment at 16:9 (count = 1), RegionEntry +Segment at 16:17 (count = 0), Skipped +Segment at 18:13 (count = 1), RegionEntry +Segment at 18:18 (count = 0), Skipped +Segment at 20:13 (count = 0), RegionEntry +Segment at 20:18 (count = 1), RegionEntry +Segment at 20:19 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 23:17 (count = 0), Skipped +Segment at 25:13 (count = 1), RegionEntry +Segment at 25:18 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:18 (count = 1), RegionEntry +Segment at 27:19 (count = 0), Skipped +Segment at 29:9 (count = 1), RegionEntry +Segment at 29:17 (count = 0), Skipped +Segment at 29:20 (count = 1), RegionEntry +Segment at 29:25 (count = 0), Skipped +Segment at 29:29 (count = 1), RegionEntry +Segment at 29:34 (count = 1), RegionEntry +Segment at 29:35 (count = 0), Skipped +Segment at 30:9 (count = 1), RegionEntry +Segment at 30:17 (count = 0), Skipped +Segment at 30:20 (count = 1), RegionEntry +Segment at 30:25 (count = 0), Skipped +Segment at 30:29 (count = 0), RegionEntry +Segment at 30:34 (count = 1), RegionEntry +Segment at 30:35 (count = 0), Skipped +Segment at 33:9 (count = 1), RegionEntry +Segment at 34:16 (count = 0), Skipped +Segment at 35:5 (count = 0), RegionEntry +Segment at 38:6 (count = 1), RegionEntry +Segment at 38:7 (count = 0), Skipped +Segment at 41:9 (count = 1), RegionEntry +Segment at 41:16 (count = 0), Skipped +Segment at 42:5 (count = 1), RegionEntry +Segment at 45:6 (count = 0), Skipped +Segment at 47:5 (count = 0), RegionEntry +Segment at 50:6 (count = 1), RegionEntry +Segment at 50:7 (count = 0), Skipped +Segment at 52:8 (count = 1), RegionEntry +Segment at 52:16 (count = 0), Skipped +Segment at 52:17 (count = 0), RegionEntry +Segment at 54:6 (count = 1), RegionEntry +Segment at 54:7 (count = 0), Skipped +Segment at 56:8 (count = 1), RegionEntry +Segment at 56:15 (count = 0), Skipped +Segment at 56:16 (count = 1), RegionEntry +Segment at 58:6 (count = 0), Skipped +Segment at 58:12 (count = 0), RegionEntry +Segment at 60:6 (count = 1), RegionEntry +Segment at 60:7 (count = 0), Skipped +Segment at 61:1 (count = 1), RegionEntry +Segment at 61:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt new file mode 100644 index 00000000000..df16c54617c --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt @@ -0,0 +1,7 @@ +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/loop_break_value.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loop_break_value +Counter in file 0 3:11 -> 13:2, #1 +Emitting segments for file: ../coverage/loop_break_value.rs +Combined regions: + 3:11 -> 13:2 (count=1) +Segment at 3:11 (count = 1), RegionEntry +Segment at 13:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..d6e4403268a --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt @@ -0,0 +1,39 @@ +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 19:5 -> 19:6, (#8 + 0) +Counter in file 0 22:11 -> 25:2, #1 +Emitting segments for file: ../coverage/loops_and_branches.rs +Combined regions: + 10:12 -> 10:16 (count=1) + 11:16 -> 11:21 (count=1) + 14:14 -> 14:15 (count=1) + 15:13 -> 15:31 (count=1) + 15:31 -> 15:32 (count=0) + 17:10 -> 17:11 (count=1) + 18:9 -> 18:15 (count=1) + 19:5 -> 19:6 (count=1) + 22:11 -> 25:2 (count=1) +Segment at 10:12 (count = 1), RegionEntry +Segment at 10:16 (count = 0), Skipped +Segment at 11:16 (count = 1), RegionEntry +Segment at 11:21 (count = 0), Skipped +Segment at 14:14 (count = 1), RegionEntry +Segment at 14:15 (count = 0), Skipped +Segment at 15:13 (count = 1), RegionEntry +Segment at 15:31 (count = 0), RegionEntry +Segment at 15:32 (count = 0), Skipped +Segment at 17:10 (count = 1), RegionEntry +Segment at 17:11 (count = 0), Skipped +Segment at 18:9 (count = 1), RegionEntry +Segment at 18:15 (count = 0), Skipped +Segment at 19:5 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped +Segment at 22:11 (count = 1), RegionEntry +Segment at 25:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..eec4aec79e6 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt @@ -0,0 +1,76 @@ +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 22:10 -> 22:11, (#3 + 0) +Counter in file 0 23:9 -> 23:23, #14 +Counter in file 0 24:6 -> 24:7, #15 +Counter in file 0 24:6 -> 24:7, (#1 + 0) +Counter in file 0 25:1 -> 25:2, #16 +Emitting segments for file: ../coverage/nested_loops.rs +Combined regions: + 2:9 -> 3:27 (count=1) + 5:19 -> 5:32 (count=1) + 6:13 -> 7:24 (count=1) + 8:13 -> 8:14 (count=3) + 8:18 -> 8:23 (count=3) + 9:16 -> 9:22 (count=3) + 10:17 -> 10:22 (count=0) + 12:13 -> 12:19 (count=3) + 13:13 -> 13:19 (count=3) + 14:16 -> 14:22 (count=3) + 15:17 -> 16:27 (count=1) + 17:21 -> 17:33 (count=1) + 19:21 -> 21:14 (count=0) + 21:14 -> 21:15 (count=2) + 22:10 -> 22:11 (count=3) + 23:9 -> 23:23 (count=0) + 24:6 -> 24:7 (count=1) + 25:1 -> 25:2 (count=1) +Segment at 2:9 (count = 1), RegionEntry +Segment at 3:27 (count = 0), Skipped +Segment at 5:19 (count = 1), RegionEntry +Segment at 5:32 (count = 0), Skipped +Segment at 6:13 (count = 1), RegionEntry +Segment at 7:24 (count = 0), Skipped +Segment at 8:13 (count = 3), RegionEntry +Segment at 8:14 (count = 0), Skipped +Segment at 8:18 (count = 3), RegionEntry +Segment at 8:23 (count = 0), Skipped +Segment at 9:16 (count = 3), RegionEntry +Segment at 9:22 (count = 0), Skipped +Segment at 10:17 (count = 0), RegionEntry +Segment at 10:22 (count = 0), Skipped +Segment at 12:13 (count = 3), RegionEntry +Segment at 12:19 (count = 0), Skipped +Segment at 13:13 (count = 3), RegionEntry +Segment at 13:19 (count = 0), Skipped +Segment at 14:16 (count = 3), RegionEntry +Segment at 14:22 (count = 0), Skipped +Segment at 15:17 (count = 1), RegionEntry +Segment at 16:27 (count = 0), Skipped +Segment at 17:21 (count = 1), RegionEntry +Segment at 17:33 (count = 0), Skipped +Segment at 19:21 (count = 0), RegionEntry +Segment at 21:14 (count = 2), RegionEntry +Segment at 21:15 (count = 0), Skipped +Segment at 22:10 (count = 3), RegionEntry +Segment at 22:11 (count = 0), Skipped +Segment at 23:9 (count = 0), RegionEntry +Segment at 23:23 (count = 0), Skipped +Segment at 24:6 (count = 1), RegionEntry +Segment at 24:7 (count = 0), Skipped +Segment at 25:1 (count = 1), RegionEntry +Segment at 25:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt new file mode 100644 index 00000000000..d2a68ab3202 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt @@ -0,0 +1,28 @@ +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/partial_eq_counter_without_region.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/partial_eq_counter_without_region +Counter in file 0 7:5 -> 7:6, #1 +Counter in file 0 21:11 -> 26:2, #1 +Counter in file 0 4:17 -> 4:22, #1 +Counter in file 0 13:9 -> 18:6, #1 +Counter in file 0 4:39 -> 4:40, #1 +Counter in file 0 4:48 -> 4:49, (#1 + 0) +Counter in file 0 8:5 -> 8:17, #1 +Emitting segments for file: ../coverage/partial_eq_counter_without_region.rs +Combined regions: + 4:17 -> 4:22 (count=2) + 4:39 -> 4:40 (count=1) + 4:48 -> 4:49 (count=1) + 7:5 -> 7:6 (count=1) + 13:9 -> 18:6 (count=2) + 21:11 -> 26:2 (count=1) +Segment at 4:17 (count = 2), RegionEntry +Segment at 4:22 (count = 0), Skipped +Segment at 4:39 (count = 1), RegionEntry +Segment at 4:40 (count = 0), Skipped +Segment at 4:48 (count = 1), RegionEntry +Segment at 4:49 (count = 0), Skipped +Segment at 7:5 (count = 1), RegionEntry +Segment at 7:6 (count = 0), Skipped +Segment at 13:9 (count = 2), RegionEntry +Segment at 18:6 (count = 0), Skipped +Segment at 21:11 (count = 1), RegionEntry +Segment at 26:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..d828e40ca3f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt @@ -0,0 +1,38 @@ +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/simple_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_loop +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) +Emitting segments for file: ../coverage/simple_loop.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 12:9 -> 12:16 (count=1) + 13:5 -> 18:6 (count=1) + 18:6 -> 18:7 (count=0) + 23:13 -> 25:14 (count=11) + 27:13 -> 27:18 (count=1) + 30:9 -> 32:10 (count=10) + 34:6 -> 34:7 (count=1) + 35:1 -> 35:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 12:9 (count = 1), RegionEntry +Segment at 12:16 (count = 0), Skipped +Segment at 13:5 (count = 1), RegionEntry +Segment at 18:6 (count = 0), RegionEntry +Segment at 18:7 (count = 0), Skipped +Segment at 23:13 (count = 11), RegionEntry +Segment at 25:14 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:18 (count = 0), Skipped +Segment at 30:9 (count = 10), RegionEntry +Segment at 32:10 (count = 0), Skipped +Segment at 34:6 (count = 1), RegionEntry +Segment at 34:7 (count = 0), Skipped +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.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt new file mode 100644 index 00000000000..e7932e0be04 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt @@ -0,0 +1,58 @@ +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/simple_match.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_match +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 +Emitting segments for file: ../coverage/simple_match.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 12:6 (count=1) + 12:6 -> 12:7 (count=0) + 15:9 -> 15:10 (count=2) + 17:9 -> 17:13 (count=3) + 22:13 -> 22:22 (count=2) + 24:13 -> 24:14 (count=1) + 26:17 -> 28:18 (count=2) + 28:18 -> 28:19 (count=1) + 30:13 -> 37:14 (count=1) + 40:13 -> 40:15 (count=1) + 42:6 -> 42:7 (count=3) + 43:1 -> 43:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 12:6 (count = 0), RegionEntry +Segment at 12:7 (count = 0), Skipped +Segment at 15:9 (count = 2), RegionEntry +Segment at 15:10 (count = 0), Skipped +Segment at 17:9 (count = 3), RegionEntry +Segment at 17:13 (count = 0), Skipped +Segment at 22:13 (count = 2), RegionEntry +Segment at 22:22 (count = 0), Skipped +Segment at 24:13 (count = 1), RegionEntry +Segment at 24:14 (count = 0), Skipped +Segment at 26:17 (count = 2), RegionEntry +Segment at 28:18 (count = 1), RegionEntry +Segment at 28:19 (count = 0), Skipped +Segment at 30:13 (count = 1), RegionEntry +Segment at 37:14 (count = 0), Skipped +Segment at 40:13 (count = 1), RegionEntry +Segment at 40:15 (count = 0), Skipped +Segment at 42:6 (count = 3), RegionEntry +Segment at 42:7 (count = 0), Skipped +Segment at 43:1 (count = 1), RegionEntry +Segment at 43:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..a690874e3c0 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt @@ -0,0 +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/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 +Emitting segments for file: ../coverage/tight_infinite_loop.rs +Combined regions: + 2:8 -> 2:13 (count=1) + 5:1 -> 5:2 (count=1) +Segment at 2:8 (count = 1), RegionEntry +Segment at 2:13 (count = 0), Skipped +Segment at 5:1 (count = 1), RegionEntry +Segment at 5:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..d510223417a --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt @@ -0,0 +1,72 @@ +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 33:6 -> 33:7, (#1 + 0) +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 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 9:6 -> 9:7, (#2 + 0) +Counter in file 0 10:1 -> 10:2, #4 +Emitting segments for file: ../coverage/try_error_result.rs +Combined regions: + 5:8 -> 5:20 (count=6) + 6:9 -> 6:16 (count=1) + 8:9 -> 8:15 (count=5) + 9:6 -> 9:7 (count=1) + 10:1 -> 10:2 (count=6) + 13:9 -> 14:23 (count=1) + 17:9 -> 17:10 (count=6) + 19:9 -> 19:14 (count=6) + 21:9 -> 25:26 (count=6) + 27:13 -> 27:41 (count=1) + 27:41 -> 27:42 (count=1) + 31:13 -> 31:42 (count=5) + 31:42 -> 31:43 (count=0) + 32:10 -> 32:11 (count=5) + 33:6 -> 33:7 (count=6) + 34:5 -> 34:11 (count=0) + 35:1 -> 35:2 (count=2) +Segment at 5:8 (count = 6), RegionEntry +Segment at 5:20 (count = 0), Skipped +Segment at 6:9 (count = 1), RegionEntry +Segment at 6:16 (count = 0), Skipped +Segment at 8:9 (count = 5), RegionEntry +Segment at 8:15 (count = 0), Skipped +Segment at 9:6 (count = 1), RegionEntry +Segment at 9:7 (count = 0), Skipped +Segment at 10:1 (count = 6), RegionEntry +Segment at 10:2 (count = 0), Skipped +Segment at 13:9 (count = 1), RegionEntry +Segment at 14:23 (count = 0), Skipped +Segment at 17:9 (count = 6), RegionEntry +Segment at 17:10 (count = 0), Skipped +Segment at 19:9 (count = 6), RegionEntry +Segment at 19:14 (count = 0), Skipped +Segment at 21:9 (count = 6), RegionEntry +Segment at 25:26 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:41 (count = 1), RegionEntry +Segment at 27:42 (count = 0), Skipped +Segment at 31:13 (count = 5), RegionEntry +Segment at 31:42 (count = 0), RegionEntry +Segment at 31:43 (count = 0), Skipped +Segment at 32:10 (count = 5), RegionEntry +Segment at 32:11 (count = 0), Skipped +Segment at 33:6 (count = 6), 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: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 new file mode 100644 index 00000000000..0fb135b2cc9 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt @@ -0,0 +1,240 @@ +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/various_conditions.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/various_conditions +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 +Emitting segments for file: ../coverage/various_conditions.rs +Combined regions: + 4:9 -> 4:26 (count=1) + 5:8 -> 5:12 (count=1) + 5:13 -> 7:6 (count=1) + 10:9 -> 10:10 (count=1) + 10:16 -> 10:29 (count=1) + 11:9 -> 12:10 (count=1) + 13:15 -> 13:28 (count=0) + 14:12 -> 14:25 (count=0) + 14:29 -> 14:42 (count=0) + 14:42 -> 14:43 (count=0) + 14:46 -> 14:60 (count=0) + 14:60 -> 14:61 (count=0) + 14:61 -> 16:10 (count=0) + 16:10 -> 16:11 (count=0) + 17:9 -> 18:18 (count=0) + 20:9 -> 20:15 (count=0) + 23:9 -> 23:26 (count=1) + 24:8 -> 24:12 (count=1) + 24:13 -> 26:6 (count=1) + 28:8 -> 28:21 (count=1) + 29:9 -> 29:23 (count=1) + 30:15 -> 30:28 (count=0) + 31:12 -> 31:25 (count=0) + 31:29 -> 31:42 (count=0) + 31:42 -> 31:43 (count=0) + 31:46 -> 31:60 (count=0) + 31:60 -> 31:61 (count=0) + 31:61 -> 33:10 (count=0) + 33:10 -> 33:11 (count=0) + 34:9 -> 34:23 (count=0) + 36:9 -> 36:15 (count=0) + 39:9 -> 39:26 (count=1) + 40:8 -> 40:12 (count=1) + 40:13 -> 42:6 (count=1) + 44:9 -> 44:10 (count=0) + 44:16 -> 44:29 (count=1) + 45:9 -> 45:23 (count=0) + 46:15 -> 46:28 (count=1) + 47:12 -> 47:25 (count=0) + 47:29 -> 47:42 (count=0) + 47:42 -> 47:43 (count=0) + 47:46 -> 47:60 (count=0) + 47:60 -> 47:61 (count=0) + 47:61 -> 49:10 (count=0) + 49:10 -> 49:11 (count=0) + 50:9 -> 50:23 (count=0) + 52:13 -> 54:15 (count=1) + 57:9 -> 57:10 (count=0) + 57:16 -> 57:29 (count=0) + 58:9 -> 58:23 (count=0) + 59:15 -> 59:28 (count=0) + 60:12 -> 60:25 (count=0) + 60:29 -> 60:42 (count=0) + 60:42 -> 60:43 (count=0) + 60:46 -> 60:60 (count=0) + 60:60 -> 60:61 (count=0) + 60:61 -> 62:10 (count=0) + 62:10 -> 62:11 (count=0) + 63:9 -> 63:23 (count=0) + 65:9 -> 65:15 (count=0) + 67:1 -> 67:2 (count=2) +Segment at 4:9 (count = 1), RegionEntry +Segment at 4:26 (count = 0), Skipped +Segment at 5:8 (count = 1), RegionEntry +Segment at 5:12 (count = 0), Skipped +Segment at 5:13 (count = 1), RegionEntry +Segment at 7:6 (count = 0), Skipped +Segment at 10:9 (count = 1), RegionEntry +Segment at 10:10 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 10:29 (count = 0), Skipped +Segment at 11:9 (count = 1), RegionEntry +Segment at 12:10 (count = 0), Skipped +Segment at 13:15 (count = 0), RegionEntry +Segment at 13:28 (count = 0), Skipped +Segment at 14:12 (count = 0), RegionEntry +Segment at 14:25 (count = 0), Skipped +Segment at 14:29 (count = 0), RegionEntry +Segment at 14:42 (count = 0), RegionEntry +Segment at 14:43 (count = 0), Skipped +Segment at 14:46 (count = 0), RegionEntry +Segment at 14:60 (count = 0), RegionEntry +Segment at 14:61 (count = 0), RegionEntry +Segment at 16:10 (count = 0), RegionEntry +Segment at 16:11 (count = 0), Skipped +Segment at 17:9 (count = 0), RegionEntry +Segment at 18:18 (count = 0), Skipped +Segment at 20:9 (count = 0), RegionEntry +Segment at 20:15 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 23:26 (count = 0), Skipped +Segment at 24:8 (count = 1), RegionEntry +Segment at 24:12 (count = 0), Skipped +Segment at 24:13 (count = 1), RegionEntry +Segment at 26:6 (count = 0), Skipped +Segment at 28:8 (count = 1), RegionEntry +Segment at 28:21 (count = 0), Skipped +Segment at 29:9 (count = 1), RegionEntry +Segment at 29:23 (count = 0), Skipped +Segment at 30:15 (count = 0), RegionEntry +Segment at 30:28 (count = 0), Skipped +Segment at 31:12 (count = 0), RegionEntry +Segment at 31:25 (count = 0), Skipped +Segment at 31:29 (count = 0), RegionEntry +Segment at 31:42 (count = 0), RegionEntry +Segment at 31:43 (count = 0), Skipped +Segment at 31:46 (count = 0), RegionEntry +Segment at 31:60 (count = 0), RegionEntry +Segment at 31:61 (count = 0), RegionEntry +Segment at 33:10 (count = 0), RegionEntry +Segment at 33:11 (count = 0), Skipped +Segment at 34:9 (count = 0), RegionEntry +Segment at 34:23 (count = 0), Skipped +Segment at 36:9 (count = 0), RegionEntry +Segment at 36:15 (count = 0), Skipped +Segment at 39:9 (count = 1), RegionEntry +Segment at 39:26 (count = 0), Skipped +Segment at 40:8 (count = 1), RegionEntry +Segment at 40:12 (count = 0), Skipped +Segment at 40:13 (count = 1), RegionEntry +Segment at 42:6 (count = 0), Skipped +Segment at 44:9 (count = 0), RegionEntry +Segment at 44:10 (count = 0), Skipped +Segment at 44:16 (count = 1), RegionEntry +Segment at 44:29 (count = 0), Skipped +Segment at 45:9 (count = 0), RegionEntry +Segment at 45:23 (count = 0), Skipped +Segment at 46:15 (count = 1), RegionEntry +Segment at 46:28 (count = 0), Skipped +Segment at 47:12 (count = 0), RegionEntry +Segment at 47:25 (count = 0), Skipped +Segment at 47:29 (count = 0), RegionEntry +Segment at 47:42 (count = 0), RegionEntry +Segment at 47:43 (count = 0), Skipped +Segment at 47:46 (count = 0), RegionEntry +Segment at 47:60 (count = 0), RegionEntry +Segment at 47:61 (count = 0), RegionEntry +Segment at 49:10 (count = 0), RegionEntry +Segment at 49:11 (count = 0), Skipped +Segment at 50:9 (count = 0), RegionEntry +Segment at 50:23 (count = 0), Skipped +Segment at 52:13 (count = 1), RegionEntry +Segment at 54:15 (count = 0), Skipped +Segment at 57:9 (count = 0), RegionEntry +Segment at 57:10 (count = 0), Skipped +Segment at 57:16 (count = 0), RegionEntry +Segment at 57:29 (count = 0), Skipped +Segment at 58:9 (count = 0), RegionEntry +Segment at 58:23 (count = 0), Skipped +Segment at 59:15 (count = 0), RegionEntry +Segment at 59:28 (count = 0), Skipped +Segment at 60:12 (count = 0), RegionEntry +Segment at 60:25 (count = 0), Skipped +Segment at 60:29 (count = 0), RegionEntry +Segment at 60:42 (count = 0), RegionEntry +Segment at 60:43 (count = 0), Skipped +Segment at 60:46 (count = 0), RegionEntry +Segment at 60:60 (count = 0), RegionEntry +Segment at 60:61 (count = 0), RegionEntry +Segment at 62:10 (count = 0), RegionEntry +Segment at 62:11 (count = 0), Skipped +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: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 new file mode 100644 index 00000000000..52c809b5325 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt @@ -0,0 +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/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 4:6 -> 4:7, (#3 + 0) +Counter in file 0 5:1 -> 5:2, #4 +Emitting segments for file: ../coverage/while.rs +Combined regions: + 2:9 -> 2:16 (count=1) + 3:11 -> 3:20 (count=1) + 3:21 -> 4:6 (count=0) + 4:6 -> 4:7 (count=0) + 5:1 -> 5:2 (count=1) +Segment at 2:9 (count = 1), RegionEntry +Segment at 2:16 (count = 0), Skipped +Segment at 3:11 (count = 1), RegionEntry +Segment at 3:20 (count = 0), Skipped +Segment at 3:21 (count = 0), RegionEntry +Segment at 4:6 (count = 0), RegionEntry +Segment at 4:7 (count = 0), Skipped +Segment at 5:1 (count = 1), RegionEntry +Segment at 5:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..30d14f4f987 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt @@ -0,0 +1,44 @@ +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 27:18 -> 27:19, (#5 + 0) +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 +Emitting segments for file: ../coverage/while_early_return.rs +Combined regions: + 5:9 -> 5:27 (count=1) + 7:9 -> 9:10 (count=7) + 12:13 -> 14:14 (count=7) + 18:21 -> 20:22 (count=1) + 22:21 -> 22:27 (count=0) + 26:21 -> 26:27 (count=1) + 27:18 -> 27:19 (count=0) + 30:9 -> 32:10 (count=6) + 35:5 -> 35:11 (count=0) + 36:1 -> 36:2 (count=2) +Segment at 5:9 (count = 1), RegionEntry +Segment at 5:27 (count = 0), Skipped +Segment at 7:9 (count = 7), RegionEntry +Segment at 9:10 (count = 0), Skipped +Segment at 12:13 (count = 7), RegionEntry +Segment at 14:14 (count = 0), Skipped +Segment at 18:21 (count = 1), RegionEntry +Segment at 20:22 (count = 0), Skipped +Segment at 22:21 (count = 0), RegionEntry +Segment at 22:27 (count = 0), Skipped +Segment at 26:21 (count = 1), RegionEntry +Segment at 26:27 (count = 0), Skipped +Segment at 27:18 (count = 0), RegionEntry +Segment at 27:19 (count = 0), Skipped +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:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json index 8c6edae2803..bff55300b3c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json @@ -17,14 +17,14 @@ }, "lines": { "count": 91, - "covered": 75, - "percent": 82.41758241758241 + "covered": 77, + "percent": 84.61538461538461 }, "regions": { - "count": 21, - "covered": 11, - "notcovered": 10, - "percent": 52.38095238095239 + "count": 25, + "covered": 13, + "notcovered": 12, + "percent": 52 } } } @@ -42,14 +42,14 @@ }, "lines": { "count": 91, - "covered": 75, - "percent": 82.41758241758241 + "covered": 77, + "percent": 84.61538461538461 }, "regions": { - "count": 21, - "covered": 11, - "notcovered": 10, - "percent": 52.38095238095239 + "count": 25, + "covered": 13, + "notcovered": 12, + "percent": 52 } } } 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 bd2e2d56d4a..7a7e4c04f00 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": 5, - "covered": 5, + "count": 6, + "covered": 6, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 5, - "covered": 5, + "count": 6, + "covered": 6, "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 a50f4657e20..1025cd3de80 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": 6, - "covered": 6, + "count": 7, + "covered": 7, "notcovered": 0, "percent": 100 } @@ -46,8 +46,8 @@ "percent": 100 }, "regions": { - "count": 6, - "covered": 6, + "count": 7, + "covered": 7, "notcovered": 0, "percent": 100 } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json index 2ff53ad33fa..84dcc251f3f 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json @@ -21,10 +21,10 @@ "percent": 100 }, "regions": { - "count": 4, + "count": 5, "covered": 4, - "notcovered": 0, - "percent": 100 + "notcovered": 1, + "percent": 80 } } } @@ -46,10 +46,10 @@ "percent": 100 }, "regions": { - "count": 4, + "count": 5, "covered": 4, - "notcovered": 0, - "percent": 100 + "notcovered": 1, + "percent": 80 } } } 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 36f81ceae19..2d2ad1dbe3f 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": 28, - "covered": 19, - "percent": 67.85714285714286 + "count": 29, + "covered": 21, + "percent": 72.41379310344827 }, "regions": { - "count": 7, - "covered": 5, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 71.42857142857143 + "percent": 77.77777777777779 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 28, - "covered": 19, - "percent": 67.85714285714286 + "count": 29, + "covered": 21, + "percent": 72.41379310344827 }, "regions": { - "count": 7, - "covered": 5, + "count": 9, + "covered": 7, "notcovered": 2, - "percent": 71.42857142857143 + "percent": 77.77777777777779 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json index a24e6a33a33..c178e7f9347 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json @@ -21,10 +21,10 @@ "percent": 100 }, "regions": { - "count": 13, + "count": 15, "covered": 13, - "notcovered": 0, - "percent": 100 + "notcovered": 2, + "percent": 86.66666666666667 } } } @@ -46,10 +46,10 @@ "percent": 100 }, "regions": { - "count": 13, + "count": 15, "covered": 13, - "notcovered": 0, - "percent": 100 + "notcovered": 2, + "percent": 86.66666666666667 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json index 585346dc32a..95a1dcd3b8e 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 21, - "covered": 19, - "percent": 90.47619047619048 + "count": 40, + "covered": 32, + "percent": 80 }, "regions": { - "count": 16, - "covered": 14, - "notcovered": 2, - "percent": 87.5 + "count": 39, + "covered": 28, + "notcovered": 11, + "percent": 71.7948717948718 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 21, - "covered": 19, - "percent": 90.47619047619048 + "count": 40, + "covered": 32, + "percent": 80 }, "regions": { - "count": 16, - "covered": 14, - "notcovered": 2, - "percent": 87.5 + "count": 39, + "covered": 28, + "notcovered": 11, + "percent": 71.7948717948718 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json new file mode 100644 index 00000000000..aec85cd0329 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/loops_and_branches.rs", + "summary": { + "functions": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "instantiations": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "lines": { + "count": 11, + "covered": 11, + "percent": 100 + }, + "regions": { + "count": 10, + "covered": 8, + "notcovered": 2, + "percent": 80 + } + } + } + ], + "totals": { + "functions": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "instantiations": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "lines": { + "count": 11, + "covered": 11, + "percent": 100 + }, + "regions": { + "count": 10, + "covered": 8, + "notcovered": 2, + "percent": 80 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json new file mode 100644 index 00000000000..dbe4f9ca6fd --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/nested_loops.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 21, + "covered": 17, + "percent": 80.95238095238095 + }, + "regions": { + "count": 20, + "covered": 16, + "notcovered": 4, + "percent": 80 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 21, + "covered": 17, + "percent": 80.95238095238095 + }, + "regions": { + "count": 20, + "covered": 16, + "notcovered": 4, + "percent": 80 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json new file mode 100644 index 00000000000..779bfe9904c --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/partial_eq_counter_without_region.rs", + "summary": { + "functions": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "instantiations": { + "count": 8, + "covered": 5, + "percent": 62.5 + }, + "lines": { + "count": 15, + "covered": 15, + "percent": 100 + }, + "regions": { + "count": 6, + "covered": 6, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "totals": { + "functions": { + "count": 5, + "covered": 5, + "percent": 100 + }, + "instantiations": { + "count": 8, + "covered": 5, + "percent": 62.5 + }, + "lines": { + "count": 15, + "covered": 15, + "percent": 100 + }, + "regions": { + "count": 6, + "covered": 6, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json index 38bc96898ea..ada6bb062dd 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 18, - "covered": 18, + "count": 19, + "covered": 19, "percent": 100 }, "regions": { - "count": 7, - "covered": 7, - "notcovered": 0, - "percent": 100 + "count": 9, + "covered": 8, + "notcovered": 1, + "percent": 88.88888888888889 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 18, - "covered": 18, + "count": 19, + "covered": 19, "percent": 100 }, "regions": { - "count": 7, - "covered": 7, - "notcovered": 0, - "percent": 100 + "count": 9, + "covered": 8, + "notcovered": 1, + "percent": 88.88888888888889 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json index f9d91d66f1d..63d1ae74c5f 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 26, - "covered": 26, + "count": 24, + "covered": 24, "percent": 100 }, "regions": { - "count": 9, - "covered": 9, - "notcovered": 0, - "percent": 100 + "count": 15, + "covered": 14, + "notcovered": 1, + "percent": 93.33333333333333 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 26, - "covered": 26, + "count": 24, + "covered": 24, "percent": 100 }, "regions": { - "count": 9, - "covered": 9, - "notcovered": 0, - "percent": 100 + "count": 15, + "covered": 14, + "notcovered": 1, + "percent": 93.33333333333333 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json new file mode 100644 index 00000000000..3fa6821cd1d --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/tight_infinite_loop.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "regions": { + "count": 2, + "covered": 2, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 2, + "covered": 2, + "percent": 100 + }, + "regions": { + "count": 2, + "covered": 2, + "notcovered": 0, + "percent": 100 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} 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 e6ef2c1ab89..e845ee29fa4 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 @@ -16,15 +16,15 @@ "percent": 100 }, "lines": { - "count": 16, - "covered": 15, - "percent": 93.75 + "count": 20, + "covered": 19, + "percent": 95 }, "regions": { - "count": 13, - "covered": 12, - "notcovered": 1, - "percent": 92.3076923076923 + "count": 20, + "covered": 17, + "notcovered": 3, + "percent": 85 } } } @@ -41,15 +41,15 @@ "percent": 100 }, "lines": { - "count": 16, - "covered": 15, - "percent": 93.75 + "count": 20, + "covered": 19, + "percent": 95 }, "regions": { - "count": 13, - "covered": 12, - "notcovered": 1, - "percent": 92.3076923076923 + "count": 20, + "covered": 17, + "notcovered": 3, + "percent": 85 } } } 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 410821ea335..464bb614ea1 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": 51, + "count": 70, "covered": 19, - "notcovered": 32, - "percent": 37.254901960784316 + "notcovered": 51, + "percent": 27.142857142857142 } } } @@ -46,10 +46,10 @@ "percent": 46.93877551020408 }, "regions": { - "count": 51, + "count": 70, "covered": 19, - "notcovered": 32, - "percent": 37.254901960784316 + "notcovered": 51, + "percent": 27.142857142857142 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json new file mode 100644 index 00000000000..27862087ed5 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json @@ -0,0 +1,59 @@ +{ + "data": [ + { + "files": [ + { + "filename": "../coverage/while.rs", + "summary": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 4, + "covered": 3, + "percent": 75 + }, + "regions": { + "count": 5, + "covered": 3, + "notcovered": 2, + "percent": 60 + } + } + } + ], + "totals": { + "functions": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "instantiations": { + "count": 1, + "covered": 1, + "percent": 100 + }, + "lines": { + "count": 4, + "covered": 3, + "percent": 75 + }, + "regions": { + "count": 5, + "covered": 3, + "notcovered": 2, + "percent": 60 + } + } + } + ], + "type": "llvm.coverage.json.export", + "version": "2.0.1" +} 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 865b705fa20..555ac745d53 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 @@ -17,14 +17,14 @@ }, "lines": { "count": 18, - "covered": 16, - "percent": 88.88888888888889 + "covered": 15, + "percent": 83.33333333333334 }, "regions": { - "count": 9, - "covered": 7, - "notcovered": 2, - "percent": 77.77777777777779 + "count": 11, + "covered": 8, + "notcovered": 3, + "percent": 72.72727272727273 } } } @@ -42,14 +42,14 @@ }, "lines": { "count": 18, - "covered": 16, - "percent": 88.88888888888889 + "covered": 15, + "percent": 83.33333333333334 }, "regions": { - "count": 9, - "covered": 7, - "notcovered": 2, - "percent": 77.77777777777779 + "count": 11, + "covered": 8, + "notcovered": 3, + "percent": 72.72727272727273 } } } diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt index 17054490e9b..aef26a62e25 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt @@ -62,7 +62,7 @@ 62| 1| let mut countdown = 0; 63| 1| if is_false { 64| 0| countdown = 10; - 65| 0| } + 65| 1| } 66| 1| "alt string 3".to_owned() 67| 1| } 68| 1| ) @@ -77,7 +77,7 @@ 77| 1| let mut countdown = 0; 78| 1| if is_false { 79| 0| countdown = 10; - 80| 0| } + 80| 1| } 81| 1| "alt string 4".to_owned() 82| 1| }; 83| 1| println!( 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 72aa020ca16..43592df1059 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| 1|} + 27| 2|} 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 86199d74763..11dc0aa65e2 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| 1|} + 38| 2|} 39| | 40| |// Expected program output: 41| |// Exiting with error... diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt index bc2f9b108b2..85e6440ab37 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt @@ -25,5 +25,6 @@ 25| 1| 10 26| 1| ; 27| 1| } + ^0 28| 1|} 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 5f899723e25..64cbc262521 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| | } + 23| 1| } 24| | 25| | if 26| 1| is_true @@ -36,6 +36,6 @@ 36| 0| = 37| 0| 100 38| 0| ; - 39| 0| } + 39| 1| } 40| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt index b13ca83d018..4a51f842a4b 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt @@ -10,6 +10,7 @@ 10| 1| if is_true { 11| 1| countdown = 10; 12| 1| } + ^0 13| | 14| | mod in_mod { 15| | const IN_MOD_CONST: u32 = 1000; @@ -48,6 +49,7 @@ 48| 1| if is_true { 49| 1| in_func(countdown); 50| 1| } + ^0 51| | 52| 1| let mut val = InStruct { 53| 1| in_struct_field: 101, diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt index ded43697515..f01f69f2496 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt @@ -12,12 +12,14 @@ 12| 1| b = 10; 13| 1| c = 100; 14| 1| } + ^0 15| | let 16| 1| somebool 17| | = 18| 1| a < b 19| | || - 20| 0| b < c + 20| 1| b < c + ^0 21| | ; 22| | let 23| 1| somebool @@ -26,19 +28,38 @@ 26| | || 27| 1| b < c 28| | ; - 29| | let - 30| 1| somebool - 31| | = - 32| 1| a < b - 33| | && - 34| 1| b < c - 35| | ; - 36| | let - 37| 1| somebool - 38| | = - 39| 1| b < a - 40| | && - 41| 0| b < c - 42| | ; - 43| 1|} + 29| 1| let somebool = a < b && b < c; + 30| 1| let somebool = b < a && b < c; + ^0 + 31| | + 32| | if + 33| 1| ! + 34| 1| is_true + 35| 0| { + 36| 0| a = 2 + 37| 0| ; + 38| 1| } + 39| | + 40| | if + 41| 1| is_true + 42| 1| { + 43| 1| b = 30 + 44| 1| ; + 45| 1| } + 46| | else + 47| 0| { + 48| 0| c = 400 + 49| 0| ; + 50| 1| } + 51| | + 52| 1| if !is_true { + 53| 0| a = 2; + 54| 1| } + 55| | + 56| 1| if is_true { + 57| 1| b = 30; + 58| 1| } else { + 59| 0| c = 400; + 60| 1| } + 61| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt new file mode 100644 index 00000000000..3a969a6b898 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt @@ -0,0 +1,38 @@ + 1| |#![allow(unused_assignments)] + 2| | + 3| |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the + 4| |// structure of this `fmt` function. + 5| | + 6| |struct DebugTest; + 7| | + 8| |impl std::fmt::Debug for DebugTest { + 9| | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + 10| 1| if true { + 11| 1| if false { + 12| | while true { + 13| | } + 14| 1| } + 15| 1| write!(f, "error")?; + ^0 + 16| | } else { + 17| 1| } + 18| 1| Ok(()) + 19| 1| } + 20| |} + 21| | + 22| 1|fn main() { + 23| 1| let debug_test = DebugTest; + 24| 1| println!("{:?}", debug_test); + 25| 1|} + 26| | + 27| |/* + 28| | + 29| |This is the error message generated, before the issue was fixed: + 30| | + 31| |error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42: + 32| |Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt): + 33| |Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s: + 34| |[bcb6, bcb7, bcb9]" } + 35| | + 36| |*/ + diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt new file mode 100644 index 00000000000..e0545c76f78 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt @@ -0,0 +1,26 @@ + 1| |fn main() { + 2| 1| let is_true = std::env::args().len() == 1; + 3| 1| let mut countdown = 10; + 4| | + 5| 1| 'outer: while countdown > 0 { + 6| 1| let mut a = 100; + 7| 1| let mut b = 100; + 8| 3| for _ in 0..50 { + 9| 3| if a < 30 { + 10| 0| break; + 11| | } + 12| 3| a -= 5; + 13| 3| b -= 5; + 14| 3| if b < 90 { + 15| 1| a -= 10; + 16| 1| if is_true { + 17| 1| break 'outer; + 18| | } else { + 19| 0| a -= 2; + 20| 0| } + 21| 2| } + 22| 3| } + 23| 0| countdown -= 1; + 24| 1| } + 25| 1|} + diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt new file mode 100644 index 00000000000..e7e4dfb5a86 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt @@ -0,0 +1,111 @@ + 1| |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the + 2| |// structure of this test. + 3| | + 4| 2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + ^1 ^1 + ------------------ + | Unexecuted instantiation: ::gt + ------------------ + | Unexecuted instantiation: ::le + ------------------ + | Unexecuted instantiation: ::ge + ------------------ + | ::lt: + | 4| 1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + ------------------ + 5| |pub struct Version { + 6| | major: usize, + 7| 1| minor: usize, + 8| | patch: usize, + 9| |} + 10| | + 11| |impl Version { + 12| | pub fn new(major: usize, minor: usize, patch: usize) -> Self { + 13| 2| Self { + 14| 2| major, + 15| 2| minor, + 16| 2| patch, + 17| 2| } + 18| 2| } + 19| |} + 20| | + 21| 1|fn main() { + 22| 1| let version_3_2_1 = Version::new(3, 2, 1); + 23| 1| let version_3_3_0 = Version::new(3, 3, 0); + 24| 1| + 25| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); + 26| 1|} + 27| | + 28| |/* + 29| | + 30| |This test verifies a bug was fixed that otherwise generated this error: + 31| | + 32| |thread 'rustc' panicked at 'No counters provided the source_hash for function: + 33| | Instance { + 34| | def: Item(WithOptConstParam { + 35| | did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp), + 36| | const_param_did: None + 37| | }), + 38| | substs: [] + 39| | }' + 40| |The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage + 41| |without a code region associated with any `Counter`. Code regions were associated with at least + 42| |one expression, which is allowed, but the `function_source_hash` was only passed to the codegen + 43| |(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the + 44| |`function_source_hash` without a code region, if necessary. + 45| | + 46| |*/ + 47| | + 48| |// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces + 49| |// the following results: + 50| | + 51| |/* + 52| | + 53| |1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17? + 54| | + 55| |2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing + 56| | line count with a different instance? Or was it really only called once? + 57| | + 58| |3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of + 59| | its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a + 60| | problem computing the file position here, for some reason. + 61| | + 62| | + 63| | 16| | + 64| | 17| 2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + 65| | ^1 ^1 + 66| |------------------ + 67| ||Unexecuted instantiation: ::gt + 68| |------------------ + 69| ||Unexecuted instantiation: ::le + 70| |------------------ + 71| ||Unexecuted instantiation: ::ge + 72| |------------------ + 73| ||::lt: + 74| || 17| 1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + 75| |------------------ + 76| | 18| |pub struct Version { + 77| | 19| | major: usize, + 78| | 20| 1| minor: usize, + 79| | 21| | patch: usize, + 80| | 22| |} + 81| | 23| | + 82| | 24| |impl Version { + 83| | 25| | pub fn new(major: usize, minor: usize, patch: usize) -> Self { + 84| | 26| 2| Version { + 85| | 27| 2| major, + 86| | 28| 2| minor, + 87| | 29| 2| patch, + 88| | 30| 2| } + 89| | 31| 2| } + 90| | 32| |} + 91| | 33| | + 92| | 34| 1|fn main() { + 93| | 35| 1| let version_3_2_1 = Version::new(3, 2, 1); + 94| | 36| 1| let version_3_3_0 = Version::new(3, 3, 0); + 95| | 37| 1| + 96| | 38| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version + 97| |_3_3_0); + 98| | 39| 1|} + 99| |*/ + diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt index f1acb7c5459..064930dd75c 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt @@ -16,6 +16,7 @@ 16| 1| 10 17| 1| ; 18| 1| } + ^0 19| | 20| | loop 21| | { @@ -31,6 +32,6 @@ 31| 10| -= 32| 10| 1 33| | ; - 34| | } + 34| 1| } 35| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt index e42f22cd047..1f7e71d3eb0 100644 --- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt @@ -10,22 +10,24 @@ 10| 1| if is_true { 11| 1| countdown = 0; 12| 1| } + ^0 13| | - 14| 3| for - 15| 3| _ + 14| | for + 15| 2| _ 16| | in - 17| 1| 0..2 + 17| 3| 0..2 18| | { 19| | let z 20| | ; 21| | match 22| 2| countdown - 23| 2| { - 24| 2| x - 25| 2| if + 23| | { + 24| 1| x + 25| | if 26| 2| x 27| 2| < 28| 2| 1 + ^1 29| | => 30| 1| { 31| 1| z = countdown @@ -39,6 +41,6 @@ 39| | => 40| 1| {} 41| | } - 42| | } + 42| 3| } 43| 1|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt new file mode 100644 index 00000000000..e02eac03a6b --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt @@ -0,0 +1,6 @@ + 1| |fn main() { + 2| 1| if false { + 3| | loop {} + 4| | } + 5| 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 ae288d7d7a0..05d72d0de46 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 @@ -6,22 +6,22 @@ 6| 1| Err(()) 7| | } else { 8| 5| Ok(()) - 9| | } + 9| 1| } 10| 6|} 11| | 12| |fn main() -> Result<(),()> { 13| 1| let mut 14| 1| countdown = 10 15| | ; - 16| 6| for + 16| | for 17| 6| _ 18| | in - 19| 1| 0..10 + 19| 6| 0..10 20| | { 21| 6| countdown 22| 6| -= 1 - 23| | ; - 24| | if + 23| 6| ; + 24| 6| if 25| 6| countdown < 5 26| | { 27| 1| call(/*return_error=*/ true)?; @@ -29,8 +29,9 @@ 29| | else 30| | { 31| 5| call(/*return_error=*/ false)?; - 32| | } - 33| | } + ^0 + 32| 5| } + 33| 6| } 34| 0| Ok(()) - 35| 1|} + 35| 2|} 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 173ff4aa4c4..e0efe75043d 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| 1|} + 67| 2|} diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt new file mode 100644 index 00000000000..194325b6b9e --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt @@ -0,0 +1,6 @@ + 1| |fn main() { + 2| 1| let num = 9; + 3| 1| while num >= 10 { + 4| 0| } + 5| 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 7dce94f25f3..2e0c4022bed 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 @@ -3,7 +3,7 @@ 3| | 4| |fn main() -> Result<(),u8> { 5| 1| let mut countdown = 10; - 6| 7| while + 6| | while 7| 7| countdown 8| 7| > 9| 7| 0 @@ -24,7 +24,7 @@ 24| | else 25| | { 26| 1| Err(1) - 27| | } + 27| 0| } 28| | ; 29| | } 30| 6| countdown @@ -33,7 +33,7 @@ 33| | ; 34| | } 35| 0| Ok(()) - 36| 1|} + 36| 2|} 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 new file mode 100644 index 00000000000..39bf7bad9a1 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt @@ -0,0 +1,95 @@ +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/closure.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/closure +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 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) +Counter in file 0 67:14 -> 75:9, (#1 + 0) +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 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 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 +Emitting segments for file: ../coverage/closure.rs +Combined regions: + 3:11 -> 18:13 (count=1) + 20:21 -> 20:38 (count=0) + 21:20 -> 21:28 (count=0) + 21:29 -> 23:18 (count=0) + 23:18 -> 23:19 (count=0) + 24:17 -> 25:14 (count=0) + 25:14 -> 33:9 (count=1) + 35:13 -> 35:30 (count=0) + 36:12 -> 36:20 (count=0) + 36:21 -> 38:10 (count=0) + 38:10 -> 38:11 (count=0) + 39:9 -> 40:6 (count=0) + 40:6 -> 60:13 (count=1) + 62:21 -> 62:38 (count=1) + 63:20 -> 63:28 (count=1) + 63:29 -> 65:18 (count=0) + 65:18 -> 65:19 (count=1) + 66:17 -> 67:14 (count=1) + 67:14 -> 75:9 (count=1) + 77:13 -> 77:30 (count=1) + 78:12 -> 78:20 (count=1) + 78:21 -> 80:10 (count=0) + 80:10 -> 80:11 (count=1) + 81:9 -> 82:6 (count=1) + 82:6 -> 93:2 (count=1) +Segment at 3:11 (count = 1), RegionEntry +Segment at 18:13 (count = 0), Skipped +Segment at 20:21 (count = 0), RegionEntry +Segment at 20:38 (count = 0), Skipped +Segment at 21:20 (count = 0), RegionEntry +Segment at 21:28 (count = 0), Skipped +Segment at 21:29 (count = 0), RegionEntry +Segment at 23:18 (count = 0), RegionEntry +Segment at 23:19 (count = 0), Skipped +Segment at 24:17 (count = 0), RegionEntry +Segment at 25:14 (count = 1), RegionEntry +Segment at 33:9 (count = 0), Skipped +Segment at 35:13 (count = 0), RegionEntry +Segment at 35:30 (count = 0), Skipped +Segment at 36:12 (count = 0), RegionEntry +Segment at 36:20 (count = 0), Skipped +Segment at 36:21 (count = 0), RegionEntry +Segment at 38:10 (count = 0), RegionEntry +Segment at 38:11 (count = 0), Skipped +Segment at 39:9 (count = 0), RegionEntry +Segment at 40:6 (count = 1), RegionEntry +Segment at 60:13 (count = 0), Skipped +Segment at 62:21 (count = 1), RegionEntry +Segment at 62:38 (count = 0), Skipped +Segment at 63:20 (count = 1), RegionEntry +Segment at 63:28 (count = 0), Skipped +Segment at 63:29 (count = 0), RegionEntry +Segment at 65:18 (count = 1), RegionEntry +Segment at 65:19 (count = 0), Skipped +Segment at 66:17 (count = 1), RegionEntry +Segment at 67:14 (count = 1), RegionEntry +Segment at 75:9 (count = 0), Skipped +Segment at 77:13 (count = 1), RegionEntry +Segment at 77:30 (count = 0), Skipped +Segment at 78:12 (count = 1), RegionEntry +Segment at 78:20 (count = 0), Skipped +Segment at 78:21 (count = 0), RegionEntry +Segment at 80:10 (count = 1), RegionEntry +Segment at 80:11 (count = 0), Skipped +Segment at 81:9 (count = 1), RegionEntry +Segment at 82:6 (count = 1), RegionEntry +Segment at 93:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..e416a84820a --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt @@ -0,0 +1,24 @@ +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/drop_trait.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/drop_trait +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) + 15:9 -> 17:42 (count=1) + 19:8 -> 19:12 (count=1) + 20:9 -> 21:22 (count=1) + 27:1 -> 27:2 (count=2) +Segment at 9:24 (count = 2), RegionEntry +Segment at 11:6 (count = 0), Skipped +Segment at 15:9 (count = 1), RegionEntry +Segment at 17:42 (count = 0), Skipped +Segment at 19:8 (count = 1), RegionEntry +Segment at 19:12 (count = 0), Skipped +Segment at 20:9 (count = 1), RegionEntry +Segment at 21:22 (count = 0), Skipped +Segment at 27:1 (count = 2), RegionEntry +Segment at 27:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..9e33b48fc29 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt @@ -0,0 +1,50 @@ +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/generics.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/generics +Counter in file 0 17:24 -> 19:6, #1 +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 +Combined regions: + 10:49 -> 12:6 (count=3) + 17:24 -> 19:6 (count=2) + 23:9 -> 28:28 (count=1) + 30:8 -> 30:12 (count=1) + 31:9 -> 32:22 (count=1) + 38:1 -> 38:2 (count=2) +Segment at 10:49 (count = 3), RegionEntry +Segment at 12:6 (count = 0), Skipped +Segment at 17:24 (count = 2), RegionEntry +Segment at 19:6 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 28:28 (count = 0), Skipped +Segment at 30:8 (count = 1), RegionEntry +Segment at 30:12 (count = 0), Skipped +Segment at 31:9 (count = 1), RegionEntry +Segment at 32:22 (count = 0), Skipped +Segment at 38:1 (count = 2), RegionEntry +Segment at 38:2 (count = 0), Skipped +Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworkdE12set_strengthB2_ +Combined regions: + 10:49 -> 12:6 (count=2) +Segment at 10:49 (count = 2), RegionEntry +Segment at 12:6 (count = 0), Skipped +Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworklE12set_strengthB2_ +Combined regions: + 10:49 -> 12:6 (count=1) +Segment at 10:49 (count = 1), RegionEntry +Segment at 12:6 (count = 0), Skipped +Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworklENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_ +Combined regions: + 17:24 -> 19:6 (count=1) +Segment at 17:24 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped +Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworkdENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_ +Combined regions: + 17:24 -> 19:6 (count=1) +Segment at 17:24 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped 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 new file mode 100644 index 00000000000..325e6985e30 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt @@ -0,0 +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/if.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if +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 +Emitting segments for file: ../coverage/if.rs +Combined regions: + 8:5 -> 18:10 (count=1) + 21:9 -> 21:16 (count=1) + 22:5 -> 27:6 (count=1) + 27:6 -> 27:7 (count=0) + 28:1 -> 28:2 (count=1) +Segment at 8:5 (count = 1), RegionEntry +Segment at 18:10 (count = 0), Skipped +Segment at 21:9 (count = 1), RegionEntry +Segment at 21:16 (count = 0), Skipped +Segment at 22:5 (count = 1), RegionEntry +Segment at 27:6 (count = 0), RegionEntry +Segment at 27:7 (count = 0), Skipped +Segment at 28:1 (count = 1), RegionEntry +Segment at 28:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..a620bf8ae4a --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt @@ -0,0 +1,38 @@ +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 23:6 -> 23:7, (#2 + 0) +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 39:6 -> 39:7, (#5 + 0) +Counter in file 0 40:1 -> 40:2, #7 +Emitting segments for file: ../coverage/if_else.rs +Combined regions: + 7:9 -> 11:16 (count=1) + 12:5 -> 17:6 (count=1) + 20:9 -> 22:16 (count=0) + 23:6 -> 23:7 (count=1) + 26:9 -> 26:16 (count=1) + 27:5 -> 32:6 (count=1) + 34:5 -> 39:6 (count=0) + 39:6 -> 39:7 (count=1) + 40:1 -> 40:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 11:16 (count = 0), Skipped +Segment at 12:5 (count = 1), RegionEntry +Segment at 17:6 (count = 0), Skipped +Segment at 20:9 (count = 0), RegionEntry +Segment at 22:16 (count = 0), Skipped +Segment at 23:6 (count = 1), RegionEntry +Segment at 23:7 (count = 0), Skipped +Segment at 26:9 (count = 1), RegionEntry +Segment at 26:16 (count = 0), Skipped +Segment at 27:5 (count = 1), RegionEntry +Segment at 32:6 (count = 0), Skipped +Segment at 34:5 (count = 0), RegionEntry +Segment at 39:6 (count = 1), RegionEntry +Segment at 39:7 (count = 0), Skipped +Segment at 40:1 (count = 1), RegionEntry +Segment at 40:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..ea6db9452a7 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt @@ -0,0 +1,61 @@ +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/inner_items.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/inner_items +Counter in file 0 19:13 -> 19:18, #1 +Counter in file 0 20:13 -> 20:14, #2 +Counter in file 0 20:17 -> 20:22, (#1 + 0) +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 33:42 -> 36:10, #1 +Counter in file 0 41:37 -> 41:41, #1 +Counter in file 0 42:13 -> 43:10, #2 +Emitting segments for file: ../coverage/inner_items.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 12:6 (count=1) + 12:6 -> 12:7 (count=0) + 19:13 -> 19:18 (count=3) + 20:13 -> 20:14 (count=3) + 20:17 -> 20:22 (count=3) + 21:9 -> 22:6 (count=3) + 33:42 -> 36:10 (count=1) + 41:37 -> 41:41 (count=1) + 42:13 -> 43:10 (count=1) + 48:8 -> 48:15 (count=1) + 48:16 -> 50:6 (count=1) + 50:6 -> 50:7 (count=0) + 52:9 -> 57:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 12:6 (count = 0), RegionEntry +Segment at 12:7 (count = 0), Skipped +Segment at 19:13 (count = 3), RegionEntry +Segment at 19:18 (count = 0), Skipped +Segment at 20:13 (count = 3), RegionEntry +Segment at 20:14 (count = 0), Skipped +Segment at 20:17 (count = 3), RegionEntry +Segment at 20:22 (count = 0), Skipped +Segment at 21:9 (count = 3), RegionEntry +Segment at 22:6 (count = 0), Skipped +Segment at 33:42 (count = 1), RegionEntry +Segment at 36:10 (count = 0), Skipped +Segment at 41:37 (count = 1), RegionEntry +Segment at 41:41 (count = 0), Skipped +Segment at 42:13 (count = 1), RegionEntry +Segment at 43:10 (count = 0), Skipped +Segment at 48:8 (count = 1), RegionEntry +Segment at 48:15 (count = 0), Skipped +Segment at 48:16 (count = 1), RegionEntry +Segment at 50:6 (count = 0), RegionEntry +Segment at 50:7 (count = 0), Skipped +Segment at 52:9 (count = 1), RegionEntry +Segment at 57:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..0f54f4904b0 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt @@ -0,0 +1,138 @@ +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/lazy_boolean.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/lazy_boolean +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 50:6 -> 50:7, (#24 + 0) +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 60:6 -> 60:7, (#30 + 0) +Counter in file 0 61:1 -> 61:2, #32 +Emitting segments for file: ../coverage/lazy_boolean.rs +Combined regions: + 7:9 -> 9:42 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 14:6 (count=1) + 14:6 -> 14:7 (count=0) + 16:9 -> 16:17 (count=1) + 18:13 -> 18:18 (count=1) + 20:13 -> 20:18 (count=0) + 20:18 -> 20:19 (count=1) + 23:9 -> 23:17 (count=1) + 25:13 -> 25:18 (count=1) + 27:13 -> 27:18 (count=1) + 27:18 -> 27:19 (count=1) + 29:9 -> 29:17 (count=1) + 29:20 -> 29:25 (count=1) + 29:29 -> 29:34 (count=1) + 29:34 -> 29:35 (count=1) + 30:9 -> 30:17 (count=1) + 30:20 -> 30:25 (count=1) + 30:29 -> 30:34 (count=0) + 30:34 -> 30:35 (count=1) + 33:9 -> 34:16 (count=1) + 35:5 -> 38:6 (count=0) + 38:6 -> 38:7 (count=1) + 41:9 -> 41:16 (count=1) + 42:5 -> 45:6 (count=1) + 47:5 -> 50:6 (count=0) + 50:6 -> 50:7 (count=1) + 52:8 -> 52:16 (count=1) + 52:17 -> 54:6 (count=0) + 54:6 -> 54:7 (count=1) + 56:8 -> 56:15 (count=1) + 56:16 -> 58:6 (count=1) + 58:12 -> 60:6 (count=0) + 60:6 -> 60:7 (count=1) + 61:1 -> 61:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:42 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 14:6 (count = 0), RegionEntry +Segment at 14:7 (count = 0), Skipped +Segment at 16:9 (count = 1), RegionEntry +Segment at 16:17 (count = 0), Skipped +Segment at 18:13 (count = 1), RegionEntry +Segment at 18:18 (count = 0), Skipped +Segment at 20:13 (count = 0), RegionEntry +Segment at 20:18 (count = 1), RegionEntry +Segment at 20:19 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 23:17 (count = 0), Skipped +Segment at 25:13 (count = 1), RegionEntry +Segment at 25:18 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:18 (count = 1), RegionEntry +Segment at 27:19 (count = 0), Skipped +Segment at 29:9 (count = 1), RegionEntry +Segment at 29:17 (count = 0), Skipped +Segment at 29:20 (count = 1), RegionEntry +Segment at 29:25 (count = 0), Skipped +Segment at 29:29 (count = 1), RegionEntry +Segment at 29:34 (count = 1), RegionEntry +Segment at 29:35 (count = 0), Skipped +Segment at 30:9 (count = 1), RegionEntry +Segment at 30:17 (count = 0), Skipped +Segment at 30:20 (count = 1), RegionEntry +Segment at 30:25 (count = 0), Skipped +Segment at 30:29 (count = 0), RegionEntry +Segment at 30:34 (count = 1), RegionEntry +Segment at 30:35 (count = 0), Skipped +Segment at 33:9 (count = 1), RegionEntry +Segment at 34:16 (count = 0), Skipped +Segment at 35:5 (count = 0), RegionEntry +Segment at 38:6 (count = 1), RegionEntry +Segment at 38:7 (count = 0), Skipped +Segment at 41:9 (count = 1), RegionEntry +Segment at 41:16 (count = 0), Skipped +Segment at 42:5 (count = 1), RegionEntry +Segment at 45:6 (count = 0), Skipped +Segment at 47:5 (count = 0), RegionEntry +Segment at 50:6 (count = 1), RegionEntry +Segment at 50:7 (count = 0), Skipped +Segment at 52:8 (count = 1), RegionEntry +Segment at 52:16 (count = 0), Skipped +Segment at 52:17 (count = 0), RegionEntry +Segment at 54:6 (count = 1), RegionEntry +Segment at 54:7 (count = 0), Skipped +Segment at 56:8 (count = 1), RegionEntry +Segment at 56:15 (count = 0), Skipped +Segment at 56:16 (count = 1), RegionEntry +Segment at 58:6 (count = 0), Skipped +Segment at 58:12 (count = 0), RegionEntry +Segment at 60:6 (count = 1), RegionEntry +Segment at 60:7 (count = 0), Skipped +Segment at 61:1 (count = 1), RegionEntry +Segment at 61:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt new file mode 100644 index 00000000000..3f5fc4a4401 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt @@ -0,0 +1,7 @@ +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/loop_break_value.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loop_break_value +Counter in file 0 3:11 -> 13:2, #1 +Emitting segments for file: ../coverage/loop_break_value.rs +Combined regions: + 3:11 -> 13:2 (count=1) +Segment at 3:11 (count = 1), RegionEntry +Segment at 13:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..ca3b1d61343 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt @@ -0,0 +1,39 @@ +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 19:5 -> 19:6, (#8 + 0) +Counter in file 0 22:11 -> 25:2, #1 +Emitting segments for file: ../coverage/loops_and_branches.rs +Combined regions: + 10:12 -> 10:16 (count=1) + 11:16 -> 11:21 (count=1) + 14:14 -> 14:15 (count=1) + 15:13 -> 15:31 (count=1) + 15:31 -> 15:32 (count=0) + 17:10 -> 17:11 (count=1) + 18:9 -> 18:15 (count=1) + 19:5 -> 19:6 (count=1) + 22:11 -> 25:2 (count=1) +Segment at 10:12 (count = 1), RegionEntry +Segment at 10:16 (count = 0), Skipped +Segment at 11:16 (count = 1), RegionEntry +Segment at 11:21 (count = 0), Skipped +Segment at 14:14 (count = 1), RegionEntry +Segment at 14:15 (count = 0), Skipped +Segment at 15:13 (count = 1), RegionEntry +Segment at 15:31 (count = 0), RegionEntry +Segment at 15:32 (count = 0), Skipped +Segment at 17:10 (count = 1), RegionEntry +Segment at 17:11 (count = 0), Skipped +Segment at 18:9 (count = 1), RegionEntry +Segment at 18:15 (count = 0), Skipped +Segment at 19:5 (count = 1), RegionEntry +Segment at 19:6 (count = 0), Skipped +Segment at 22:11 (count = 1), RegionEntry +Segment at 25:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..9c9c46a0834 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt @@ -0,0 +1,76 @@ +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 22:10 -> 22:11, (#3 + 0) +Counter in file 0 23:9 -> 23:23, #14 +Counter in file 0 24:6 -> 24:7, #15 +Counter in file 0 24:6 -> 24:7, (#1 + 0) +Counter in file 0 25:1 -> 25:2, #16 +Emitting segments for file: ../coverage/nested_loops.rs +Combined regions: + 2:9 -> 3:27 (count=1) + 5:19 -> 5:32 (count=1) + 6:13 -> 7:24 (count=1) + 8:13 -> 8:14 (count=3) + 8:18 -> 8:23 (count=3) + 9:16 -> 9:22 (count=3) + 10:17 -> 10:22 (count=0) + 12:13 -> 12:19 (count=3) + 13:13 -> 13:19 (count=3) + 14:16 -> 14:22 (count=3) + 15:17 -> 16:27 (count=1) + 17:21 -> 17:33 (count=1) + 19:21 -> 21:14 (count=0) + 21:14 -> 21:15 (count=2) + 22:10 -> 22:11 (count=3) + 23:9 -> 23:23 (count=0) + 24:6 -> 24:7 (count=1) + 25:1 -> 25:2 (count=1) +Segment at 2:9 (count = 1), RegionEntry +Segment at 3:27 (count = 0), Skipped +Segment at 5:19 (count = 1), RegionEntry +Segment at 5:32 (count = 0), Skipped +Segment at 6:13 (count = 1), RegionEntry +Segment at 7:24 (count = 0), Skipped +Segment at 8:13 (count = 3), RegionEntry +Segment at 8:14 (count = 0), Skipped +Segment at 8:18 (count = 3), RegionEntry +Segment at 8:23 (count = 0), Skipped +Segment at 9:16 (count = 3), RegionEntry +Segment at 9:22 (count = 0), Skipped +Segment at 10:17 (count = 0), RegionEntry +Segment at 10:22 (count = 0), Skipped +Segment at 12:13 (count = 3), RegionEntry +Segment at 12:19 (count = 0), Skipped +Segment at 13:13 (count = 3), RegionEntry +Segment at 13:19 (count = 0), Skipped +Segment at 14:16 (count = 3), RegionEntry +Segment at 14:22 (count = 0), Skipped +Segment at 15:17 (count = 1), RegionEntry +Segment at 16:27 (count = 0), Skipped +Segment at 17:21 (count = 1), RegionEntry +Segment at 17:33 (count = 0), Skipped +Segment at 19:21 (count = 0), RegionEntry +Segment at 21:14 (count = 2), RegionEntry +Segment at 21:15 (count = 0), Skipped +Segment at 22:10 (count = 3), RegionEntry +Segment at 22:11 (count = 0), Skipped +Segment at 23:9 (count = 0), RegionEntry +Segment at 23:23 (count = 0), Skipped +Segment at 24:6 (count = 1), RegionEntry +Segment at 24:7 (count = 0), Skipped +Segment at 25:1 (count = 1), RegionEntry +Segment at 25:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..dbcaa57b4b2 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt @@ -0,0 +1,68 @@ +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:39 -> 4:49, #4 +Counter in file 0 4:48 -> 4:49, #5 +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 +Counter in file 0 4:48 -> 4:49, (#1 + 0) +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:51 -> 4:54, #4 +Counter in file 0 4:53 -> 4:54, #5 +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 +Counter in file 0 4:48 -> 4:49, (#1 + 0) +Counter in file 0 7:5 -> 7:6, #1 +Counter in file 0 4:10 -> 4:15, #1 +Counter in file 0 4:35 -> 4:37, #1 +Counter in file 0 7:5 -> 7:6, #1 +Counter in file 0 8:5 -> 8:17, #1 +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 +Emitting segments for file: ../coverage/partial_eq_counter_without_region.rs +Combined regions: + 4:17 -> 4:22 (count=2) + 4:39 -> 4:40 (count=1) + 4:48 -> 4:49 (count=1) + 7:5 -> 7:6 (count=1) + 13:9 -> 18:6 (count=2) + 21:11 -> 26:2 (count=1) +Segment at 4:17 (count = 2), RegionEntry +Segment at 4:22 (count = 0), Skipped +Segment at 4:39 (count = 1), RegionEntry +Segment at 4:40 (count = 0), Skipped +Segment at 4:48 (count = 1), RegionEntry +Segment at 4:49 (count = 0), Skipped +Segment at 7:5 (count = 1), RegionEntry +Segment at 7:6 (count = 0), Skipped +Segment at 13:9 (count = 2), RegionEntry +Segment at 18:6 (count = 0), Skipped +Segment at 21:11 (count = 1), RegionEntry +Segment at 26:2 (count = 0), Skipped +Emitting segments for function: _RNvXs0_Cs4fqI2P2rA04_33partial_eq_counter_without_regionNtB5_7VersionNtNtCs7f2nZg1zwMz_4core3cmp10PartialOrd2ltB5_ +Combined regions: + 4:39 -> 4:40 (count=1) + 4:48 -> 4:49 (count=1) +Segment at 4:39 (count = 1), RegionEntry +Segment at 4:40 (count = 0), Skipped +Segment at 4:48 (count = 1), RegionEntry +Segment at 4:49 (count = 0), Skipped 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 new file mode 100644 index 00000000000..90e09099dcc --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt @@ -0,0 +1,38 @@ +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/simple_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_loop +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) +Emitting segments for file: ../coverage/simple_loop.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 12:9 -> 12:16 (count=1) + 13:5 -> 18:6 (count=1) + 18:6 -> 18:7 (count=0) + 23:13 -> 25:14 (count=11) + 27:13 -> 27:18 (count=1) + 30:9 -> 32:10 (count=10) + 34:6 -> 34:7 (count=1) + 35:1 -> 35:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 12:9 (count = 1), RegionEntry +Segment at 12:16 (count = 0), Skipped +Segment at 13:5 (count = 1), RegionEntry +Segment at 18:6 (count = 0), RegionEntry +Segment at 18:7 (count = 0), Skipped +Segment at 23:13 (count = 11), RegionEntry +Segment at 25:14 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:18 (count = 0), Skipped +Segment at 30:9 (count = 10), RegionEntry +Segment at 32:10 (count = 0), Skipped +Segment at 34:6 (count = 1), RegionEntry +Segment at 34:7 (count = 0), Skipped +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.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt new file mode 100644 index 00000000000..39a986332cd --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt @@ -0,0 +1,58 @@ +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/simple_match.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_match +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 +Emitting segments for file: ../coverage/simple_match.rs +Combined regions: + 7:9 -> 9:26 (count=1) + 10:8 -> 10:15 (count=1) + 10:16 -> 12:6 (count=1) + 12:6 -> 12:7 (count=0) + 15:9 -> 15:10 (count=2) + 17:9 -> 17:13 (count=3) + 22:13 -> 22:22 (count=2) + 24:13 -> 24:14 (count=1) + 26:17 -> 28:18 (count=2) + 28:18 -> 28:19 (count=1) + 30:13 -> 37:14 (count=1) + 40:13 -> 40:15 (count=1) + 42:6 -> 42:7 (count=3) + 43:1 -> 43:2 (count=1) +Segment at 7:9 (count = 1), RegionEntry +Segment at 9:26 (count = 0), Skipped +Segment at 10:8 (count = 1), RegionEntry +Segment at 10:15 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 12:6 (count = 0), RegionEntry +Segment at 12:7 (count = 0), Skipped +Segment at 15:9 (count = 2), RegionEntry +Segment at 15:10 (count = 0), Skipped +Segment at 17:9 (count = 3), RegionEntry +Segment at 17:13 (count = 0), Skipped +Segment at 22:13 (count = 2), RegionEntry +Segment at 22:22 (count = 0), Skipped +Segment at 24:13 (count = 1), RegionEntry +Segment at 24:14 (count = 0), Skipped +Segment at 26:17 (count = 2), RegionEntry +Segment at 28:18 (count = 1), RegionEntry +Segment at 28:19 (count = 0), Skipped +Segment at 30:13 (count = 1), RegionEntry +Segment at 37:14 (count = 0), Skipped +Segment at 40:13 (count = 1), RegionEntry +Segment at 40:15 (count = 0), Skipped +Segment at 42:6 (count = 3), RegionEntry +Segment at 42:7 (count = 0), Skipped +Segment at 43:1 (count = 1), RegionEntry +Segment at 43:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..a0687815fb9 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt @@ -0,0 +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/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 +Emitting segments for file: ../coverage/tight_infinite_loop.rs +Combined regions: + 2:8 -> 2:13 (count=1) + 5:1 -> 5:2 (count=1) +Segment at 2:8 (count = 1), RegionEntry +Segment at 2:13 (count = 0), Skipped +Segment at 5:1 (count = 1), RegionEntry +Segment at 5:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..10fc52354b9 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt @@ -0,0 +1,72 @@ +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 33:6 -> 33:7, (#1 + 0) +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 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 9:6 -> 9:7, (#2 + 0) +Counter in file 0 10:1 -> 10:2, #4 +Emitting segments for file: ../coverage/try_error_result.rs +Combined regions: + 5:8 -> 5:20 (count=6) + 6:9 -> 6:16 (count=1) + 8:9 -> 8:15 (count=5) + 9:6 -> 9:7 (count=1) + 10:1 -> 10:2 (count=6) + 13:9 -> 14:23 (count=1) + 17:9 -> 17:10 (count=6) + 19:9 -> 19:14 (count=6) + 21:9 -> 25:26 (count=6) + 27:13 -> 27:41 (count=1) + 27:41 -> 27:42 (count=1) + 31:13 -> 31:42 (count=5) + 31:42 -> 31:43 (count=0) + 32:10 -> 32:11 (count=5) + 33:6 -> 33:7 (count=6) + 34:5 -> 34:11 (count=0) + 35:1 -> 35:2 (count=2) +Segment at 5:8 (count = 6), RegionEntry +Segment at 5:20 (count = 0), Skipped +Segment at 6:9 (count = 1), RegionEntry +Segment at 6:16 (count = 0), Skipped +Segment at 8:9 (count = 5), RegionEntry +Segment at 8:15 (count = 0), Skipped +Segment at 9:6 (count = 1), RegionEntry +Segment at 9:7 (count = 0), Skipped +Segment at 10:1 (count = 6), RegionEntry +Segment at 10:2 (count = 0), Skipped +Segment at 13:9 (count = 1), RegionEntry +Segment at 14:23 (count = 0), Skipped +Segment at 17:9 (count = 6), RegionEntry +Segment at 17:10 (count = 0), Skipped +Segment at 19:9 (count = 6), RegionEntry +Segment at 19:14 (count = 0), Skipped +Segment at 21:9 (count = 6), RegionEntry +Segment at 25:26 (count = 0), Skipped +Segment at 27:13 (count = 1), RegionEntry +Segment at 27:41 (count = 1), RegionEntry +Segment at 27:42 (count = 0), Skipped +Segment at 31:13 (count = 5), RegionEntry +Segment at 31:42 (count = 0), RegionEntry +Segment at 31:43 (count = 0), Skipped +Segment at 32:10 (count = 5), RegionEntry +Segment at 32:11 (count = 0), Skipped +Segment at 33:6 (count = 6), 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: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 new file mode 100644 index 00000000000..567c8cd9b6d --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt @@ -0,0 +1,240 @@ +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/various_conditions.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/various_conditions +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 +Emitting segments for file: ../coverage/various_conditions.rs +Combined regions: + 4:9 -> 4:26 (count=1) + 5:8 -> 5:12 (count=1) + 5:13 -> 7:6 (count=1) + 10:9 -> 10:10 (count=1) + 10:16 -> 10:29 (count=1) + 11:9 -> 12:10 (count=1) + 13:15 -> 13:28 (count=0) + 14:12 -> 14:25 (count=0) + 14:29 -> 14:42 (count=0) + 14:42 -> 14:43 (count=0) + 14:46 -> 14:60 (count=0) + 14:60 -> 14:61 (count=0) + 14:61 -> 16:10 (count=0) + 16:10 -> 16:11 (count=0) + 17:9 -> 18:18 (count=0) + 20:9 -> 20:15 (count=0) + 23:9 -> 23:26 (count=1) + 24:8 -> 24:12 (count=1) + 24:13 -> 26:6 (count=1) + 28:8 -> 28:21 (count=1) + 29:9 -> 29:23 (count=1) + 30:15 -> 30:28 (count=0) + 31:12 -> 31:25 (count=0) + 31:29 -> 31:42 (count=0) + 31:42 -> 31:43 (count=0) + 31:46 -> 31:60 (count=0) + 31:60 -> 31:61 (count=0) + 31:61 -> 33:10 (count=0) + 33:10 -> 33:11 (count=0) + 34:9 -> 34:23 (count=0) + 36:9 -> 36:15 (count=0) + 39:9 -> 39:26 (count=1) + 40:8 -> 40:12 (count=1) + 40:13 -> 42:6 (count=1) + 44:9 -> 44:10 (count=0) + 44:16 -> 44:29 (count=1) + 45:9 -> 45:23 (count=0) + 46:15 -> 46:28 (count=1) + 47:12 -> 47:25 (count=0) + 47:29 -> 47:42 (count=0) + 47:42 -> 47:43 (count=0) + 47:46 -> 47:60 (count=0) + 47:60 -> 47:61 (count=0) + 47:61 -> 49:10 (count=0) + 49:10 -> 49:11 (count=0) + 50:9 -> 50:23 (count=0) + 52:13 -> 54:15 (count=1) + 57:9 -> 57:10 (count=0) + 57:16 -> 57:29 (count=0) + 58:9 -> 58:23 (count=0) + 59:15 -> 59:28 (count=0) + 60:12 -> 60:25 (count=0) + 60:29 -> 60:42 (count=0) + 60:42 -> 60:43 (count=0) + 60:46 -> 60:60 (count=0) + 60:60 -> 60:61 (count=0) + 60:61 -> 62:10 (count=0) + 62:10 -> 62:11 (count=0) + 63:9 -> 63:23 (count=0) + 65:9 -> 65:15 (count=0) + 67:1 -> 67:2 (count=2) +Segment at 4:9 (count = 1), RegionEntry +Segment at 4:26 (count = 0), Skipped +Segment at 5:8 (count = 1), RegionEntry +Segment at 5:12 (count = 0), Skipped +Segment at 5:13 (count = 1), RegionEntry +Segment at 7:6 (count = 0), Skipped +Segment at 10:9 (count = 1), RegionEntry +Segment at 10:10 (count = 0), Skipped +Segment at 10:16 (count = 1), RegionEntry +Segment at 10:29 (count = 0), Skipped +Segment at 11:9 (count = 1), RegionEntry +Segment at 12:10 (count = 0), Skipped +Segment at 13:15 (count = 0), RegionEntry +Segment at 13:28 (count = 0), Skipped +Segment at 14:12 (count = 0), RegionEntry +Segment at 14:25 (count = 0), Skipped +Segment at 14:29 (count = 0), RegionEntry +Segment at 14:42 (count = 0), RegionEntry +Segment at 14:43 (count = 0), Skipped +Segment at 14:46 (count = 0), RegionEntry +Segment at 14:60 (count = 0), RegionEntry +Segment at 14:61 (count = 0), RegionEntry +Segment at 16:10 (count = 0), RegionEntry +Segment at 16:11 (count = 0), Skipped +Segment at 17:9 (count = 0), RegionEntry +Segment at 18:18 (count = 0), Skipped +Segment at 20:9 (count = 0), RegionEntry +Segment at 20:15 (count = 0), Skipped +Segment at 23:9 (count = 1), RegionEntry +Segment at 23:26 (count = 0), Skipped +Segment at 24:8 (count = 1), RegionEntry +Segment at 24:12 (count = 0), Skipped +Segment at 24:13 (count = 1), RegionEntry +Segment at 26:6 (count = 0), Skipped +Segment at 28:8 (count = 1), RegionEntry +Segment at 28:21 (count = 0), Skipped +Segment at 29:9 (count = 1), RegionEntry +Segment at 29:23 (count = 0), Skipped +Segment at 30:15 (count = 0), RegionEntry +Segment at 30:28 (count = 0), Skipped +Segment at 31:12 (count = 0), RegionEntry +Segment at 31:25 (count = 0), Skipped +Segment at 31:29 (count = 0), RegionEntry +Segment at 31:42 (count = 0), RegionEntry +Segment at 31:43 (count = 0), Skipped +Segment at 31:46 (count = 0), RegionEntry +Segment at 31:60 (count = 0), RegionEntry +Segment at 31:61 (count = 0), RegionEntry +Segment at 33:10 (count = 0), RegionEntry +Segment at 33:11 (count = 0), Skipped +Segment at 34:9 (count = 0), RegionEntry +Segment at 34:23 (count = 0), Skipped +Segment at 36:9 (count = 0), RegionEntry +Segment at 36:15 (count = 0), Skipped +Segment at 39:9 (count = 1), RegionEntry +Segment at 39:26 (count = 0), Skipped +Segment at 40:8 (count = 1), RegionEntry +Segment at 40:12 (count = 0), Skipped +Segment at 40:13 (count = 1), RegionEntry +Segment at 42:6 (count = 0), Skipped +Segment at 44:9 (count = 0), RegionEntry +Segment at 44:10 (count = 0), Skipped +Segment at 44:16 (count = 1), RegionEntry +Segment at 44:29 (count = 0), Skipped +Segment at 45:9 (count = 0), RegionEntry +Segment at 45:23 (count = 0), Skipped +Segment at 46:15 (count = 1), RegionEntry +Segment at 46:28 (count = 0), Skipped +Segment at 47:12 (count = 0), RegionEntry +Segment at 47:25 (count = 0), Skipped +Segment at 47:29 (count = 0), RegionEntry +Segment at 47:42 (count = 0), RegionEntry +Segment at 47:43 (count = 0), Skipped +Segment at 47:46 (count = 0), RegionEntry +Segment at 47:60 (count = 0), RegionEntry +Segment at 47:61 (count = 0), RegionEntry +Segment at 49:10 (count = 0), RegionEntry +Segment at 49:11 (count = 0), Skipped +Segment at 50:9 (count = 0), RegionEntry +Segment at 50:23 (count = 0), Skipped +Segment at 52:13 (count = 1), RegionEntry +Segment at 54:15 (count = 0), Skipped +Segment at 57:9 (count = 0), RegionEntry +Segment at 57:10 (count = 0), Skipped +Segment at 57:16 (count = 0), RegionEntry +Segment at 57:29 (count = 0), Skipped +Segment at 58:9 (count = 0), RegionEntry +Segment at 58:23 (count = 0), Skipped +Segment at 59:15 (count = 0), RegionEntry +Segment at 59:28 (count = 0), Skipped +Segment at 60:12 (count = 0), RegionEntry +Segment at 60:25 (count = 0), Skipped +Segment at 60:29 (count = 0), RegionEntry +Segment at 60:42 (count = 0), RegionEntry +Segment at 60:43 (count = 0), Skipped +Segment at 60:46 (count = 0), RegionEntry +Segment at 60:60 (count = 0), RegionEntry +Segment at 60:61 (count = 0), RegionEntry +Segment at 62:10 (count = 0), RegionEntry +Segment at 62:11 (count = 0), Skipped +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: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 new file mode 100644 index 00000000000..1aad1a3c83b --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt @@ -0,0 +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/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 4:6 -> 4:7, (#3 + 0) +Counter in file 0 5:1 -> 5:2, #4 +Emitting segments for file: ../coverage/while.rs +Combined regions: + 2:9 -> 2:16 (count=1) + 3:11 -> 3:20 (count=1) + 3:21 -> 4:6 (count=0) + 4:6 -> 4:7 (count=0) + 5:1 -> 5:2 (count=1) +Segment at 2:9 (count = 1), RegionEntry +Segment at 2:16 (count = 0), Skipped +Segment at 3:11 (count = 1), RegionEntry +Segment at 3:20 (count = 0), Skipped +Segment at 3:21 (count = 0), RegionEntry +Segment at 4:6 (count = 0), RegionEntry +Segment at 4:7 (count = 0), Skipped +Segment at 5:1 (count = 1), RegionEntry +Segment at 5:2 (count = 0), Skipped 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 new file mode 100644 index 00000000000..7c24ea22d67 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt @@ -0,0 +1,44 @@ +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 27:18 -> 27:19, (#5 + 0) +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 +Emitting segments for file: ../coverage/while_early_return.rs +Combined regions: + 5:9 -> 5:27 (count=1) + 7:9 -> 9:10 (count=7) + 12:13 -> 14:14 (count=7) + 18:21 -> 20:22 (count=1) + 22:21 -> 22:27 (count=0) + 26:21 -> 26:27 (count=1) + 27:18 -> 27:19 (count=0) + 30:9 -> 32:10 (count=6) + 35:5 -> 35:11 (count=0) + 36:1 -> 36:2 (count=2) +Segment at 5:9 (count = 1), RegionEntry +Segment at 5:27 (count = 0), Skipped +Segment at 7:9 (count = 7), RegionEntry +Segment at 9:10 (count = 0), Skipped +Segment at 12:13 (count = 7), RegionEntry +Segment at 14:14 (count = 0), Skipped +Segment at 18:21 (count = 1), RegionEntry +Segment at 20:22 (count = 0), Skipped +Segment at 22:21 (count = 0), RegionEntry +Segment at 22:27 (count = 0), Skipped +Segment at 26:21 (count = 1), RegionEntry +Segment at 26:27 (count = 0), Skipped +Segment at 27:18 (count = 0), RegionEntry +Segment at 27:19 (count = 0), Skipped +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:2 (count = 0), Skipped diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html index 43f75c574d0..0f076a93c09 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 35:13-35:26: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +36:21-38:10: @3[1]: _3 = const () +38:10-38:10: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +36:21-38:10: @3[1]: _3 = const () +38:10-38:10: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 2".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html index 8f07ec5fcde..bc78a604e31 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 77:13-77:26: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +78:21-80:10: @3[1]: _3 = const () +80:10-80:10: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +78:21-80:10: @3[1]: _3 = const () +80:10-80:10: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 4".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html index ca9031a1094..b0db2311730 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 20:21-20:34: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +21:29-23:18: @3[1]: _3 = const () +23:18-23:18: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +21:29-23:18: @3[1]: _3 = const () +23:18-23:18: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 1".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html index 820f8d9c6cf..ca07a8d3ce5 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 62:21-62:34: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +63:29-65:18: @3[1]: _3 = const () +65:18-65:18: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +63:29-65:18: @3[1]: _3 = const () +65:18-65:18: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 3".to_owned() - }⦉@4,5 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 494e6f20ea7..325b6c64345 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 -}@11⦊‸⦉@11 +}@1,3,4,5,9,10⦊‸⦉@1,3,4,5,9,10@2,6,7,8⦊‸⦉@2,6,7,8@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 6dc893d28ff..55d7e8bfbae 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 -}@14⦊‸⦉@14 +}@4,6,7,8,12,13⦊‸⦉@4,6,7,8,12,13@5,9,10,11⦊‸⦉@5,9,10,11@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html index 0379d900e94..0d4b940214e 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html @@ -146,17 +146,23 @@ @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> countdown = +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> = 10 +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> 10 ; +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> ; }⦉@4,6 -}@7⦊‸⦉@7 +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 +}@7⦊‸⦉@7 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 b51c5c84c0d..094dacde986 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 + }⦉@9@8,10⦊‸⦉@8,10 }@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html index 49639cc6884..7f1262a6abf 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html @@ -63,8 +63,7 @@ let @0⦊b = 1⦉@0; let @1,2,3,4⦊c⦉@1,2,3,4 = @0⦊a + b⦉@0; +20:21-20:22: @0[7]: _5 = _2">@0⦊a + b⦉@0; fn trait_func(&mut self, incr: u32) { - @0⦊self.in_struct_field += incr⦉@0; + self.in_struct_field += @0⦊incr⦉@0; @1,2⦊in_func(self.in_struct_field); diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html index 56557b8ef95..ec3517ec9ed 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html @@ -86,11 +86,14 @@ 9:9-9:22: @3[3]: FakeRead(ForLet, _5)"> let mut countdown = 0⦉@0,1,2,3; if @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown = 10; +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> countdown = 10; }⦉@4,6 +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 mod in_mod { const IN_MOD_CONST: u32 = 1000; @@ -126,16 +129,19 @@ type InType = String; - if @7⦊is_true⦉@7 if @7⦊is_true⦉@7 @8,10,11⦊{ -@8,10,11⦊{ + in_func(countdown); - in_func(countdown); + }⦉@8,10,11 +48:16-50:6: @11[2]: _8 = const () +50:6-50:6: @11.Goto: goto -> bb12"> }⦉@8,10,11@9⦊‸⦉@9 let // Initialize test constants in a way that cannot be determined at compile time, to ensure // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // dependent conditions. - let let @0,1,2,3⦊is_true = std::env::args().len() == 1; - -@0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7">@4,6⦊{ a = 1; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> a = 1; b = 10; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> b = 10; c = 100; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> c = 100; }⦉@4,6 +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 let - @11⦊somebool⦉@11 + @11⦊somebool⦉@11 = - @7⦊a < b⦉@7 || - @10⦊b < c⦉@10 +20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)">@10⦊b < c⦉@10@8⦊‸⦉@8@9⦊‸⦉@9 ; let - @15⦊somebool⦉@15 + @15⦊somebool⦉@15 = - @11⦊b < a⦉@11 || - @14⦊b < c⦉@14 +27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)">@14⦊b < c⦉@14@12⦊‸⦉@12@13⦊‸⦉@13 ; - let - @19⦊somebool⦉@19 - = - @15⦊a < b⦉@15 - && - @18⦊b < c⦉@18 - ; - let - @23⦊somebool⦉@23 - = - @19⦊b < a⦉@19 - && - @22⦊b < c⦉@22 - ; -}@23⦊‸⦉@23 + let @19⦊somebool⦉@19 = @15⦊a < b⦉@15 && @18⦊b < c⦉@18@16⦊‸⦉@16@17⦊‸⦉@17; + let @23⦊somebool⦉@23 = @19⦊b < a⦉@19 && @22⦊b < c⦉@22@20⦊‸⦉@20@21⦊‸⦉@21; + + if + @23⦊! + is_true⦉@23 + @24,26⦊{ + a = 2 + ; + }⦉@24,26@25⦊‸⦉@25 + + if + @27⦊is_true⦉@27 + @28,30⦊{ + b = 30 + ; + }⦉@28,30 + else + @29⦊{ + c = 400 + ; + }⦉@29@28,30⦊‸⦉@28,30 + + if @31⦊!is_true⦉@31 @32,34⦊{ + a = 2; + }⦉@32,34@33⦊‸⦉@33 + + if @35⦊is_true⦉@35 @36,38⦊{ + b = 30; + }⦉@36,38 else @37⦊{ + c = 400; + }⦉@37@36,38⦊‸⦉@36,38 +}@39⦊‸⦉@39 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a876c85822f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,151 @@ + + + +loops_and_branches.main - Coverage Spans + + + +
fn main() @0,1,2,3⦊{ + let debug_test = DebugTest; + println!("{:?}", debug_test); +}⦉@0,1,2,3
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..1b9767506f2 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html @@ -0,0 +1,94 @@ + + + +loops_and_branches.{impl#0}-fmt - Coverage Spans + + + +
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + if @0⦊true⦉@0 { + if @1,3⦊false⦉@1,3 { + while @6,7⦊true⦉@6,7 @8,10⦊{ + }⦉@8,10 + }@9⦊‸⦉@9@5⦊‸⦉@5 + @11,12,13,14⦊write!(f, "error")⦉@11,12,13,14@16,18,19,20⦊?⦉@16,18,19,20; + } else @2⦊{ + }⦉@2@15⦊‸⦉@15 + @21⦊Ok(())⦉@21 + }@16,18,19,20⦊‸⦉@16,18,19,20@22⦊‸⦉@22
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..042845b70cc --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,125 @@ + + + +nested_loops.main - Coverage Spans + + + +
fn main() { + let @0,1,2,3⦊is_true = std::env::args().len() == 1; + let mut countdown = 10⦉@0,1,2,3; + + 'outer: while @4,5⦊countdown > 0⦉@4,5 { + let @6,8,9⦊mut a = 100; + let mut b = 100⦉@6,8,9; + for @14,16⦊_⦉@14,16 in @10,11,12⦊0..50⦉@10,11,12 { + if @14,16⦊a < 30⦉@14,16 { + @17,19⦊break⦉@17,19; + } + @20⦊a -= 5⦉@20; + @21⦊b -= 5⦉@21; + if @21⦊b < 90⦉@21 { + @25⦊a -= 10; + if is_true⦉@25 { + @26,28⦊break 'outer⦉@26,28; + } else { + @29⦊a -= 2; + } + }⦉@29@23⦊‸⦉@23 + }@6,8,9⦊‸⦉@6,8,9@30⦊‸⦉@30 + @32⦊countdown -= 1⦉@32; + }@0,1,2,3⦊‸⦉@0,1,2,3@7⦊‸⦉@7 +}@33⦊‸⦉@33
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..3ebe51bc7ec --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,285 @@ + + + +partial_eq_counter_without_region.main - Coverage Spans + + + +
fn main() @0,1,2,3,4,5,6,7,8⦊{ + let version_3_2_1 = Version::new(3, 2, 1); + let version_3_3_0 = Version::new(3, 3, 0); + + println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); +}⦉@0,1,2,3,4,5,6,7,8
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ee6a5489f26 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html @@ -0,0 +1,94 @@ + + + +partial_eq_counter_without_region.{impl#0}-new - Coverage Spans + + + +
pub fn new(major: usize, minor: usize, patch: usize) -> Self { + @0⦊Self { + major, + minor, + patch, + } + }⦉@0
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a39772288a3 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html @@ -0,0 +1,70 @@ + + + +partial_eq_counter_without_region.{impl#1}-cmp - Coverage Spans + + + +
@14⦊@11,12⦊@10⦊@13⦊Ord⦉@13⦉@10⦉@11,12⦉@14@15⦊‸⦉@15
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..671cbea0ff3 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..6da79c4b130 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..5f5c31ce775 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..fbdd0f7db42 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..736f2034333 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..0fec7c9932f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ff4eba10789 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ccc86a7f92f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-le-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..682b9112c4c --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-le - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..e018c96c24f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a10032059b5 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..89dad0f9069 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..2c03e967eeb --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-partial_cmp - Coverage Spans + + + +
@17⦊@14,15⦊@12⦊@16⦊PartialOrd⦉@16⦉@12⦉@14,15⦉@17@18⦊‸⦉@18
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..49d73b3457b --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html @@ -0,0 +1,65 @@ + + + +partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq - Coverage Spans + + + +
@0⦊Eq⦉@0
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..bc34080f109 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html @@ -0,0 +1,67 @@ + + + +partial_eq_counter_without_region.{impl#6}-eq - Coverage Spans + + + +
@2⦊@1⦊PartialEq⦉@1⦉@2@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..376c8dd80d0 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html @@ -0,0 +1,71 @@ + + + +partial_eq_counter_without_region.{impl#6}-ne - Coverage Spans + + + +
@2⦊@5⦊@6⦊@1⦊PartialEq⦉@1⦉@6⦉@5⦉@2@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..c3fed16a3b4 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html @@ -0,0 +1,99 @@ + + + +partial_eq_counter_without_region.{impl#7}-fmt - Coverage Spans + + + +
@0,1,2,3,4,5⦊Debug⦉@0,1,2,3,4,5
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..6a4f11e0754 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html @@ -0,0 +1,78 @@ + + + +partial_eq_counter_without_region.{impl#8}-clone - Coverage Spans + + + +
@0,1,2,3⦊Clone⦉@0,1,2,3
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html index 4b21d3fc263..618f84513e9 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html @@ -89,39 +89,45 @@ @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> countdown = +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> = 10 +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> 10 ; +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> ; }⦉@4,6 +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 loop { if - @8,9⦊countdown - == - 0⦉@8,9 { - @10,12⦊break⦉@10,12 + @10,12⦊break⦉@10,12 ; } - @11⦊countdown - -= - 1⦉@11 + @13⦊countdown + -= + 1⦉@13 ; - } + }@7⦊‸⦉@7 }@10,12⦊‸⦉@10,12 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html index 5ba770ef607..66885d0612b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html @@ -86,51 +86,39 @@ 9:9-9:22: @3[3]: FakeRead(ForLet, _5)"> let mut countdown = 1⦉@0,1,2,3; if @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown = 0; +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> countdown = 0; }⦉@4,6 +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 - @9,10,11⦊for - _⦉@9,10,11 + for + @13,15,17⦊_⦉@13,15,17 in - @7,8⦊0..2⦉@7,8 + @9,10,11⦊0..2⦉@9,10,11 { let z ; match - @13,15,17⦊countdown - { - x - if - x - @13,15,17⦊countdown⦉@13,15,17 + { + @18⦊x⦉@18 + if + @13,15,17⦊x + < - 1⦉@13,15,17 + 1⦉@13,15,17@19⦊‸⦉@19 => => @16⦊{}⦉@16 } - } + }@7,8⦊‸⦉@7,8@20⦊‸⦉@20 }@12⦊‸⦉@12 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..db08315baa6 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,70 @@ + + + +tight_infinite_loop.main - Coverage Spans + + + +
fn main() { + if @0⦊false⦉@0 { + @4,5⦊loop {}⦉@4,5@1,3⦊‸⦉@1,3@4,5⦊‸⦉@4,5 + } +}@2⦊‸⦉@2
+ + 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 9f993342340..8a0b1ae8dab 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 - } -}@4⦊‸⦉@4 + }@1,3⦊‸⦉@1,3 +}@4⦊‸⦉@4 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html index 660c3031f35..428c6fadc27 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html @@ -65,37 +65,51 @@ countdown = 10⦉@0,1 ; - @2,3,4⦊for - _⦉@2,3,4 + for + @6,8⦊_⦉@6,8 in - @0,1⦊0..10⦉@0,1 + @2,3,4⦊0..10⦉@2,3,4 { - @6,8⦊countdown - -= 1⦉@6,8 - ; - if - @9⦊countdown < 5⦉@9 +25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">@9⦊countdown + -= 1 + ; + if + countdown < 5⦉@9 { - @10,12,13,14⦊call(/*return_error=*/ true)?⦉@10,12,13,14; + @10,12,13,14⦊call(/*return_error=*/ true)⦉@10,12,13,14@16,18,19,20⦊?⦉@16,18,19,20; } else { - @11,21,22⦊call(/*return_error=*/ false)?⦉@11,21,22; - } - } - @11,21,22⦊call(/*return_error=*/ false)⦉@11,21,22@24,26,27,28⦊?⦉@24,26,27,28; + }@15⦊‸⦉@15@23⦊‸⦉@23 + }@0,1⦊‸⦉@0,1@29⦊‸⦉@29 + @5⦊Ok(())⦉@5 -}@31⦊‸⦉@31 +}@30⦊‸⦉@30@31⦊‸⦉@31 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html index 28f1d013c83..b9f6f4d7832 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html @@ -64,32 +64,42 @@ 4:9-4:22: @0[2]: FakeRead(ForLet, _1)">@0⦊mut countdown = 0⦉@0; if @0⦊true⦉@0 @1,3⦊{ +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4"> }⦉@1,3@2⦊‸⦉@2 const B: u32 = 100; - let @25⦊x⦉@25 = if let @25⦊x⦉@25 = if @4⦊countdown > 7⦉@4 { - @5,7⦊countdown -= 4⦉@5,7; - @8⦊B⦉@8 + @8⦊countdown -= 4; + B⦉@8 } else if @6⦊countdown > 2⦉@6 { if @9,11⦊countdown < 1⦉@9,11 || @18⦊countdown > 5⦉@18 || @14⦊countdown != 9⦉@14 @20,22⦊{ +14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)">@18⦊countdown > 5⦉@18@16⦊‸⦉@16@17⦊‸⦉@17 || @14⦊countdown != 9⦉@14@12⦊‸⦉@12@13⦊‸⦉@13 @20,22⦊{ countdown = 0; +14:61-16:10: @22[1]: _10 = const () +16:10-16:10: @22.Goto: goto -> bb23"> countdown = 0; }⦉@20,22 - @23⦊countdown -= 5⦉@23; - @24⦊countdown⦉@24 +14:61-16:10: @22[1]: _10 = const () +16:10-16:10: @22.Goto: goto -> bb23"> }⦉@20,22@21⦊‸⦉@21 + @24⦊countdown -= 5; + countdown⦉@24 } else { @10⦊return⦉@10; }; @@ -98,29 +108,35 @@ 23:9-23:22: @25[4]: FakeRead(ForLet, _21)">@25⦊mut countdown = 0⦉@25; if @25⦊true⦉@25 @26,28⦊{ +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29">@26,28⦊{ countdown = 10; +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29"> countdown = 10; }⦉@26,28 +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29"> }⦉@26,28@27⦊‸⦉@27 - if if @29⦊countdown > 7⦉@29 { - @30,32⦊countdown -= 4⦉@30,32; - } else if @33⦊countdown -= 4⦉@33; + } else if @31⦊countdown > 2⦉@31 { - if @34,36⦊countdown < 1⦉@34,36 || @43⦊countdown > 5⦉@43 || @39⦊countdown != 9⦉@39 @45,47⦊{ - countdown = 0; - }⦉@45,47 - @48⦊countdown -= 5⦉@48; + if @34,36⦊countdown < 1⦉@34,36 || @43⦊countdown > 5⦉@43@41⦊‸⦉@41@42⦊‸⦉@42 || @39⦊countdown != 9⦉@39@37⦊‸⦉@37@38⦊‸⦉@38 @45,47⦊{ + countdown = 0; + }⦉@45,47@46⦊‸⦉@46 + @49⦊countdown -= 5⦉@49; } else { @35⦊return⦉@35; } @@ -129,29 +145,35 @@ 39:9-39:22: @50[4]: FakeRead(ForLet, _41)">@50⦊mut countdown = 0⦉@50; if @50⦊true⦉@50 @51,53⦊{ +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54">@51,53⦊{ countdown = 1; +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54"> countdown = 1; }⦉@51,53 +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54"> }⦉@51,53@52⦊‸⦉@52 - let @77⦊z⦉@77 = if let @77⦊z⦉@77 = if @54⦊countdown > 7⦉@54 { - @55,57⦊countdown -= 4⦉@55,57; - } else if @58⦊countdown -= 4⦉@58; + } else if @56⦊countdown > 2⦉@56 { - if @59,61⦊countdown < 1⦉@59,61 || @68⦊countdown > 5⦉@68 || @64⦊countdown != 9⦉@64 @70,72⦊{ - countdown = 0; - }⦉@70,72 - @73⦊countdown -= 5⦉@73; + if @59,61⦊countdown < 1⦉@59,61 || @68⦊countdown > 5⦉@68@66⦊‸⦉@66@67⦊‸⦉@67 || @64⦊countdown != 9⦉@64@62⦊‸⦉@62@63⦊‸⦉@63 @70,72⦊{ + countdown = 0; + }⦉@70,72@71⦊‸⦉@71 + @74⦊countdown -= 5⦉@74; } else { let let @98⦊w⦉@98 = if @77⦊countdown > 7⦉@77 { - @78,80⦊countdown -= 4⦉@78,80; + @81⦊countdown -= 4⦉@81; } else if @79⦊countdown > 2⦉@79 { if @82,84⦊countdown < 1⦉@82,84 || @91⦊countdown > 5⦉@91 || @87⦊countdown != 9⦉@87 @93,95⦊{ +60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)">@91⦊countdown > 5⦉@91@89⦊‸⦉@89@90⦊‸⦉@90 || @87⦊countdown != 9⦉@87@85⦊‸⦉@85@86⦊‸⦉@86 @93,95⦊{ countdown = 0; +60:61-62:10: @95[1]: _80 = const () +62:10-62:10: @95.Goto: goto -> bb96"> countdown = 0; }⦉@93,95 - @96⦊countdown -= 5⦉@96; +60:61-62:10: @95[1]: _80 = const () +62:10-62:10: @95.Goto: goto -> bb96"> }⦉@93,95@94⦊‸⦉@94 + @97⦊countdown -= 5⦉@97; } else { - @83⦊return⦉@83; + @83⦊return⦉@83; }; -}@102⦊‸⦉@102 +}@101⦊‸⦉@101@102⦊‸⦉@102 diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..5c49ec19707 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,71 @@ + + + +while.main - Coverage Spans + + + +
fn main() { + let @0⦊num = 9⦉@0; + while @1,2⦊num >= 10⦉@1,2 @3,5⦊{ + }⦉@3,5@3,5⦊‸⦉@3,5 +}@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html index b96789a9219..be674dc7d38 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html @@ -62,12 +62,10 @@
fn main() -> Result<(),u8> { let @0⦊mut countdown = 10⦉@0; - while + @1,2⦊while - countdown +7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">@1,2⦊countdown > @@ -104,16 +102,16 @@ else { @10⦊Err(1)⦉@10 - } + }@9,11⦊‸⦉@9,11 ; } - @7⦊countdown - -= - 1⦉@7 + @12⦊countdown + -= + 1⦉@12 ; } - @4⦊Ok(())⦉@4 -}@14⦊‸⦉@14
+}@13⦊‸⦉@13@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html index 43f75c574d0..0f076a93c09 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 35:13-35:26: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +36:21-38:10: @3[1]: _3 = const () +38:10-38:10: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +36:21-38:10: @3[1]: _3 = const () +38:10-38:10: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 2".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html index 8f07ec5fcde..bc78a604e31 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 77:13-77:26: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +78:21-80:10: @3[1]: _3 = const () +80:10-80:10: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +78:21-80:10: @3[1]: _3 = const () +80:10-80:10: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 4".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html index ca9031a1094..b0db2311730 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 20:21-20:34: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +21:29-23:18: @3[1]: _3 = const () +23:18-23:18: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +21:29-23:18: @3[1]: _3 = const () +23:18-23:18: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 1".to_owned() - }⦉@4,5 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html index 820f8d9c6cf..ca07a8d3ce5 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html @@ -65,16 +65,19 @@ 62:21-62:34: @0[2]: FakeRead(ForLet, _2)">@0⦊mut countdown = 0⦉@0; if @0⦊is_false⦉@0 @1,3⦊{ +63:29-65:18: @3[1]: _3 = const () +65:18-65:18: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +63:29-65:18: @3[1]: _3 = const () +65:18-65:18: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 - }⦉@1,3@2⦊‸⦉@2 + @4,5⦊"alt string 3".to_owned() - }⦉@4,5 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 494e6f20ea7..325b6c64345 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 -}@11⦊‸⦉@11 +}@1,3,4,5,9,10⦊‸⦉@1,3,4,5,9,10@2,6,7,8⦊‸⦉@2,6,7,8@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 6dc893d28ff..55d7e8bfbae 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 -}@14⦊‸⦉@14 +}@4,6,7,8,12,13⦊‸⦉@4,6,7,8,12,13@5,9,10,11⦊‸⦉@5,9,10,11@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html index 0379d900e94..0d4b940214e 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html @@ -146,17 +146,23 @@ @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> countdown = +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> = 10 +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> 10 ; +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> ; }⦉@4,6 -}@7⦊‸⦉@7 +22:5-27:6: @6[1]: _0 = const () +27:6-27:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 +}@7⦊‸⦉@7 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 b51c5c84c0d..094dacde986 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 + }⦉@9@8,10⦊‸⦉@8,10 }@11⦊‸⦉@11 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html index 49639cc6884..7f1262a6abf 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html @@ -63,8 +63,7 @@ let @0⦊b = 1⦉@0; let @1,2,3,4⦊c⦉@1,2,3,4 = @0⦊a + b⦉@0; +20:21-20:22: @0[7]: _5 = _2">@0⦊a + b⦉@0; fn trait_func(&mut self, incr: u32) { - @0⦊self.in_struct_field += incr⦉@0; + self.in_struct_field += @0⦊incr⦉@0; @1,2⦊in_func(self.in_struct_field); diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html index 56557b8ef95..ec3517ec9ed 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html @@ -86,11 +86,14 @@ 9:9-9:22: @3[3]: FakeRead(ForLet, _5)"> let mut countdown = 0⦉@0,1,2,3; if @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown = 10; +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> countdown = 10; }⦉@4,6 +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 mod in_mod { const IN_MOD_CONST: u32 = 1000; @@ -126,16 +129,19 @@ type InType = String; - if @7⦊is_true⦉@7 if @7⦊is_true⦉@7 @8,10,11⦊{ -@8,10,11⦊{ + in_func(countdown); - in_func(countdown); + }⦉@8,10,11 +48:16-50:6: @11[2]: _8 = const () +50:6-50:6: @11.Goto: goto -> bb12"> }⦉@8,10,11@9⦊‸⦉@9 let // Initialize test constants in a way that cannot be determined at compile time, to ensure // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // dependent conditions. - let let @0,1,2,3⦊is_true = std::env::args().len() == 1; - -@0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7">@4,6⦊{ a = 1; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> a = 1; b = 10; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> b = 10; c = 100; +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> c = 100; }⦉@4,6 +10:16-14:6: @6[3]: _9 = const () +14:6-14:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 let - @11⦊somebool⦉@11 + @11⦊somebool⦉@11 = - @7⦊a < b⦉@7 || - @10⦊b < c⦉@10 +20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)">@10⦊b < c⦉@10@8⦊‸⦉@8@9⦊‸⦉@9 ; let - @15⦊somebool⦉@15 + @15⦊somebool⦉@15 = - @11⦊b < a⦉@11 || - @14⦊b < c⦉@14 +27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)">@14⦊b < c⦉@14@12⦊‸⦉@12@13⦊‸⦉@13 ; - let - @19⦊somebool⦉@19 - = - @15⦊a < b⦉@15 - && - @18⦊b < c⦉@18 - ; - let - @23⦊somebool⦉@23 - = - @19⦊b < a⦉@19 - && - @22⦊b < c⦉@22 - ; -}@23⦊‸⦉@23 + let @19⦊somebool⦉@19 = @15⦊a < b⦉@15 && @18⦊b < c⦉@18@16⦊‸⦉@16@17⦊‸⦉@17; + let @23⦊somebool⦉@23 = @19⦊b < a⦉@19 && @22⦊b < c⦉@22@20⦊‸⦉@20@21⦊‸⦉@21; + + if + @23⦊! + is_true⦉@23 + @24,26⦊{ + a = 2 + ; + }⦉@24,26@25⦊‸⦉@25 + + if + @27⦊is_true⦉@27 + @28,30⦊{ + b = 30 + ; + }⦉@28,30 + else + @29⦊{ + c = 400 + ; + }⦉@29@28,30⦊‸⦉@28,30 + + if @31⦊!is_true⦉@31 @32,34⦊{ + a = 2; + }⦉@32,34@33⦊‸⦉@33 + + if @35⦊is_true⦉@35 @36,38⦊{ + b = 30; + }⦉@36,38 else @37⦊{ + c = 400; + }⦉@37@36,38⦊‸⦉@36,38 +}@39⦊‸⦉@39 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a876c85822f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,151 @@ + + + +loops_and_branches.main - Coverage Spans + + + +
fn main() @0,1,2,3⦊{ + let debug_test = DebugTest; + println!("{:?}", debug_test); +}⦉@0,1,2,3
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..1b9767506f2 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html @@ -0,0 +1,94 @@ + + + +loops_and_branches.{impl#0}-fmt - Coverage Spans + + + +
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + if @0⦊true⦉@0 { + if @1,3⦊false⦉@1,3 { + while @6,7⦊true⦉@6,7 @8,10⦊{ + }⦉@8,10 + }@9⦊‸⦉@9@5⦊‸⦉@5 + @11,12,13,14⦊write!(f, "error")⦉@11,12,13,14@16,18,19,20⦊?⦉@16,18,19,20; + } else @2⦊{ + }⦉@2@15⦊‸⦉@15 + @21⦊Ok(())⦉@21 + }@16,18,19,20⦊‸⦉@16,18,19,20@22⦊‸⦉@22
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..042845b70cc --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,125 @@ + + + +nested_loops.main - Coverage Spans + + + +
fn main() { + let @0,1,2,3⦊is_true = std::env::args().len() == 1; + let mut countdown = 10⦉@0,1,2,3; + + 'outer: while @4,5⦊countdown > 0⦉@4,5 { + let @6,8,9⦊mut a = 100; + let mut b = 100⦉@6,8,9; + for @14,16⦊_⦉@14,16 in @10,11,12⦊0..50⦉@10,11,12 { + if @14,16⦊a < 30⦉@14,16 { + @17,19⦊break⦉@17,19; + } + @20⦊a -= 5⦉@20; + @21⦊b -= 5⦉@21; + if @21⦊b < 90⦉@21 { + @25⦊a -= 10; + if is_true⦉@25 { + @26,28⦊break 'outer⦉@26,28; + } else { + @29⦊a -= 2; + } + }⦉@29@23⦊‸⦉@23 + }@6,8,9⦊‸⦉@6,8,9@30⦊‸⦉@30 + @32⦊countdown -= 1⦉@32; + }@0,1,2,3⦊‸⦉@0,1,2,3@7⦊‸⦉@7 +}@33⦊‸⦉@33
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..3ebe51bc7ec --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,285 @@ + + + +partial_eq_counter_without_region.main - Coverage Spans + + + +
fn main() @0,1,2,3,4,5,6,7,8⦊{ + let version_3_2_1 = Version::new(3, 2, 1); + let version_3_3_0 = Version::new(3, 3, 0); + + println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); +}⦉@0,1,2,3,4,5,6,7,8
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ee6a5489f26 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html @@ -0,0 +1,94 @@ + + + +partial_eq_counter_without_region.{impl#0}-new - Coverage Spans + + + +
pub fn new(major: usize, minor: usize, patch: usize) -> Self { + @0⦊Self { + major, + minor, + patch, + } + }⦉@0
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a39772288a3 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html @@ -0,0 +1,70 @@ + + + +partial_eq_counter_without_region.{impl#1}-cmp - Coverage Spans + + + +
@14⦊@11,12⦊@10⦊@13⦊Ord⦉@13⦉@10⦉@11,12⦉@14@15⦊‸⦉@15
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..671cbea0ff3 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..6da79c4b130 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..5f5c31ce775 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-ge - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..fbdd0f7db42 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..736f2034333 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..0fec7c9932f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-gt - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ff4eba10789 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..ccc86a7f92f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-le-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..682b9112c4c --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-le - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..e018c96c24f --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0} - Coverage Spans + + + +
minor: usize, + @0,1,2⦊patch: usize⦉@0,1,2
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..a10032059b5 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html @@ -0,0 +1,73 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt-{closure#0} - Coverage Spans + + + +
major: usize, + @0,1,2,3⦊‸⦉@0,1,2,3minor: usize
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..89dad0f9069 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html @@ -0,0 +1,82 @@ + + + +partial_eq_counter_without_region.{impl#2}-lt - Coverage Spans + + + +
@0,1,2,3,4⦊‸⦉@0,1,2,3,4PartialOrd@0,1,2,3,4⦊‸⦉@0,1,2,3,4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..2c03e967eeb --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html @@ -0,0 +1,72 @@ + + + +partial_eq_counter_without_region.{impl#2}-partial_cmp - Coverage Spans + + + +
@17⦊@14,15⦊@12⦊@16⦊PartialOrd⦉@16⦉@12⦉@14,15⦉@17@18⦊‸⦉@18
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..49d73b3457b --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html @@ -0,0 +1,65 @@ + + + +partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq - Coverage Spans + + + +
@0⦊Eq⦉@0
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..bc34080f109 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html @@ -0,0 +1,67 @@ + + + +partial_eq_counter_without_region.{impl#6}-eq - Coverage Spans + + + +
@2⦊@1⦊PartialEq⦉@1⦉@2@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..376c8dd80d0 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html @@ -0,0 +1,71 @@ + + + +partial_eq_counter_without_region.{impl#6}-ne - Coverage Spans + + + +
@2⦊@5⦊@6⦊@1⦊PartialEq⦉@1⦉@6⦉@5⦉@2@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..c3fed16a3b4 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html @@ -0,0 +1,99 @@ + + + +partial_eq_counter_without_region.{impl#7}-fmt - Coverage Spans + + + +
@0,1,2,3,4,5⦊Debug⦉@0,1,2,3,4,5
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..6a4f11e0754 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html @@ -0,0 +1,78 @@ + + + +partial_eq_counter_without_region.{impl#8}-clone - Coverage Spans + + + +
@0,1,2,3⦊Clone⦉@0,1,2,3
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html index 4b21d3fc263..618f84513e9 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html @@ -89,39 +89,45 @@ @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> countdown = +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> = 10 +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> 10 ; +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> ; }⦉@4,6 +13:5-18:6: @6[1]: _6 = const () +18:6-18:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 loop { if - @8,9⦊countdown - == - 0⦉@8,9 { - @10,12⦊break⦉@10,12 + @10,12⦊break⦉@10,12 ; } - @11⦊countdown - -= - 1⦉@11 + @13⦊countdown + -= + 1⦉@13 ; - } + }@7⦊‸⦉@7 }@10,12⦊‸⦉@10,12 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html index 5ba770ef607..66885d0612b 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html @@ -86,51 +86,39 @@ 9:9-9:22: @3[3]: FakeRead(ForLet, _5)"> let mut countdown = 1⦉@0,1,2,3; if @0,1,2,3⦊is_true⦉@0,1,2,3 @4,6⦊{ +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7">@4,6⦊{ countdown = 0; +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> countdown = 0; }⦉@4,6 +10:16-12:6: @6[1]: _6 = const () +12:6-12:6: @6.Goto: goto -> bb7"> }⦉@4,6@5⦊‸⦉@5 - @9,10,11⦊for - _⦉@9,10,11 + for + @13,15,17⦊_⦉@13,15,17 in - @7,8⦊0..2⦉@7,8 + @9,10,11⦊0..2⦉@9,10,11 { let z ; match - @13,15,17⦊countdown - { - x - if - x - @13,15,17⦊countdown⦉@13,15,17 + { + @18⦊x⦉@18 + if + @13,15,17⦊x + < - 1⦉@13,15,17 + 1⦉@13,15,17@19⦊‸⦉@19 => => @16⦊{}⦉@16 } - } + }@7,8⦊‸⦉@7,8@20⦊‸⦉@20 }@12⦊‸⦉@12 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..db08315baa6 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,70 @@ + + + +tight_infinite_loop.main - Coverage Spans + + + +
fn main() { + if @0⦊false⦉@0 { + @4,5⦊loop {}⦉@4,5@1,3⦊‸⦉@1,3@4,5⦊‸⦉@4,5 + } +}@2⦊‸⦉@2
+ + 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 9f993342340..8a0b1ae8dab 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 - } -}@4⦊‸⦉@4 + }@1,3⦊‸⦉@1,3 +}@4⦊‸⦉@4 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html index 660c3031f35..428c6fadc27 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html @@ -65,37 +65,51 @@ countdown = 10⦉@0,1 ; - @2,3,4⦊for - _⦉@2,3,4 + for + @6,8⦊_⦉@6,8 in - @0,1⦊0..10⦉@0,1 + @2,3,4⦊0..10⦉@2,3,4 { - @6,8⦊countdown - -= 1⦉@6,8 - ; - if - @9⦊countdown < 5⦉@9 +25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">@9⦊countdown + -= 1 + ; + if + countdown < 5⦉@9 { - @10,12,13,14⦊call(/*return_error=*/ true)?⦉@10,12,13,14; + @10,12,13,14⦊call(/*return_error=*/ true)⦉@10,12,13,14@16,18,19,20⦊?⦉@16,18,19,20; } else { - @11,21,22⦊call(/*return_error=*/ false)?⦉@11,21,22; - } - } - @11,21,22⦊call(/*return_error=*/ false)⦉@11,21,22@24,26,27,28⦊?⦉@24,26,27,28; + }@15⦊‸⦉@15@23⦊‸⦉@23 + }@0,1⦊‸⦉@0,1@29⦊‸⦉@29 + @5⦊Ok(())⦉@5 -}@31⦊‸⦉@31 +}@30⦊‸⦉@30@31⦊‸⦉@31 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html index 28f1d013c83..b9f6f4d7832 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html @@ -64,32 +64,42 @@ 4:9-4:22: @0[2]: FakeRead(ForLet, _1)">@0⦊mut countdown = 0⦉@0; if @0⦊true⦉@0 @1,3⦊{ +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4">@1,3⦊{ countdown = 10; +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4"> countdown = 10; }⦉@1,3 +5:13-7:6: @3[1]: _2 = const () +7:6-7:6: @3.Goto: goto -> bb4"> }⦉@1,3@2⦊‸⦉@2 const B: u32 = 100; - let @25⦊x⦉@25 = if let @25⦊x⦉@25 = if @4⦊countdown > 7⦉@4 { - @5,7⦊countdown -= 4⦉@5,7; - @8⦊B⦉@8 + @8⦊countdown -= 4; + B⦉@8 } else if @6⦊countdown > 2⦉@6 { if @9,11⦊countdown < 1⦉@9,11 || @18⦊countdown > 5⦉@18 || @14⦊countdown != 9⦉@14 @20,22⦊{ +14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)">@18⦊countdown > 5⦉@18@16⦊‸⦉@16@17⦊‸⦉@17 || @14⦊countdown != 9⦉@14@12⦊‸⦉@12@13⦊‸⦉@13 @20,22⦊{ countdown = 0; +14:61-16:10: @22[1]: _10 = const () +16:10-16:10: @22.Goto: goto -> bb23"> countdown = 0; }⦉@20,22 - @23⦊countdown -= 5⦉@23; - @24⦊countdown⦉@24 +14:61-16:10: @22[1]: _10 = const () +16:10-16:10: @22.Goto: goto -> bb23"> }⦉@20,22@21⦊‸⦉@21 + @24⦊countdown -= 5; + countdown⦉@24 } else { @10⦊return⦉@10; }; @@ -98,29 +108,35 @@ 23:9-23:22: @25[4]: FakeRead(ForLet, _21)">@25⦊mut countdown = 0⦉@25; if @25⦊true⦉@25 @26,28⦊{ +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29">@26,28⦊{ countdown = 10; +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29"> countdown = 10; }⦉@26,28 +24:13-26:6: @28[1]: _22 = const () +26:6-26:6: @28.Goto: goto -> bb29"> }⦉@26,28@27⦊‸⦉@27 - if if @29⦊countdown > 7⦉@29 { - @30,32⦊countdown -= 4⦉@30,32; - } else if @33⦊countdown -= 4⦉@33; + } else if @31⦊countdown > 2⦉@31 { - if @34,36⦊countdown < 1⦉@34,36 || @43⦊countdown > 5⦉@43 || @39⦊countdown != 9⦉@39 @45,47⦊{ - countdown = 0; - }⦉@45,47 - @48⦊countdown -= 5⦉@48; + if @34,36⦊countdown < 1⦉@34,36 || @43⦊countdown > 5⦉@43@41⦊‸⦉@41@42⦊‸⦉@42 || @39⦊countdown != 9⦉@39@37⦊‸⦉@37@38⦊‸⦉@38 @45,47⦊{ + countdown = 0; + }⦉@45,47@46⦊‸⦉@46 + @49⦊countdown -= 5⦉@49; } else { @35⦊return⦉@35; } @@ -129,29 +145,35 @@ 39:9-39:22: @50[4]: FakeRead(ForLet, _41)">@50⦊mut countdown = 0⦉@50; if @50⦊true⦉@50 @51,53⦊{ +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54">@51,53⦊{ countdown = 1; +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54"> countdown = 1; }⦉@51,53 +40:13-42:6: @53[1]: _42 = const () +42:6-42:6: @53.Goto: goto -> bb54"> }⦉@51,53@52⦊‸⦉@52 - let @77⦊z⦉@77 = if let @77⦊z⦉@77 = if @54⦊countdown > 7⦉@54 { - @55,57⦊countdown -= 4⦉@55,57; - } else if @58⦊countdown -= 4⦉@58; + } else if @56⦊countdown > 2⦉@56 { - if @59,61⦊countdown < 1⦉@59,61 || @68⦊countdown > 5⦉@68 || @64⦊countdown != 9⦉@64 @70,72⦊{ - countdown = 0; - }⦉@70,72 - @73⦊countdown -= 5⦉@73; + if @59,61⦊countdown < 1⦉@59,61 || @68⦊countdown > 5⦉@68@66⦊‸⦉@66@67⦊‸⦉@67 || @64⦊countdown != 9⦉@64@62⦊‸⦉@62@63⦊‸⦉@63 @70,72⦊{ + countdown = 0; + }⦉@70,72@71⦊‸⦉@71 + @74⦊countdown -= 5⦉@74; } else { let let @98⦊w⦉@98 = if @77⦊countdown > 7⦉@77 { - @78,80⦊countdown -= 4⦉@78,80; + @81⦊countdown -= 4⦉@81; } else if @79⦊countdown > 2⦉@79 { if @82,84⦊countdown < 1⦉@82,84 || @91⦊countdown > 5⦉@91 || @87⦊countdown != 9⦉@87 @93,95⦊{ +60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)">@91⦊countdown > 5⦉@91@89⦊‸⦉@89@90⦊‸⦉@90 || @87⦊countdown != 9⦉@87@85⦊‸⦉@85@86⦊‸⦉@86 @93,95⦊{ countdown = 0; +60:61-62:10: @95[1]: _80 = const () +62:10-62:10: @95.Goto: goto -> bb96"> countdown = 0; }⦉@93,95 - @96⦊countdown -= 5⦉@96; +60:61-62:10: @95[1]: _80 = const () +62:10-62:10: @95.Goto: goto -> bb96"> }⦉@93,95@94⦊‸⦉@94 + @97⦊countdown -= 5⦉@97; } else { - @83⦊return⦉@83; + @83⦊return⦉@83; }; -}@102⦊‸⦉@102 +}@101⦊‸⦉@101@102⦊‸⦉@102 diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html new file mode 100644 index 00000000000..5c49ec19707 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html @@ -0,0 +1,71 @@ + + + +while.main - Coverage Spans + + + +
fn main() { + let @0⦊num = 9⦉@0; + while @1,2⦊num >= 10⦉@1,2 @3,5⦊{ + }⦉@3,5@3,5⦊‸⦉@3,5 +}@4⦊‸⦉@4
+ + diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html index b96789a9219..be674dc7d38 100644 --- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html +++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html @@ -62,12 +62,10 @@
fn main() -> Result<(),u8> { let @0⦊mut countdown = 10⦉@0; - while + @1,2⦊while - countdown +7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">@1,2⦊countdown > @@ -104,16 +102,16 @@ else { @10⦊Err(1)⦉@10 - } + }@9,11⦊‸⦉@9,11 ; } - @7⦊countdown - -= - 1⦉@7 + @12⦊countdown + -= + 1⦉@12 ; } - @4⦊Ok(())⦉@4 -}@14⦊‸⦉@14
+}@13⦊‸⦉@13@14⦊‸⦉@14 diff --git a/src/test/run-make-fulldeps/coverage/lazy_boolean.rs b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs index 1d83eb30dea..bb6219e851c 100644 --- a/src/test/run-make-fulldeps/coverage/lazy_boolean.rs +++ b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs @@ -26,18 +26,36 @@ fn main() { || b < c ; - let - somebool - = - a < b - && - b < c - ; - let - somebool - = - b < a - && - b < c - ; + let somebool = a < b && b < c; + let somebool = b < a && b < c; + + if + ! + is_true + { + a = 2 + ; + } + + if + is_true + { + b = 30 + ; + } + else + { + c = 400 + ; + } + + if !is_true { + a = 2; + } + + if is_true { + b = 30; + } else { + c = 400; + } } diff --git a/src/test/run-make-fulldeps/coverage/loops_and_branches.rs b/src/test/run-make-fulldeps/coverage/loops_and_branches.rs new file mode 100644 index 00000000000..a9df7e0fab7 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage/loops_and_branches.rs @@ -0,0 +1,36 @@ +#![allow(unused_assignments)] + +// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the +// structure of this `fmt` function. + +struct DebugTest; + +impl std::fmt::Debug for DebugTest { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + if true { + if false { + while true { + } + } + write!(f, "error")?; + } else { + } + Ok(()) + } +} + +fn main() { + let debug_test = DebugTest; + println!("{:?}", debug_test); +} + +/* + +This is the error message generated, before the issue was fixed: + +error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42: +Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt): +Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s: +[bcb6, bcb7, bcb9]" } + +*/ diff --git a/src/test/run-make-fulldeps/coverage/nested_loops.rs b/src/test/run-make-fulldeps/coverage/nested_loops.rs new file mode 100644 index 00000000000..4c7c7842796 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage/nested_loops.rs @@ -0,0 +1,25 @@ +fn main() { + let is_true = std::env::args().len() == 1; + let mut countdown = 10; + + 'outer: while countdown > 0 { + let mut a = 100; + let mut b = 100; + for _ in 0..50 { + if a < 30 { + break; + } + a -= 5; + b -= 5; + if b < 90 { + a -= 10; + if is_true { + break 'outer; + } else { + a -= 2; + } + } + } + countdown -= 1; + } +} diff --git a/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs b/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs new file mode 100644 index 00000000000..334fb3364cc --- /dev/null +++ b/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs @@ -0,0 +1,99 @@ +// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the +// structure of this test. + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Version { + major: usize, + minor: usize, + patch: usize, +} + +impl Version { + pub fn new(major: usize, minor: usize, patch: usize) -> Self { + Self { + major, + minor, + patch, + } + } +} + +fn main() { + let version_3_2_1 = Version::new(3, 2, 1); + let version_3_3_0 = Version::new(3, 3, 0); + + println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); +} + +/* + +This test verifies a bug was fixed that otherwise generated this error: + +thread 'rustc' panicked at 'No counters provided the source_hash for function: + Instance { + def: Item(WithOptConstParam { + did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp), + const_param_did: None + }), + substs: [] + }' +The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage +without a code region associated with any `Counter`. Code regions were associated with at least +one expression, which is allowed, but the `function_source_hash` was only passed to the codegen +(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the +`function_source_hash` without a code region, if necessary. + +*/ + +// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces +// the following results: + +/* + +1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17? + +2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing + line count with a different instance? Or was it really only called once? + +3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of + its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a + problem computing the file position here, for some reason. + + + 16| | + 17| 2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] + ^1 ^1 +------------------ +|Unexecuted instantiation: ::gt +------------------ +|Unexecuted instantiation: ::le +------------------ +|Unexecuted instantiation: ::ge +------------------ +|::lt: +| 17| 1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +------------------ + 18| |pub struct Version { + 19| | major: usize, + 20| 1| minor: usize, + 21| | patch: usize, + 22| |} + 23| | + 24| |impl Version { + 25| | pub fn new(major: usize, minor: usize, patch: usize) -> Self { + 26| 2| Version { + 27| 2| major, + 28| 2| minor, + 29| 2| patch, + 30| 2| } + 31| 2| } + 32| |} + 33| | + 34| 1|fn main() { + 35| 1| let version_3_2_1 = Version::new(3, 2, 1); + 36| 1| let version_3_3_0 = Version::new(3, 3, 0); + 37| 1| + 38| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version +_3_3_0); + 39| 1|} +*/ diff --git a/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs b/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs new file mode 100644 index 00000000000..cef99027aaa --- /dev/null +++ b/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs @@ -0,0 +1,5 @@ +fn main() { + if false { + loop {} + } +} diff --git a/src/test/run-make-fulldeps/coverage/while.rs b/src/test/run-make-fulldeps/coverage/while.rs new file mode 100644 index 00000000000..781b90b3566 --- /dev/null +++ b/src/test/run-make-fulldeps/coverage/while.rs @@ -0,0 +1,5 @@ +fn main() { + let num = 9; + while num >= 10 { + } +}