nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 23:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #115301 - Zalathar:regions-vec, r=davidtwco

Browse Source 
coverage: Allow each coverage statement to have multiple code regions

The original implementation of coverage instrumentation was built around the assumption that a coverage counter/expression would be associated with *up to one* code region. When it was discovered that *multiple* regions would sometimes need to share a counter, a workaround was found: for the remaining regions, the instrumentor would create a fresh expression that adds zero  to the existing counter/expression.

That got the job done, but resulted in some awkward code, and produces unnecessarily complicated coverage maps in the final binary.

---

This PR removes that tension by changing `StatementKind::Coverage`'s code region field from `Option<CodeRegion>` to `Vec<CodeRegion>`.

The changes on the codegen side are fairly straightforward. As long as each `CoverageKind::Counter` only injects one `llvm.instrprof.increment`, the rest of coverage codegen is happy to handle multiple regions mapped to the same counter/expression, with only minor option-to-vec adjustments.

On the instrumentor/mir-transform side, we can get rid of the code that creates extra (x + 0) expressions. Instead we gather all of the code regions associated with a single BCB, and inject them all into one coverage statement.

---

There are several patches here but they can be divided in to three phases:
- Preparatory work
- Actually switching over to multiple regions per coverage statement
- Cleaning up

So viewing the patches individually may be easier.
This commit is contained in:
bors 2023-10-03 18:36:21 +00:00
commit 36aab8df0a
37 changed files with 1074 additions and 1218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
View File

@ -11,7 +11,7 @@ pub struct Expression {
lhs: Operand,
op: Op,
rhs: Operand,
region: Option<CodeRegion>,
code_regions: Vec<CodeRegion>,
}
/// Collects all of the coverage regions associated with (a) injected counters, (b) counter
@ -30,7 +30,7 @@ pub struct FunctionCoverage<'tcx> {
instance: Instance<'tcx>,
source_hash: u64,
is_used: bool,
counters: IndexVec<CounterId, Option<CodeRegion>>,
counters: IndexVec<CounterId, Option<Vec<CodeRegion>>>,
expressions: IndexVec<ExpressionId, Option<Expression>>,
unreachable_regions: Vec<CodeRegion>,
}
@ -77,28 +77,40 @@ impl<'tcx> FunctionCoverage<'tcx> {
}
}
/// Adds a code region to be counted by an injected counter intrinsic.
pub fn add_counter(&mut self, id: CounterId, region: CodeRegion) {
if let Some(previous_region) = self.counters[id].replace(region.clone()) {
assert_eq!(previous_region, region, "add_counter: code region for id changed");
/// Adds code regions to be counted by an injected counter intrinsic.
#[instrument(level = "debug", skip(self))]
pub(crate) fn add_counter(&mut self, id: CounterId, code_regions: &[CodeRegion]) {
if code_regions.is_empty() {
return;
}
let slot = &mut self.counters[id];
match slot {
None => *slot = Some(code_regions.to_owned()),
// If this counter ID slot has already been filled, it should
// contain identical information.
Some(ref previous_regions) => assert_eq!(
previous_regions, code_regions,
"add_counter: code regions for id changed"
),
}
}
/// Adds information about a coverage expression, along with zero or more
/// code regions mapped to that expression.
///
/// Both counters and "counter expressions" (or simply, "expressions") can be operands in other
/// expressions. These are tracked as separate variants of `Operand`, so there is no ambiguity
/// between operands that are counter IDs and operands that are expression IDs.
pub fn add_counter_expression(
#[instrument(level = "debug", skip(self))]
pub(crate) fn add_counter_expression(
&mut self,
expression_id: ExpressionId,
lhs: Operand,
op: Op,
rhs: Operand,
region: Option<CodeRegion>,
code_regions: &[CodeRegion],
) {
debug!(
"add_counter_expression({:?}, lhs={:?}, op={:?}, rhs={:?} at {:?}",
expression_id, lhs, op, rhs, region
);
debug_assert!(
expression_id.as_usize() < self.expressions.len(),
"expression_id {} is out of range for expressions.len() = {}
@ -107,23 +119,25 @@ impl<'tcx> FunctionCoverage<'tcx> {
self.expressions.len(),
self,
);
if let Some(previous_expression) = self.expressions[expression_id].replace(Expression {
lhs,
op,
rhs,
region: region.clone(),
}) {
assert_eq!(
previous_expression,
Expression { lhs, op, rhs, region },
let expression = Expression { lhs, op, rhs, code_regions: code_regions.to_owned() };
let slot = &mut self.expressions[expression_id];
match slot {
None => *slot = Some(expression),
// If this expression ID slot has already been filled, it should
// contain identical information.
Some(ref previous_expression) => assert_eq!(
previous_expression, &expression,
"add_counter_expression: expression for id changed"
);
),
}
}
/// Add a region that will be marked as "unreachable", with a constant "zero counter".
pub fn add_unreachable_region(&mut self, region: CodeRegion) {
self.unreachable_regions.push(region)
/// Adds regions that will be marked as "unreachable", with a constant "zero counter".
#[instrument(level = "debug", skip(self))]
pub(crate) fn add_unreachable_regions(&mut self, code_regions: &[CodeRegion]) {
assert!(!code_regions.is_empty(), "unreachable regions always have code regions");
self.unreachable_regions.extend_from_slice(code_regions);
}
/// Perform some simplifications to make the final coverage mappings
@ -212,10 +226,15 @@ impl<'tcx> FunctionCoverage<'tcx> {
}
fn counter_regions(&self) -> impl Iterator<Item = (Counter, &CodeRegion)> {
self.counters.iter_enumerated().filter_map(|(index, entry)| {
// Option::map() will return None to filter out missing counters. This may happen
// if, for example, a MIR-instrumented counter is removed during an optimization.
entry.as_ref().map(|region| (Counter::counter_value_reference(index), region))
self.counters
.iter_enumerated()
// Filter out counter IDs that we never saw during MIR traversal.
// This can happen if a counter was optimized out by MIR transforms
// (and replaced with `CoverageKind::Unreachable` instead).
.filter_map(|(id, maybe_code_regions)| Some((id, maybe_code_regions.as_ref()?)))
.flat_map(|(id, code_regions)| {
let counter = Counter::counter_value_reference(id);
code_regions.iter().map(move |region| (counter, region))
})
}
@ -254,13 +273,17 @@ impl<'tcx> FunctionCoverage<'tcx> {
fn expression_regions(&self) -> Vec<(Counter, &CodeRegion)> {
// Find all of the expression IDs that weren't optimized out AND have
// an attached code region, and return the corresponding mapping as a
// counter/region pair.
// one or more attached code regions, and return the corresponding
// mappings as counter/region pairs.
self.expressions
.iter_enumerated()
.filter_map(|(id, expression)| {
let code_region = expression.as_ref()?.region.as_ref()?;
Some((Counter::expression(id), code_region))
.filter_map(|(id, maybe_expression)| {
let code_regions = &maybe_expression.as_ref()?.code_regions;
Some((id, code_regions))
})
.flat_map(|(id, code_regions)| {
let counter = Counter::expression(id);
code_regions.iter().map(move |code_region| (counter, code_region))
})
.collect::<Vec<_>>()
}

45
compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
View File

@ -89,9 +89,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
/// `function_coverage_map` (keyed by function `Instance`) during codegen.
/// But in this case, since the unused function was _not_ previously
/// codegenned, collect the coverage `CodeRegion`s from the MIR and add
/// them. The first `CodeRegion` is used to add a single counter, with the
/// same counter ID used in the injected `instrprof.increment` intrinsic
/// call. Since the function is never called, all other `CodeRegion`s can be
/// them. Since the function is never called, all of its `CodeRegion`s can be
/// added as `unreachable_region`s.
fn define_unused_fn(&self, def_id: DefId) {
let instance = declare_unused_fn(self, def_id);
@ -110,25 +108,15 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
.entry(instance)
.or_insert_with(|| FunctionCoverage::new(bx.tcx(), instance));
let Coverage { kind, code_region } = coverage.clone();
match kind {
let Coverage { kind, code_regions } = coverage;
match *kind {
CoverageKind::Counter { function_source_hash, id } => {
debug!(
"ensuring function source hash is set for instance={:?}; function_source_hash={}",
instance, function_source_hash,
);
func_coverage.set_function_source_hash(function_source_hash);
if let Some(code_region) = code_region {
// Note: Some counters do not have code regions, but may still be referenced
// from expressions. In that case, don't add the counter to the coverage map,
// but do inject the counter intrinsic.
debug!(
"adding counter to coverage_map: instance={:?}, id={:?}, region={:?}",
instance, id, code_region,
);
func_coverage.add_counter(id, code_region);
}
func_coverage.add_counter(id, code_regions);
// We need to explicitly drop the `RefMut` before calling into `instrprof_increment`,
// as that needs an exclusive borrow.
drop(coverage_map);
@ -146,20 +134,10 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
bx.instrprof_increment(fn_name, hash, num_counters, index);
}
CoverageKind::Expression { id, lhs, op, rhs } => {
debug!(
"adding counter expression to coverage_map: instance={:?}, id={:?}, {:?} {:?} {:?}; region: {:?}",
instance, id, lhs, op, rhs, code_region,
);
func_coverage.add_counter_expression(id, lhs, op, rhs, code_region);
func_coverage.add_counter_expression(id, lhs, op, rhs, code_regions);
}
CoverageKind::Unreachable => {
let code_region =
code_region.expect("unreachable regions always have code regions");
debug!(
"adding unreachable code to coverage_map: instance={:?}, at {:?}",
instance, code_region,
);
func_coverage.add_unreachable_region(code_region);
func_coverage.add_unreachable_regions(code_regions);
}
}
}
@ -227,14 +205,9 @@ fn add_unused_function_coverage<'tcx>(
let tcx = cx.tcx;
let mut function_coverage = FunctionCoverage::unused(tcx, instance);
for (index, &code_region) in tcx.covered_code_regions(def_id).iter().enumerate() {
if index == 0 {
// Insert at least one real counter so the LLVM CoverageMappingReader will find expected
// definitions.
function_coverage.add_counter(UNUSED_FUNCTION_COUNTER_ID, code_region.clone());
} else {
function_coverage.add_unreachable_region(code_region.clone());
}
for &code_region in tcx.covered_code_regions(def_id) {
let code_region = std::slice::from_ref(code_region);
function_coverage.add_unreachable_regions(code_region);
}
if let Some(coverage_context) = cx.coverage_context() {

10
compiler/rustc_middle/src/mir/coverage.rs
View File

@ -18,11 +18,6 @@ rustc_index::newtype_index! {
impl CounterId {
pub const START: Self = Self::from_u32(0);
#[inline(always)]
pub fn next_id(self) -> Self {
Self::from_u32(self.as_u32() + 1)
}
}
rustc_index::newtype_index! {
@ -38,11 +33,6 @@ rustc_index::newtype_index! {
impl ExpressionId {
pub const START: Self = Self::from_u32(0);
#[inline(always)]
pub fn next_id(self) -> Self {
Self::from_u32(self.as_u32() + 1)
}
}
/// Operand of a coverage-counter expression.

11
compiler/rustc_middle/src/mir/pretty.rs
View File

@ -16,7 +16,7 @@ use rustc_middle::mir::interpret::{
Pointer, Provenance,
};
use rustc_middle::mir::visit::Visitor;
use rustc_middle::mir::*;
use rustc_middle::mir::{self, *};
use rustc_middle::ty::{self, TyCtxt};
use rustc_target::abi::Size;
@ -685,10 +685,13 @@ impl Debug for Statement<'_> {
AscribeUserType(box (ref place, ref c_ty), ref variance) => {
write!(fmt, "AscribeUserType({place:?}, {variance:?}, {c_ty:?})")
}
Coverage(box self::Coverage { ref kind, code_region: Some(ref rgn) }) => {
write!(fmt, "Coverage::{kind:?} for {rgn:?}")
Coverage(box mir::Coverage { ref kind, ref code_regions }) => {
if code_regions.is_empty() {
write!(fmt, "Coverage::{kind:?}")
} else {
write!(fmt, "Coverage::{kind:?} for {code_regions:?}")
}
}
Coverage(box ref coverage) => write!(fmt, "Coverage::{:?}", coverage.kind),
Intrinsic(box ref intrinsic) => write!(fmt, "{intrinsic}"),
ConstEvalCounter => write!(fmt, "ConstEvalCounter"),
Nop => write!(fmt, "nop"),

2
compiler/rustc_middle/src/mir/syntax.rs
View File

@ -514,7 +514,7 @@ pub enum FakeReadCause {
#[derive(TypeFoldable, TypeVisitable)]
pub struct Coverage {
pub kind: CoverageKind,
pub code_region: Option<CodeRegion>,
pub code_regions: Vec<CodeRegion>,
}
#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)]

37
compiler/rustc_mir_transform/src/coverage/counters.rs
View File

@ -1,10 +1,8 @@
use super::Error;
use super::graph;
use super::spans;
use graph::{BasicCoverageBlock, BcbBranch, CoverageGraph, TraverseCoverageGraphWithLoops};
use spans::CoverageSpan;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::graph::WithNumNodes;
@ -93,14 +91,14 @@ impl CoverageCounters {
}
/// Makes [`BcbCounter`] `Counter`s and `Expressions` for the `BasicCoverageBlock`s directly or
/// indirectly associated with `CoverageSpans`, and accumulates additional `Expression`s
/// indirectly associated with coverage spans, and accumulates additional `Expression`s
/// representing intermediate values.
pub fn make_bcb_counters(
&mut self,
basic_coverage_blocks: &CoverageGraph,
coverage_spans: &[CoverageSpan],
bcb_has_coverage_spans: impl Fn(BasicCoverageBlock) -> bool,
) -> Result<(), Error> {
MakeBcbCounters::new(self, basic_coverage_blocks).make_bcb_counters(coverage_spans)
MakeBcbCounters::new(self, basic_coverage_blocks).make_bcb_counters(bcb_has_coverage_spans)
}
fn make_counter(&mut self) -> BcbCounter {
@ -113,14 +111,10 @@ impl CoverageCounters {
BcbCounter::Expression { id, lhs, op, rhs }
}
pub fn make_identity_counter(&mut self, counter_operand: Operand) -> BcbCounter {
self.make_expression(counter_operand, Op::Add, Operand::Zero)
}
/// Counter IDs start from one and go up.
fn next_counter(&mut self) -> CounterId {
let next = self.next_counter_id;
self.next_counter_id = next.next_id();
self.next_counter_id = self.next_counter_id + 1;
next
}
@ -128,7 +122,7 @@ impl CoverageCounters {
/// (Counter IDs and Expression IDs are distinguished by the `Operand` enum.)
fn next_expression(&mut self) -> ExpressionId {
let next = self.next_expression_id;
self.next_expression_id = next.next_id();
self.next_expression_id = self.next_expression_id + 1;
next
}
@ -208,7 +202,7 @@ impl CoverageCounters {
}
/// Traverse the `CoverageGraph` and add either a `Counter` or `Expression` to every BCB, to be
/// injected with `CoverageSpan`s. `Expressions` have no runtime overhead, so if a viable expression
/// injected with coverage spans. `Expressions` have no runtime overhead, so if a viable expression
/// (adding or subtracting two other counters or expressions) can compute the same result as an
/// embedded counter, an `Expression` should be used.
struct MakeBcbCounters<'a> {
@ -234,17 +228,14 @@ impl<'a> MakeBcbCounters<'a> {
/// Returns any non-code-span expressions created to represent intermediate values (such as to
/// add two counters so the result can be subtracted from another counter), or an Error with
/// message for subsequent debugging.
fn make_bcb_counters(&mut self, coverage_spans: &[CoverageSpan]) -> Result<(), Error> {
fn make_bcb_counters(
&mut self,
bcb_has_coverage_spans: impl Fn(BasicCoverageBlock) -> bool,
) -> Result<(), Error> {
debug!("make_bcb_counters(): adding a counter or expression to each BasicCoverageBlock");
let num_bcbs = self.basic_coverage_blocks.num_nodes();
let mut bcbs_with_coverage = BitSet::new_empty(num_bcbs);
for covspan in coverage_spans {
bcbs_with_coverage.insert(covspan.bcb);
}
// Walk the `CoverageGraph`. For each `BasicCoverageBlock` node with an associated
// `CoverageSpan`, add a counter. If the `BasicCoverageBlock` branches, add a counter or
// coverage span, add a counter. If the `BasicCoverageBlock` branches, add a counter or
// expression to each branch `BasicCoverageBlock` (if the branch BCB has only one incoming
// edge) or edge from the branching BCB to the branch BCB (if the branch BCB has multiple
// incoming edges).
@ -255,8 +246,8 @@ impl<'a> MakeBcbCounters<'a> {
// the current BCB is in one or more nested loops or not.
let mut traversal = TraverseCoverageGraphWithLoops::new(&self.basic_coverage_blocks);
while let Some(bcb) = traversal.next(self.basic_coverage_blocks) {
if bcbs_with_coverage.contains(bcb) {
debug!("{:?} has at least one `CoverageSpan`. Get or make its counter", bcb);
if bcb_has_coverage_spans(bcb) {
debug!("{:?} has at least one coverage span. Get or make its counter", bcb);
let branching_counter_operand = self.get_or_make_counter_operand(bcb)?;
if self.bcb_needs_branch_counters(bcb) {
@ -264,7 +255,7 @@ impl<'a> MakeBcbCounters<'a> {
}
} else {
debug!(
"{:?} does not have any `CoverageSpan`s. A counter will only be added if \
"{:?} does not have any coverage spans. A counter will only be added if \
and when a covered BCB has an expression dependency.",
bcb,
);

4
compiler/rustc_mir_transform/src/coverage/graph.rs
View File

@ -288,9 +288,9 @@ rustc_index::newtype_index! {
/// not relevant to coverage analysis. `FalseUnwind`, for example, can be treated the same as
/// a `Goto`, and merged with its successor into the same BCB.
///
/// Each BCB with at least one computed `CoverageSpan` will have no more than one `Counter`.
/// Each BCB with at least one computed coverage span will have no more than one `Counter`.
/// In some cases, a BCB's execution count can be computed by `Expression`. Additional
/// disjoint `CoverageSpan`s in a BCB can also be counted by `Expression` (by adding `ZERO`
/// disjoint coverage spans in a BCB can also be counted by `Expression` (by adding `ZERO`
/// to the BCB's primary counter or expression).
///
/// The BCB CFG is critical to simplifying the coverage analysis by ensuring graph path-based

81
compiler/rustc_mir_transform/src/coverage/mod.rs
View File

@ -9,13 +9,11 @@ mod tests;
use self::counters::{BcbCounter, CoverageCounters};
use self::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph};
use self::spans::{CoverageSpan, CoverageSpans};
use self::spans::CoverageSpans;
use crate::MirPass;
use rustc_data_structures::graph::WithNumNodes;
use rustc_data_structures::sync::Lrc;
use rustc_index::IndexVec;
use rustc_middle::hir;
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir::coverage::*;
@ -154,7 +152,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
let body_span = self.body_span;
////////////////////////////////////////////////////
// Compute `CoverageSpan`s from the `CoverageGraph`.
// Compute coverage spans from the `CoverageGraph`.
let coverage_spans = CoverageSpans::generate_coverage_spans(
&self.mir_body,
fn_sig_span,
@ -164,32 +162,33 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
////////////////////////////////////////////////////
// Create an optimized mix of `Counter`s and `Expression`s for the `CoverageGraph`. Ensure
// every `CoverageSpan` has a `Counter` or `Expression` assigned to its `BasicCoverageBlock`
// every coverage span has a `Counter` or `Expression` assigned to its `BasicCoverageBlock`
// and all `Expression` dependencies (operands) are also generated, for any other
// `BasicCoverageBlock`s not already associated with a `CoverageSpan`.
// `BasicCoverageBlock`s not already associated with a coverage span.
//
// Intermediate expressions (used to compute other `Expression` values), which have no
// direct association with any `BasicCoverageBlock`, are accumulated inside `coverage_counters`.
let bcb_has_coverage_spans = |bcb| coverage_spans.bcb_has_coverage_spans(bcb);
let result = self
.coverage_counters
.make_bcb_counters(&mut self.basic_coverage_blocks, &coverage_spans);
.make_bcb_counters(&mut self.basic_coverage_blocks, bcb_has_coverage_spans);
if let Ok(()) = result {
////////////////////////////////////////////////////
// Remove the counter or edge counter from of each `CoverageSpan`s associated
// Remove the counter or edge counter from of each coverage cpan's associated
// `BasicCoverageBlock`, and inject a `Coverage` statement into the MIR.
//
// `Coverage` statements injected from `CoverageSpan`s will include the code regions
// `Coverage` statements injected from coverage spans will include the code regions
// (source code start and end positions) to be counted by the associated counter.
//
// These `CoverageSpan`-associated counters are removed from their associated
// These coverage-span-associated counters are removed from their associated
// `BasicCoverageBlock`s so that the only remaining counters in the `CoverageGraph`
// are indirect counters (to be injected next, without associated code regions).
self.inject_coverage_span_counters(coverage_spans);
self.inject_coverage_span_counters(&coverage_spans);
////////////////////////////////////////////////////
// For any remaining `BasicCoverageBlock` counters (that were not associated with
// any `CoverageSpan`), inject `Coverage` statements (_without_ code region `Span`s)
// any coverage span), inject `Coverage` statements (_without_ code region spans)
// to ensure `BasicCoverageBlock` counters that other `Expression`s may depend on
// are in fact counted, even though they don't directly contribute to counting
// their own independent code region's coverage.
@ -214,47 +213,40 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
}
}
/// 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` 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<CoverageSpan>) {
/// Injects a single [`StatementKind::Coverage`] for each BCB that has one
/// or more coverage spans.
fn inject_coverage_span_counters(&mut self, coverage_spans: &CoverageSpans) {
let tcx = self.tcx;
let source_map = tcx.sess.source_map();
let body_span = self.body_span;
let file_name = Symbol::intern(&self.source_file.name.prefer_remapped().to_string_lossy());
let mut bcb_counters = IndexVec::from_elem_n(None, self.basic_coverage_blocks.num_nodes());
for covspan in coverage_spans {
let bcb = covspan.bcb;
let span = covspan.span;
let counter_kind = if let Some(&counter_operand) = bcb_counters[bcb].as_ref() {
self.coverage_counters.make_identity_counter(counter_operand)
} else if let Some(counter_kind) = self.coverage_counters.take_bcb_counter(bcb) {
bcb_counters[bcb] = Some(counter_kind.as_operand());
counter_kind
} else {
for (bcb, spans) in coverage_spans.bcbs_with_coverage_spans() {
let counter_kind = self.coverage_counters.take_bcb_counter(bcb).unwrap_or_else(|| {
bug!("Every BasicCoverageBlock should have a Counter or Expression");
};
});
let code_region = make_code_region(source_map, file_name, span, body_span);
// Convert the coverage spans into a vector of code regions to be
// associated with this BCB's coverage statement.
let code_regions = spans
.iter()
.map(|&span| make_code_region(source_map, file_name, span, body_span))
.collect::<Vec<_>>();
inject_statement(
self.mir_body,
self.make_mir_coverage_kind(&counter_kind),
self.bcb_leader_bb(bcb),
Some(code_region),
code_regions,
);
}
}
/// `inject_coverage_span_counters()` looped through the `CoverageSpan`s and injected the
/// counter from the `CoverageSpan`s `BasicCoverageBlock`, removing it from the BCB in the
/// process (via `take_counter()`).
/// At this point, any BCB with coverage counters has already had its counter injected
/// into MIR, and had its counter removed from `coverage_counters` (via `take_counter()`).
///
/// Any other counter associated with a `BasicCoverageBlock`, or its incoming edge, but not
/// associated with a `CoverageSpan`, should only exist if the counter is an `Expression`
/// associated with a coverage span, should only exist if the counter is an `Expression`
/// dependency (one of the expression operands). Collect them, and inject the additional
/// counters into the MIR, without a reportable coverage span.
fn inject_indirect_counters(&mut self) {
@ -303,7 +295,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
self.mir_body,
self.make_mir_coverage_kind(&counter_kind),
inject_to_bb,
None,
Vec::new(),
);
}
BcbCounter::Expression { .. } => inject_intermediate_expression(
@ -368,20 +360,14 @@ fn inject_statement(
mir_body: &mut mir::Body<'_>,
counter_kind: CoverageKind,
bb: BasicBlock,
some_code_region: Option<CodeRegion>,
code_regions: Vec<CodeRegion>,
) {
debug!(
" injecting statement {:?} for {:?} at code region: {:?}",
counter_kind, bb, some_code_region
);
debug!(" injecting statement {counter_kind:?} for {bb:?} at code regions: {code_regions:?}");
let data = &mut mir_body[bb];
let source_info = data.terminator().source_info;
let statement = Statement {
source_info,
kind: StatementKind::Coverage(Box::new(Coverage {
kind: counter_kind,
code_region: some_code_region,
})),
kind: StatementKind::Coverage(Box::new(Coverage { kind: counter_kind, code_regions })),
};
data.statements.insert(0, statement);
}
@ -395,7 +381,10 @@ fn inject_intermediate_expression(mir_body: &mut mir::Body<'_>, expression: Cove
let source_info = data.terminator().source_info;
let statement = Statement {
source_info,
kind: StatementKind::Coverage(Box::new(Coverage { kind: expression, code_region: None })),
kind: StatementKind::Coverage(Box::new(Coverage {
kind: expression,
code_regions: Vec::new(),
})),
};
data.statements.push(statement);
}

4
compiler/rustc_mir_transform/src/coverage/query.rs
View File

@ -93,8 +93,8 @@ fn coverageinfo<'tcx>(tcx: TyCtxt<'tcx>, instance_def: ty::InstanceDef<'tcx>) ->
fn covered_code_regions(tcx: TyCtxt<'_>, def_id: DefId) -> Vec<&CodeRegion> {
let body = mir_body(tcx, def_id);
all_coverage_in_mir_body(body)
// Not all coverage statements have an attached code region.
.filter_map(|coverage| coverage.code_region.as_ref())
// Coverage statements have a list of code regions (possibly empty).
.flat_map(|coverage| coverage.code_regions.as_slice())
.collect()
}

57
compiler/rustc_mir_transform/src/coverage/spans.rs
View File

@ -1,6 +1,7 @@
use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph, START_BCB};
use rustc_data_structures::graph::WithNumNodes;
use rustc_index::IndexVec;
use rustc_middle::mir::{
self, AggregateKind, BasicBlock, FakeReadCause, Rvalue, Statement, StatementKind, Terminator,
TerminatorKind,
@ -10,6 +11,48 @@ use rustc_span::{BytePos, ExpnKind, MacroKind, Span, Symbol};
use std::cell::OnceCell;
pub(super) struct CoverageSpans {
/// Map from BCBs to their list of coverage spans.
bcb_to_spans: IndexVec<BasicCoverageBlock, Vec<Span>>,
}
impl CoverageSpans {
pub(super) fn generate_coverage_spans(
mir_body: &mir::Body<'_>,
fn_sig_span: Span,
body_span: Span,
basic_coverage_blocks: &CoverageGraph,
) -> Self {
let coverage_spans = CoverageSpansGenerator::generate_coverage_spans(
mir_body,
fn_sig_span,
body_span,
basic_coverage_blocks,
);
// Group the coverage spans by BCB, with the BCBs in sorted order.
let mut bcb_to_spans = IndexVec::from_elem_n(Vec::new(), basic_coverage_blocks.num_nodes());
for CoverageSpan { bcb, span, .. } in coverage_spans {
bcb_to_spans[bcb].push(span);
}
Self { bcb_to_spans }
}
pub(super) fn bcb_has_coverage_spans(&self, bcb: BasicCoverageBlock) -> bool {
!self.bcb_to_spans[bcb].is_empty()
}
pub(super) fn bcbs_with_coverage_spans(
&self,
) -> impl Iterator<Item = (BasicCoverageBlock, &[Span])> {
self.bcb_to_spans.iter_enumerated().filter_map(|(bcb, spans)| {
// Only yield BCBs that have at least one coverage span.
(!spans.is_empty()).then_some((bcb, spans.as_slice()))
})
}
}
#[derive(Debug, Copy, Clone)]
pub(super) enum CoverageStatement {
Statement(BasicBlock, Span, usize),
@ -35,7 +78,7 @@ impl CoverageStatement {
/// or is subsumed by the `Span` associated with this `CoverageSpan`, and it's `BasicBlock`
/// `dominates()` the `BasicBlock`s in this `CoverageSpan`.
#[derive(Debug, Clone)]
pub(super) struct CoverageSpan {
struct CoverageSpan {
pub span: Span,
pub expn_span: Span,
pub current_macro_or_none: OnceCell<Option<Symbol>>,
@ -162,7 +205,7 @@ impl CoverageSpan {
/// * 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> {
struct CoverageSpansGenerator<'a, 'tcx> {
/// The MIR, used to look up `BasicBlockData`.
mir_body: &'a mir::Body<'tcx>,
@ -218,7 +261,7 @@ pub struct CoverageSpans<'a, 'tcx> {
refined_spans: Vec<CoverageSpan>,
}
impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
impl<'a, 'tcx> CoverageSpansGenerator<'a, 'tcx> {
/// Generate a minimal set of `CoverageSpan`s, each representing a contiguous code region to be
/// counted.
///
@ -246,7 +289,7 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
body_span: Span,
basic_coverage_blocks: &'a CoverageGraph,
) -> Vec<CoverageSpan> {
let mut coverage_spans = CoverageSpans {
let mut coverage_spans = Self {
mir_body,
fn_sig_span,
body_span,
@ -734,7 +777,7 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
/// If the MIR `Statement` has a span contributive to computing coverage spans,
/// return it; otherwise return `None`.
pub(super) fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span> {
fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span> {
match statement.kind {
// These statements have spans that are often outside the scope of the executed source code
// for their parent `BasicBlock`.
@ -781,7 +824,7 @@ pub(super) fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span>
/// If the MIR `Terminator` has a span contributive to computing coverage spans,
/// return it; otherwise return `None`.
pub(super) fn filtered_terminator_span(terminator: &Terminator<'_>) -> Option<Span> {
fn filtered_terminator_span(terminator: &Terminator<'_>) -> Option<Span> {
match terminator.kind {
// These terminators have spans that don't positively contribute to computing a reasonable
// span of actually executed source code. (For example, SwitchInt terminators extracted from
@ -828,7 +871,7 @@ pub(super) fn filtered_terminator_span(terminator: &Terminator<'_>) -> Option<Sp
/// [^1]Expansions result from Rust syntax including macros, syntactic sugar,
/// etc.).
#[inline]
pub(super) fn function_source_span(span: Span, body_span: Span) -> Span {
fn function_source_span(span: Span, body_span: Span) -> Span {
let original_span = original_sp(span, body_span).with_ctxt(body_span.ctxt());
if body_span.contains(original_span) { original_span } else { body_span }
}

34
compiler/rustc_mir_transform/src/coverage/tests.rs
View File

@ -25,8 +25,7 @@
//! to: `rustc_span::create_default_session_globals_then(|| { test_here(); })`.
use super::counters;
use super::graph;
use super::spans;
use super::graph::{self, BasicCoverageBlock};
use coverage_test_macros::let_bcb;
@ -644,39 +643,18 @@ fn test_traverse_coverage_with_loops() {
);
}
fn synthesize_body_span_from_terminators(mir_body: &Body<'_>) -> Span {
let mut some_span: Option<Span> = None;
for (_, data) in mir_body.basic_blocks.iter_enumerated() {
let term_span = data.terminator().source_info.span;
if let Some(span) = some_span.as_mut() {
*span = span.to(term_span);
} else {
some_span = Some(term_span)
}
}
some_span.expect("body must have at least one BasicBlock")
}
#[test]
fn test_make_bcb_counters() {
rustc_span::create_default_session_globals_then(|| {
let mir_body = goto_switchint();
let body_span = synthesize_body_span_from_terminators(&mir_body);
let mut basic_coverage_blocks = graph::CoverageGraph::from_mir(&mir_body);
let mut coverage_spans = Vec::new();
for (bcb, data) in basic_coverage_blocks.iter_enumerated() {
if let Some(span) = spans::filtered_terminator_span(data.terminator(&mir_body)) {
coverage_spans.push(spans::CoverageSpan::for_terminator(
spans::function_source_span(span, body_span),
span,
bcb,
data.last_bb(),
));
}
}
// Historically this test would use `spans` internals to set up fake
// coverage spans for BCBs 1 and 2. Now we skip that step and just tell
// BCB counter construction that those BCBs have spans.
let bcb_has_coverage_spans = |bcb: BasicCoverageBlock| (1..=2).contains(&bcb.as_usize());
let mut coverage_counters = counters::CoverageCounters::new(&basic_coverage_blocks);
coverage_counters
.make_bcb_counters(&mut basic_coverage_blocks, &coverage_spans)
.make_bcb_counters(&mut basic_coverage_blocks, bcb_has_coverage_spans)
.expect("should be Ok");
assert_eq!(coverage_counters.intermediate_expressions.len(), 0);

10
compiler/rustc_mir_transform/src/simplify.rs
View File

@ -441,21 +441,23 @@ fn save_unreachable_coverage(
let dead_block = &basic_blocks[dead_block];
for statement in &dead_block.statements {
let StatementKind::Coverage(coverage) = &statement.kind else { continue };
let Some(code_region) = &coverage.code_region else { continue };
if coverage.code_regions.is_empty() {
continue;
};
let instance = statement.source_info.scope.inlined_instance(source_scopes);
if live.contains(&instance) {
retained_coverage.push((statement.source_info, code_region.clone()));
retained_coverage.push((statement.source_info, coverage.code_regions.clone()));
}
}
}
let start_block = &mut basic_blocks[START_BLOCK];
start_block.statements.extend(retained_coverage.into_iter().map(
|(source_info, code_region)| Statement {
|(source_info, code_regions)| Statement {
source_info,
kind: StatementKind::Coverage(Box::new(Coverage {
kind: CoverageKind::Unreachable,
code_region: Some(code_region),
code_regions,
})),
},
));

90
tests/coverage-map/status-quo/async.cov-map
View File

@ -38,42 +38,40 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 13, 20) to (start + 0, 25)
Function name: async::e (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0f, 01, 00, 14]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 0f, 01, 00, 14]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 15, 1) to (start + 0, 20)
- Code(Zero) at (prev + 15, 1) to (start + 0, 20)
Function name: async::e::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0f, 14, 00, 19]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 0f, 14, 00, 19]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 15, 20) to (start + 0, 25)
- Code(Zero) at (prev + 15, 20) to (start + 0, 25)
Function name: async::executor::block_on::<core::pin::Pin<&mut async::i::{closure#0}>>
Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 6e, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 6e, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 3
- expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 110, 5) to (start + 10, 54)
- Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
= ((c0 + c1) - c1)
- Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
= (c0 + c1)
- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
= ((c0 + c1) - c1)
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
= ((c0 + c1) - c1)
Function name: async::executor::block_on::VTABLE::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 72, 11, 00, 33]
@ -124,20 +122,20 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 17, 20) to (start + 0, 25)
Function name: async::foo (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 00, 1e]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 13, 01, 00, 1e]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 30)
- Code(Zero) at (prev + 19, 1) to (start + 0, 30)
Function name: async::foo::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 1e, 00, 2d]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 13, 1e, 00, 2d]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 19, 30) to (start + 0, 45)
- Code(Zero) at (prev + 19, 30) to (start + 0, 45)
Function name: async::g
Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 01, 00, 17]
@ -148,14 +146,14 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 21, 1) to (start + 0, 23)
Function name: async::g::{closure#0} (unused)
Raw bytes (69): 0x[01, 01, 00, 0d, 00, 15, 17, 01, 0c, 00, 02, 09, 00, 0a, 01, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Raw bytes (69): 0x[01, 01, 00, 0d, 00, 15, 17, 01, 0c, 00, 02, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 13
- Code(Zero) at (prev + 21, 23) to (start + 1, 12)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 17)
- Code(Zero) at (prev + 0, 14) to (start + 0, 17)
- Code(Zero) at (prev + 0, 18) to (start + 0, 23)
- Code(Zero) at (prev + 0, 27) to (start + 0, 28)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
@ -176,14 +174,14 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 29, 1) to (start + 0, 22)
Function name: async::h::{closure#0} (unused)
Raw bytes (44): 0x[01, 01, 00, 08, 00, 1d, 16, 03, 0c, 00, 04, 09, 00, 0a, 01, 00, 0e, 00, 13, 00, 00, 14, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Raw bytes (44): 0x[01, 01, 00, 08, 00, 1d, 16, 03, 0c, 00, 04, 09, 00, 0a, 00, 00, 0e, 00, 13, 00, 00, 14, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 8
- Code(Zero) at (prev + 29, 22) to (start + 3, 12)
- Code(Zero) at (prev + 4, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 19)
- Code(Zero) at (prev + 0, 14) to (start + 0, 19)
- Code(Zero) at (prev + 0, 20) to (start + 0, 25)
- Code(Zero) at (prev + 0, 26) to (start + 0, 27)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
@ -199,58 +197,46 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 38, 1) to (start + 0, 19)
Function name: async::i::{closure#0}
Raw bytes (84): 0x[01, 01, 05, 01, 00, 0d, 00, 1d, 00, 19, 13, 1d, 21, 0e, 01, 26, 13, 04, 0c, 0d, 05, 09, 00, 0a, 03, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 07, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 0b, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 0f, 02, 01, 00, 02]
Raw bytes (78): 0x[01, 01, 02, 19, 07, 1d, 21, 0e, 01, 26, 13, 04, 0c, 0d, 05, 09, 00, 0a, 01, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 0d, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 1d, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(3), rhs = Zero
- expression 2 operands: lhs = Counter(7), rhs = Zero
- expression 3 operands: lhs = Counter(6), rhs = Expression(4, Add)
- expression 4 operands: lhs = Counter(7), rhs = Counter(8)
Number of expressions: 2
- expression 0 operands: lhs = Counter(6), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(7), rhs = Counter(8)
Number of file 0 mappings: 14
- Code(Counter(0)) at (prev + 38, 19) to (start + 4, 12)
- Code(Counter(3)) at (prev + 5, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 18)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 19) to (start + 0, 24)
- Code(Counter(2)) at (prev + 0, 28) to (start + 0, 33)
- Code(Expression(1, Add)) at (prev + 0, 39) to (start + 0, 42)
= (c3 + Zero)
- Code(Counter(3)) at (prev + 0, 39) to (start + 0, 42)
- Code(Counter(5)) at (prev + 0, 43) to (start + 0, 48)
- Code(Counter(7)) at (prev + 1, 9) to (start + 0, 10)
- Code(Counter(4)) at (prev + 0, 14) to (start + 0, 17)
- Code(Counter(9)) at (prev + 0, 18) to (start + 0, 23)
- Code(Counter(10)) at (prev + 0, 27) to (start + 0, 32)
- Code(Expression(2, Add)) at (prev + 0, 36) to (start + 0, 38)
= (c7 + Zero)
- Code(Counter(7)) at (prev + 0, 36) to (start + 0, 38)
- Code(Counter(8)) at (prev + 1, 14) to (start + 0, 16)
- Code(Expression(3, Add)) at (prev + 2, 1) to (start + 0, 2)
- Code(Expression(0, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c6 + (c7 + c8))
Function name: async::j
Raw bytes (59): 0x[01, 01, 05, 01, 00, 05, 00, 09, 00, 05, 13, 09, 0d, 09, 01, 31, 01, 13, 0c, 05, 14, 09, 00, 0a, 03, 00, 0e, 00, 1b, 07, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 0b, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 0f, 02, 01, 00, 02]
Raw bytes (53): 0x[01, 01, 02, 05, 07, 09, 0d, 09, 01, 31, 01, 13, 0c, 05, 14, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(1), rhs = Zero
- expression 2 operands: lhs = Counter(2), rhs = Zero
- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
Number of expressions: 2
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 49, 1) to (start + 19, 12)
- Code(Counter(1)) at (prev + 20, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 27)
= (c0 + Zero)
- Code(Expression(1, Add)) at (prev + 0, 31) to (start + 0, 39)
= (c1 + Zero)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 27)
- Code(Counter(1)) at (prev + 0, 31) to (start + 0, 39)
- Code(Counter(2)) at (prev + 1, 9) to (start + 0, 10)
- Code(Counter(4)) at (prev + 0, 14) to (start + 0, 26)
- Code(Expression(2, Add)) at (prev + 0, 30) to (start + 0, 32)
= (c2 + Zero)
- Code(Counter(2)) at (prev + 0, 30) to (start + 0, 32)
- Code(Counter(3)) at (prev + 1, 14) to (start + 0, 16)
- Code(Expression(3, Add)) at (prev + 2, 1) to (start + 0, 2)
- Code(Expression(0, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c1 + (c2 + c3))
Function name: async::j::c
@ -285,12 +271,12 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 67, 5) to (start + 0, 23)
Function name: async::k (unused)
Raw bytes (29): 0x[01, 01, 00, 05, 01, 4b, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Raw bytes (29): 0x[01, 01, 00, 05, 00, 4b, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 75, 1) to (start + 1, 12)
- Code(Zero) at (prev + 75, 1) to (start + 1, 12)
- Code(Zero) at (prev + 2, 14) to (start + 0, 16)
- Code(Zero) at (prev + 1, 14) to (start + 0, 16)
- Code(Zero) at (prev + 1, 14) to (start + 0, 16)
@ -323,12 +309,12 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 91, 1) to (start + 0, 25)
Function name: async::m::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 5b, 19, 00, 22]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 5b, 19, 00, 22]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 91, 25) to (start + 0, 34)
- Code(Zero) at (prev + 91, 25) to (start + 0, 34)
Function name: async::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 5d, 01, 08, 02]

28
tests/coverage-map/status-quo/async2.cov-map
View File

@ -38,48 +38,44 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 19, 36) to (start + 2, 2)
Function name: async2::executor::block_on::<async2::async_func::{closure#0}>
Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 3
- expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 39, 5) to (start + 10, 54)
- Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
= ((c0 + c1) - c1)
- Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
= (c0 + c1)
- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
= ((c0 + c1) - c1)
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
= ((c0 + c1) - c1)
Function name: async2::executor::block_on::<async2::async_func_just_println::{closure#0}>
Raw bytes (44): 0x[01, 01, 05, 0b, 05, 01, 05, 01, 05, 02, 00, 02, 00, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 0f, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 13, 02, 05, 00, 06]
Raw bytes (40): 0x[01, 01, 03, 0b, 05, 01, 05, 01, 05, 06, 01, 27, 05, 0a, 36, 02, 0d, 20, 00, 23, 0b, 00, 27, 00, 49, 02, 01, 17, 00, 1a, 05, 01, 0e, 00, 0f, 02, 02, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 3
- expression 0 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 4 operands: lhs = Expression(0, Sub), rhs = Zero
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 39, 5) to (start + 10, 54)
- Code(Expression(0, Sub)) at (prev + 13, 32) to (start + 0, 35)
= ((c0 + c1) - c1)
- Code(Expression(2, Add)) at (prev + 0, 39) to (start + 0, 73)
= (c0 + c1)
- Code(Expression(3, Add)) at (prev + 1, 23) to (start + 0, 26)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 1, 23) to (start + 0, 26)
= ((c0 + c1) - c1)
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 15)
- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
= (((c0 + c1) - c1) + Zero)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
= ((c0 + c1) - c1)
Function name: async2::executor::block_on::VTABLE::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 2b, 11, 00, 33]

185
tests/coverage-map/status-quo/closure.cov-map
View File

@ -1,77 +1,36 @@
Function name: closure::main
Raw bytes (170): 0x[01, 01, 17, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 05, 05, 5a, 01, 05, 18, 01, 08, 01, 0f, 0d, 03, 16, 0e, 06, 0a, 07, 10, 05, 13, 0d, 0b, 1a, 0e, 06, 0a, 0f, 10, 05, 0c, 16, 13, 16, 05, 0d, 18, 17, 19, 09, 01, 1e, 1b, 04, 09, 00, 29, 1f, 01, 09, 00, 2d, 23, 01, 09, 00, 24, 27, 05, 09, 00, 24, 2b, 02, 09, 00, 21, 2f, 04, 09, 00, 21, 33, 04, 09, 00, 28, 37, 09, 09, 00, 32, 3b, 04, 09, 00, 33, 3f, 07, 09, 00, 4b, 43, 08, 09, 00, 48, 47, 0a, 09, 00, 47, 4b, 08, 09, 00, 44, 4f, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 5a, 04, 06, 00, 07, 57, 01, 05, 03, 02]
Raw bytes (128): 0x[01, 01, 02, 01, 05, 05, 02, 18, 01, 08, 01, 0f, 0d, 01, 16, 0e, 06, 0a, 01, 10, 05, 13, 0d, 01, 1a, 0e, 06, 0a, 01, 10, 05, 0c, 16, 01, 16, 05, 0d, 18, 01, 19, 09, 01, 1e, 01, 04, 09, 00, 29, 01, 01, 09, 00, 2d, 01, 01, 09, 00, 24, 01, 05, 09, 00, 24, 01, 02, 09, 00, 21, 01, 04, 09, 00, 21, 01, 04, 09, 00, 28, 01, 09, 09, 00, 32, 01, 04, 09, 00, 33, 01, 07, 09, 00, 4b, 01, 08, 09, 00, 48, 01, 0a, 09, 00, 47, 01, 08, 09, 00, 44, 01, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 02, 04, 06, 00, 07, 07, 01, 05, 03, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 23
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(0), rhs = Zero
- expression 2 operands: lhs = Counter(0), rhs = Zero
- expression 3 operands: lhs = Counter(0), rhs = Zero
- expression 4 operands: lhs = Counter(0), rhs = Zero
- expression 5 operands: lhs = Counter(0), rhs = Zero
- expression 6 operands: lhs = Counter(0), rhs = Zero
- expression 7 operands: lhs = Counter(0), rhs = Zero
- expression 8 operands: lhs = Counter(0), rhs = Zero
- expression 9 operands: lhs = Counter(0), rhs = Zero
- expression 10 operands: lhs = Counter(0), rhs = Zero
- expression 11 operands: lhs = Counter(0), rhs = Zero
- expression 12 operands: lhs = Counter(0), rhs = Zero
- expression 13 operands: lhs = Counter(0), rhs = Zero
- expression 14 operands: lhs = Counter(0), rhs = Zero
- expression 15 operands: lhs = Counter(0), rhs = Zero
- expression 16 operands: lhs = Counter(0), rhs = Zero
- expression 17 operands: lhs = Counter(0), rhs = Zero
- expression 18 operands: lhs = Counter(0), rhs = Zero
- expression 19 operands: lhs = Counter(0), rhs = Zero
- expression 20 operands: lhs = Counter(0), rhs = Counter(1)
- expression 21 operands: lhs = Counter(1), rhs = Expression(22, Sub)
- expression 22 operands: lhs = Counter(0), rhs = Counter(1)
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 24
- Code(Counter(0)) at (prev + 8, 1) to (start + 15, 13)
- Code(Expression(0, Add)) at (prev + 22, 14) to (start + 6, 10)
= (c0 + Zero)
- Code(Expression(1, Add)) at (prev + 16, 5) to (start + 19, 13)
= (c0 + Zero)
- Code(Expression(2, Add)) at (prev + 26, 14) to (start + 6, 10)
= (c0 + Zero)
- Code(Expression(3, Add)) at (prev + 16, 5) to (start + 12, 22)
= (c0 + Zero)
- Code(Expression(4, Add)) at (prev + 22, 5) to (start + 13, 24)
= (c0 + Zero)
- Code(Expression(5, Add)) at (prev + 25, 9) to (start + 1, 30)
= (c0 + Zero)
- Code(Expression(6, Add)) at (prev + 4, 9) to (start + 0, 41)
= (c0 + Zero)
- Code(Expression(7, Add)) at (prev + 1, 9) to (start + 0, 45)
= (c0 + Zero)
- Code(Expression(8, Add)) at (prev + 1, 9) to (start + 0, 36)
= (c0 + Zero)
- Code(Expression(9, Add)) at (prev + 5, 9) to (start + 0, 36)
= (c0 + Zero)
- Code(Expression(10, Add)) at (prev + 2, 9) to (start + 0, 33)
= (c0 + Zero)
- Code(Expression(11, Add)) at (prev + 4, 9) to (start + 0, 33)
= (c0 + Zero)
- Code(Expression(12, Add)) at (prev + 4, 9) to (start + 0, 40)
= (c0 + Zero)
- Code(Expression(13, Add)) at (prev + 9, 9) to (start + 0, 50)
= (c0 + Zero)
- Code(Expression(14, Add)) at (prev + 4, 9) to (start + 0, 51)
= (c0 + Zero)
- Code(Expression(15, Add)) at (prev + 7, 9) to (start + 0, 75)
= (c0 + Zero)
- Code(Expression(16, Add)) at (prev + 8, 9) to (start + 0, 72)
= (c0 + Zero)
- Code(Expression(17, Add)) at (prev + 10, 9) to (start + 0, 71)
= (c0 + Zero)
- Code(Expression(18, Add)) at (prev + 8, 9) to (start + 0, 68)
= (c0 + Zero)
- Code(Expression(19, Add)) at (prev + 10, 8) to (start + 0, 16)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 22, 14) to (start + 6, 10)
- Code(Counter(0)) at (prev + 16, 5) to (start + 19, 13)
- Code(Counter(0)) at (prev + 26, 14) to (start + 6, 10)
- Code(Counter(0)) at (prev + 16, 5) to (start + 12, 22)
- Code(Counter(0)) at (prev + 22, 5) to (start + 13, 24)
- Code(Counter(0)) at (prev + 25, 9) to (start + 1, 30)
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 41)
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 45)
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 36)
- Code(Counter(0)) at (prev + 5, 9) to (start + 0, 36)
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 33)
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 33)
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 40)
- Code(Counter(0)) at (prev + 9, 9) to (start + 0, 50)
- Code(Counter(0)) at (prev + 4, 9) to (start + 0, 51)
- Code(Counter(0)) at (prev + 7, 9) to (start + 0, 75)
- Code(Counter(0)) at (prev + 8, 9) to (start + 0, 72)
- Code(Counter(0)) at (prev + 10, 9) to (start + 0, 71)
- Code(Counter(0)) at (prev + 8, 9) to (start + 0, 68)
- Code(Counter(0)) at (prev + 10, 8) to (start + 0, 16)
- Code(Counter(1)) at (prev + 0, 17) to (start + 4, 6)
- Code(Expression(22, Sub)) at (prev + 4, 6) to (start + 0, 7)
- Code(Expression(0, Sub)) at (prev + 4, 6) to (start + 0, 7)
= (c0 - c1)
- Code(Expression(21, Add)) at (prev + 1, 5) to (start + 3, 2)
- Code(Expression(1, Add)) at (prev + 1, 5) to (start + 3, 2)
= (c1 + (c0 - c1))
Function name: closure::main::{closure#0}
@ -90,46 +49,45 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1))
Function name: closure::main::{closure#10} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 9a, 01, 07, 00, 21]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 9a, 01, 07, 00, 21]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 154, 7) to (start + 0, 33)
- Code(Zero) at (prev + 154, 7) to (start + 0, 33)
Function name: closure::main::{closure#11} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 9e, 01, 07, 00, 21]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 9e, 01, 07, 00, 21]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 158, 7) to (start + 0, 33)
- Code(Zero) at (prev + 158, 7) to (start + 0, 33)
Function name: closure::main::{closure#12} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, a6, 01, 01, 00, 17]
Raw bytes (10): 0x[01, 01, 00, 01, 00, a6, 01, 01, 00, 17]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 166, 1) to (start + 0, 23)
- Code(Zero) at (prev + 166, 1) to (start + 0, 23)
Function name: closure::main::{closure#13} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, ab, 01, 0d, 02, 0e]
Raw bytes (10): 0x[01, 01, 00, 01, 00, ab, 01, 0d, 02, 0e]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 171, 13) to (start + 2, 14)
- Code(Zero) at (prev + 171, 13) to (start + 2, 14)
Function name: closure::main::{closure#14}
Raw bytes (38): 0x[01, 01, 04, 05, 0a, 01, 05, 01, 05, 03, 00, 05, 03, b2, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 0f, 01, 0d, 00, 0e]
Raw bytes (36): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 05, 03, b2, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 01, 0d, 00, 0e]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 3
- expression 0 operands: lhs = Counter(1), rhs = Expression(2, Sub)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Zero
Number of file 0 mappings: 5
- Code(Expression(0, Add)) at (prev + 178, 13) to (start + 0, 21)
= (c1 + (c0 - c1))
@ -137,40 +95,36 @@ Number of file 0 mappings: 5
- Code(Counter(1)) at (prev + 1, 30) to (start + 0, 37)
- Code(Expression(2, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1)
- Code(Expression(3, Add)) at (prev + 1, 13) to (start + 0, 14)
= ((c1 + (c0 - c1)) + Zero)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 14)
= (c1 + (c0 - c1))
Function name: closure::main::{closure#15}
Raw bytes (45): 0x[01, 01, 05, 05, 0e, 01, 05, 01, 00, 01, 05, 03, 00, 06, 01, ba, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 0b, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0e, 00, 2f, 00, 33, 13, 02, 09, 00, 0a]
Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, ba, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
- expression 0 operands: lhs = Counter(1), rhs = Expression(3, Sub)
Number of expressions: 3
- expression 0 operands: lhs = Counter(1), rhs = Expression(2, Sub)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Zero
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Expression(0, Add), rhs = Zero
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 186, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21)
= (c1 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 1, 17) to (start + 1, 27)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27)
- Code(Counter(1)) at (prev + 1, 30) to (start + 0, 37)
- Code(Expression(3, Sub)) at (prev + 0, 47) to (start + 0, 51)
- Code(Expression(2, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1)
- Code(Expression(4, Add)) at (prev + 2, 9) to (start + 0, 10)
= ((c1 + (c0 - c1)) + Zero)
- Code(Expression(0, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c1 + (c0 - c1))
Function name: closure::main::{closure#16}
Raw bytes (38): 0x[01, 01, 04, 05, 0a, 01, 05, 01, 05, 03, 00, 05, 03, c4, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 0f, 01, 0d, 00, 0e]
Raw bytes (36): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 05, 03, c4, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 01, 0d, 00, 0e]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 3
- expression 0 operands: lhs = Counter(1), rhs = Expression(2, Sub)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Zero
Number of file 0 mappings: 5
- Code(Expression(0, Add)) at (prev + 196, 13) to (start + 0, 21)
= (c1 + (c0 - c1))
@ -178,30 +132,27 @@ Number of file 0 mappings: 5
- Code(Counter(1)) at (prev + 1, 30) to (start + 0, 37)
- Code(Expression(2, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1)
- Code(Expression(3, Add)) at (prev + 1, 13) to (start + 0, 14)
= ((c1 + (c0 - c1)) + Zero)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 14)
= (c1 + (c0 - c1))
Function name: closure::main::{closure#17}
Raw bytes (45): 0x[01, 01, 05, 05, 0e, 01, 05, 01, 00, 01, 05, 03, 00, 06, 01, cc, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 0b, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0e, 00, 2f, 00, 33, 13, 02, 09, 00, 0a]
Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, cc, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
- expression 0 operands: lhs = Counter(1), rhs = Expression(3, Sub)
Number of expressions: 3
- expression 0 operands: lhs = Counter(1), rhs = Expression(2, Sub)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Zero
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Expression(0, Add), rhs = Zero
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 204, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21)
= (c1 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 1, 17) to (start + 1, 27)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27)
- Code(Counter(1)) at (prev + 1, 30) to (start + 0, 37)
- Code(Expression(3, Sub)) at (prev + 0, 47) to (start + 0, 51)
- Code(Expression(2, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1)
- Code(Expression(4, Add)) at (prev + 2, 9) to (start + 0, 10)
= ((c1 + (c0 - c1)) + Zero)
- Code(Expression(0, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c1 + (c0 - c1))
Function name: closure::main::{closure#18}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 18, 0d, 02, 1c, 05, 02, 1d, 02, 12, 02, 02, 12, 00, 13, 07, 01, 11, 01, 0e]
@ -264,23 +215,23 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1))
Function name: closure::main::{closure#3} (unused)
Raw bytes (25): 0x[01, 01, 00, 04, 01, 80, 01, 05, 01, 14, 00, 01, 15, 02, 0a, 00, 02, 0a, 00, 0b, 00, 01, 09, 01, 06]
Raw bytes (25): 0x[01, 01, 00, 04, 00, 80, 01, 05, 01, 14, 00, 01, 15, 02, 0a, 00, 02, 0a, 00, 0b, 00, 01, 09, 01, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 128, 5) to (start + 1, 20)
- Code(Zero) at (prev + 128, 5) to (start + 1, 20)
- Code(Zero) at (prev + 1, 21) to (start + 2, 10)
- Code(Zero) at (prev + 2, 10) to (start + 0, 11)
- Code(Zero) at (prev + 1, 9) to (start + 1, 6)
Function name: closure::main::{closure#4} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 88, 01, 35, 00, 43]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 88, 01, 35, 00, 43]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 136, 53) to (start + 0, 67)
- Code(Zero) at (prev + 136, 53) to (start + 0, 67)
Function name: closure::main::{closure#5}
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8b, 01, 3d, 00, 4f]
@ -299,26 +250,26 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 140, 65) to (start + 0, 87)
Function name: closure::main::{closure#7} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8d, 01, 3b, 00, 51]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 8d, 01, 3b, 00, 51]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 141, 59) to (start + 0, 81)
- Code(Zero) at (prev + 141, 59) to (start + 0, 81)
Function name: closure::main::{closure#8} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 92, 01, 3b, 00, 55]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 92, 01, 3b, 00, 55]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 146, 59) to (start + 0, 85)
- Code(Zero) at (prev + 146, 59) to (start + 0, 85)
Function name: closure::main::{closure#9} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 01, 94, 01, 38, 02, 06]
Raw bytes (10): 0x[01, 01, 00, 01, 00, 94, 01, 38, 02, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 148, 56) to (start + 2, 6)
- Code(Zero) at (prev + 148, 56) to (start + 2, 6)

125
tests/coverage-map/status-quo/closure_bug.cov-map
View File

@ -1,89 +1,74 @@
Function name: closure_bug::main
Raw bytes (241): 0x[01, 01, 34, 01, 00, 01, 05, 05, ce, 01, 01, 05, cb, 01, 00, 05, ce, 01, 01, 05, cb, 01, 09, 05, ce, 01, 01, 05, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, c3, 01, 00, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, bb, 01, 00, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, bb, 01, 11, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 11, b6, 01, bb, 01, 11, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 11, 01, 06, 01, 03, 0a, 03, 09, 05, 01, 0e, 05, 01, 0f, 00, 17, ce, 01, 00, 17, 00, 18, cb, 01, 02, 09, 00, 0a, 13, 06, 05, 01, 0e, 09, 01, 0f, 00, 17, c6, 01, 00, 17, 00, 18, c3, 01, 02, 09, 00, 0a, 3b, 06, 05, 01, 0e, 0d, 01, 0f, 00, 17, be, 01, 00, 17, 00, 18, bb, 01, 02, 09, 00, 0a, 7b, 06, 05, 01, 0e, 11, 01, 0f, 00, 17, b6, 01, 00, 17, 00, 18, b3, 01, 01, 01, 00, 02]
Raw bytes (201): 0x[01, 01, 26, 01, 05, 05, 02, 05, 02, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 82, 01, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 01, 06, 01, 03, 0a, 01, 09, 05, 01, 0e, 05, 01, 0f, 00, 17, 02, 00, 17, 00, 18, 97, 01, 02, 09, 00, 0a, 97, 01, 06, 05, 01, 0e, 09, 01, 0f, 00, 17, 92, 01, 00, 17, 00, 18, 8f, 01, 02, 09, 00, 0a, 8f, 01, 06, 05, 01, 0e, 0d, 01, 0f, 00, 17, 8a, 01, 00, 17, 00, 18, 87, 01, 02, 09, 00, 0a, 87, 01, 06, 05, 01, 0e, 11, 01, 0f, 00, 17, 82, 01, 00, 17, 00, 18, 7f, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 52
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Expression(50, Add), rhs = Zero
- expression 5 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 7 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 8 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 9 operands: lhs = Counter(0), rhs = Counter(1)
- expression 10 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 11 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 12 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 13 operands: lhs = Counter(0), rhs = Counter(1)
- expression 14 operands: lhs = Expression(48, Add), rhs = Zero
- expression 15 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 16 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 17 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 18 operands: lhs = Counter(0), rhs = Counter(1)
- expression 19 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 20 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 21 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 22 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 23 operands: lhs = Counter(0), rhs = Counter(1)
- expression 24 operands: lhs = Counter(3), rhs = Expression(47, Sub)
- expression 25 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 26 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 27 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 28 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 29 operands: lhs = Counter(0), rhs = Counter(1)
- expression 30 operands: lhs = Expression(46, Add), rhs = Zero
- expression 31 operands: lhs = Counter(3), rhs = Expression(47, Sub)
- expression 32 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 33 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 34 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 35 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 36 operands: lhs = Counter(0), rhs = Counter(1)
- expression 37 operands: lhs = Expression(46, Add), rhs = Counter(4)
- expression 38 operands: lhs = Counter(3), rhs = Expression(47, Sub)
- expression 39 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 40 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 41 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 42 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 43 operands: lhs = Counter(0), rhs = Counter(1)
- expression 44 operands: lhs = Counter(4), rhs = Expression(45, Sub)
- expression 45 operands: lhs = Expression(46, Add), rhs = Counter(4)
- expression 46 operands: lhs = Counter(3), rhs = Expression(47, Sub)
- expression 47 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 48 operands: lhs = Counter(2), rhs = Expression(49, Sub)
- expression 49 operands: lhs = Expression(50, Add), rhs = Counter(2)
- expression 50 operands: lhs = Counter(1), rhs = Expression(51, Sub)
- expression 51 operands: lhs = Counter(0), rhs = Counter(1)
Number of expressions: 38
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 3 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 4 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 5 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 6 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 7 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 8 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 9 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 10 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 11 operands: lhs = Expression(35, Add), rhs = Counter(3)
- expression 12 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 13 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 14 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 15 operands: lhs = Counter(3), rhs = Expression(34, Sub)
- expression 16 operands: lhs = Expression(35, Add), rhs = Counter(3)
- expression 17 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 18 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 19 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 20 operands: lhs = Counter(3), rhs = Expression(34, Sub)
- expression 21 operands: lhs = Expression(35, Add), rhs = Counter(3)
- expression 22 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 23 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 24 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 25 operands: lhs = Expression(33, Add), rhs = Counter(4)
- expression 26 operands: lhs = Counter(3), rhs = Expression(34, Sub)
- expression 27 operands: lhs = Expression(35, Add), rhs = Counter(3)
- expression 28 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 29 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 30 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 31 operands: lhs = Counter(4), rhs = Expression(32, Sub)
- expression 32 operands: lhs = Expression(33, Add), rhs = Counter(4)
- expression 33 operands: lhs = Counter(3), rhs = Expression(34, Sub)
- expression 34 operands: lhs = Expression(35, Add), rhs = Counter(3)
- expression 35 operands: lhs = Counter(2), rhs = Expression(36, Sub)
- expression 36 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 37 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 17
- Code(Counter(0)) at (prev + 6, 1) to (start + 3, 10)
- Code(Expression(0, Add)) at (prev + 9, 5) to (start + 1, 14)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 9, 5) to (start + 1, 14)
- Code(Counter(1)) at (prev + 1, 15) to (start + 0, 23)
- Code(Expression(51, Sub)) at (prev + 0, 23) to (start + 0, 24)
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 24)
= (c0 - c1)
- Code(Expression(50, Add)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(37, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c1 + (c0 - c1))
- Code(Expression(37, Add)) at (prev + 6, 5) to (start + 1, 14)
= (c1 + (c0 - c1))
- Code(Expression(4, Add)) at (prev + 6, 5) to (start + 1, 14)
= ((c1 + (c0 - c1)) + Zero)
- Code(Counter(2)) at (prev + 1, 15) to (start + 0, 23)
- Code(Expression(49, Sub)) at (prev + 0, 23) to (start + 0, 24)
- Code(Expression(36, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c1 + (c0 - c1)) - c2)
- Code(Expression(48, Add)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(35, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c2 + ((c1 + (c0 - c1)) - c2))
- Code(Expression(35, Add)) at (prev + 6, 5) to (start + 1, 14)
= (c2 + ((c1 + (c0 - c1)) - c2))
- Code(Expression(14, Add)) at (prev + 6, 5) to (start + 1, 14)
= ((c2 + ((c1 + (c0 - c1)) - c2)) + Zero)
- Code(Counter(3)) at (prev + 1, 15) to (start + 0, 23)
- Code(Expression(47, Sub)) at (prev + 0, 23) to (start + 0, 24)
- Code(Expression(34, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)
- Code(Expression(46, Add)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(33, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
- Code(Expression(33, Add)) at (prev + 6, 5) to (start + 1, 14)
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
- Code(Expression(30, Add)) at (prev + 6, 5) to (start + 1, 14)
= ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) + Zero)
- Code(Counter(4)) at (prev + 1, 15) to (start + 0, 23)
- Code(Expression(45, Sub)) at (prev + 0, 23) to (start + 0, 24)
- Code(Expression(32, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)
- Code(Expression(44, Add)) at (prev + 1, 1) to (start + 0, 2)
- Code(Expression(31, Add)) at (prev + 1, 1) to (start + 0, 2)
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
Function name: closure_bug::main::{closure#0}

22
tests/coverage-map/status-quo/closure_macro.cov-map
View File

@ -7,27 +7,23 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 29, 1) to (start + 2, 2)
Function name: closure_macro::main
Raw bytes (49): 0x[01, 01, 05, 01, 05, 02, 00, 05, 00, 02, 00, 05, 02, 07, 01, 21, 01, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 07, 00, 12, 00, 13, 0b, 00, 54, 00, 55, 0f, 02, 09, 02, 0b, 13, 03, 01, 00, 02]
Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 21, 01, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 2 operands: lhs = Counter(1), rhs = Zero
- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 4 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 33, 1) to (start + 1, 33)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15)
= (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
- Code(Expression(1, Add)) at (prev + 0, 18) to (start + 0, 19)
= ((c0 - c1) + Zero)
- Code(Expression(2, Add)) at (prev + 0, 84) to (start + 0, 85)
= (c1 + Zero)
- Code(Expression(3, Add)) at (prev + 2, 9) to (start + 2, 11)
= ((c0 - c1) + Zero)
- Code(Expression(4, Add)) at (prev + 3, 1) to (start + 0, 2)
- Code(Expression(0, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c0 - c1)
- Code(Counter(1)) at (prev + 0, 84) to (start + 0, 85)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 2, 11)
= (c0 - c1)
- Code(Expression(1, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c1 + (c0 - c1))
Function name: closure_macro::main::{closure#0}

22
tests/coverage-map/status-quo/closure_macro_async.cov-map
View File

@ -15,27 +15,23 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 33, 1) to (start + 0, 43)
Function name: closure_macro_async::test::{closure#0}
Raw bytes (49): 0x[01, 01, 05, 01, 05, 02, 00, 05, 00, 02, 00, 05, 02, 07, 01, 21, 2b, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 07, 00, 12, 00, 13, 0b, 00, 54, 00, 55, 0f, 02, 09, 02, 0b, 13, 03, 01, 00, 02]
Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 21, 2b, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 2 operands: lhs = Counter(1), rhs = Zero
- expression 3 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 4 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 33, 43) to (start + 1, 33)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15)
= (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
- Code(Expression(1, Add)) at (prev + 0, 18) to (start + 0, 19)
= ((c0 - c1) + Zero)
- Code(Expression(2, Add)) at (prev + 0, 84) to (start + 0, 85)
= (c1 + Zero)
- Code(Expression(3, Add)) at (prev + 2, 9) to (start + 2, 11)
= ((c0 - c1) + Zero)
- Code(Expression(4, Add)) at (prev + 3, 1) to (start + 0, 2)
- Code(Expression(0, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c0 - c1)
- Code(Counter(1)) at (prev + 0, 84) to (start + 0, 85)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 2, 11)
= (c0 - c1)
- Code(Expression(1, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c1 + (c0 - c1))
Function name: closure_macro_async::test::{closure#0}::{closure#0}

338
tests/coverage-map/status-quo/conditions.cov-map
View File

@ -1,14 +1,14 @@
Function name: conditions::main
Raw bytes (793): 0x[01, 01, 90, 01, 09, 33, 37, 41, 3b, 3d, 35, 39, 05, 00, bf, 04, 09, 05, 00, 0d, 35, 26, 39, 0d, 35, 3b, 3d, 35, 39, 37, 41, 3b, 3d, 35, 39, ba, 04, 0d, bf, 04, 09, 05, 00, 03, 00, 45, 00, 87, 01, 49, 45, 00, 82, 01, 31, 87, 01, 49, 45, 00, 7e, 4d, 82, 01, 31, 87, 01, 49, 45, 00, 7a, 51, 7e, 4d, 82, 01, 31, 87, 01, 49, 45, 00, ab, 01, 55, 4d, 51, a7, 01, 59, ab, 01, 55, 4d, 51, 49, a3, 01, a7, 01, 59, ab, 01, 55, 4d, 51, 61, 00, e7, 01, 65, 61, 00, e2, 01, 2d, e7, 01, 65, 61, 00, de, 01, 69, e2, 01, 2d, e7, 01, 65, 61, 00, da, 01, 6d, de, 01, 69, e2, 01, 2d, e7, 01, 65, 61, 00, 8f, 02, 71, 69, 6d, 8b, 02, 75, 8f, 02, 71, 69, 6d, 83, 02, 00, 65, 87, 02, 8b, 02, 75, 8f, 02, 71, 69, 6d, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, 79, 00, db, 02, 7d, 79, 00, d6, 02, 29, db, 02, 7d, 79, 00, d2, 02, 81, 01, d6, 02, 29, db, 02, 7d, 79, 00, ce, 02, 85, 01, d2, 02, 81, 01, d6, 02, 29, db, 02, 7d, 79, 00, fb, 03, 89, 01, 81, 01, 85, 01, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, 11, 9b, 04, 9f, 04, 21, a3, 04, 1d, 15, 19, ef, 03, 00, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, ef, 03, 11, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, ea, 03, 25, ef, 03, 11, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, e6, 03, 15, ea, 03, 25, ef, 03, 11, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, e2, 03, 19, e6, 03, 15, ea, 03, 25, ef, 03, 11, 7d, f3, 03, f7, 03, 8d, 01, fb, 03, 89, 01, 81, 01, 85, 01, a3, 04, 1d, 15, 19, 9f, 04, 21, a3, 04, 1d, 15, 19, 97, 04, a7, 04, 11, 9b, 04, 9f, 04, 21, a3, 04, 1d, 15, 19, ab, 04, b6, 04, af, 04, b3, 04, 25, 29, 2d, 31, ba, 04, 0d, bf, 04, 09, 05, 00, 44, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 00, 02, 06, 00, 07, 03, 03, 09, 00, 0a, bf, 04, 00, 10, 00, 1d, 09, 01, 09, 01, 0a, ba, 04, 02, 0f, 00, 1c, 0d, 01, 0c, 00, 19, 26, 00, 1d, 00, 2a, 22, 00, 2e, 00, 3c, 37, 00, 3d, 02, 0a, 41, 02, 0a, 00, 0b, 33, 01, 09, 01, 12, b6, 04, 03, 09, 00, 0f, 4b, 03, 09, 01, 0c, 45, 01, 0d, 02, 06, 00, 02, 06, 00, 07, 87, 01, 02, 08, 00, 15, 49, 00, 16, 02, 06, 82, 01, 02, 0f, 00, 1c, 7e, 01, 0c, 00, 19, 7a, 00, 1d, 00, 2a, 76, 00, 2e, 00, 3c, a7, 01, 00, 3d, 02, 0a, 59, 02, 0a, 00, 0b, a3, 01, 01, 09, 00, 17, 31, 02, 09, 00, 0f, 9f, 01, 03, 08, 00, 0c, 5d, 01, 0d, 01, 10, 61, 01, 11, 02, 0a, 00, 02, 0a, 00, 0b, e7, 01, 02, 0c, 00, 19, 65, 00, 1a, 02, 0a, e2, 01, 03, 11, 00, 1e, de, 01, 01, 10, 00, 1d, da, 01, 00, 21, 00, 2e, d6, 01, 00, 32, 00, 40, 8b, 02, 00, 41, 02, 0e, 75, 02, 0e, 00, 0f, 87, 02, 01, 0d, 00, 1b, 2d, 02, 0d, 00, 13, 00, 02, 06, 00, 07, ff, 01, 02, 09, 01, 0c, 79, 01, 0d, 02, 06, 00, 02, 06, 00, 07, ef, 03, 02, 09, 00, 0a, db, 02, 00, 10, 00, 1d, 7d, 00, 1e, 02, 06, d6, 02, 02, 0f, 00, 1c, d2, 02, 01, 0c, 00, 19, ce, 02, 00, 1d, 00, 2a, ca, 02, 00, 2e, 00, 3c, f7, 03, 00, 3d, 02, 0a, 8d, 01, 02, 0a, 00, 0b, f3, 03, 01, 09, 00, 17, 29, 02, 0d, 02, 0f, 97, 04, 05, 09, 00, 0a, 83, 03, 00, 10, 00, 1d, 11, 00, 1e, 02, 06, ea, 03, 02, 0f, 00, 1c, e6, 03, 01, 0c, 00, 19, e2, 03, 00, 1d, 00, 2a, de, 03, 00, 2e, 00, 3c, 9f, 04, 00, 3d, 02, 0a, 21, 02, 0a, 00, 0b, 9b, 04, 01, 09, 00, 17, 25, 02, 09, 00, 0f, 93, 04, 02, 01, 00, 02]
Raw bytes (784): 0x[01, 01, 8e, 01, 09, 33, 37, 41, 3b, 3d, 35, 39, 05, 00, b7, 04, 09, 05, 00, 0d, 35, 26, 39, 0d, 35, 3b, 3d, 35, 39, 37, 41, 3b, 3d, 35, 39, b2, 04, 0d, b7, 04, 09, 05, 00, 45, 00, 83, 01, 49, 45, 00, 7e, 31, 83, 01, 49, 45, 00, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, 76, 51, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, a7, 01, 55, 4d, 51, a3, 01, 59, a7, 01, 55, 4d, 51, 49, 9f, 01, a3, 01, 59, a7, 01, 55, 4d, 51, 61, 00, e3, 01, 65, 61, 00, de, 01, 2d, e3, 01, 65, 61, 00, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, d6, 01, 6d, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, 8b, 02, 71, 69, 6d, 87, 02, 75, 8b, 02, 71, 69, 6d, ff, 01, 00, 65, 83, 02, 87, 02, 75, 8b, 02, 71, 69, 6d, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 79, 00, d7, 02, 7d, 79, 00, d2, 02, 29, d7, 02, 7d, 79, 00, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, ca, 02, 85, 01, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, f3, 03, 89, 01, 81, 01, 85, 01, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, da, 03, 19, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 9b, 04, 1d, 15, 19, 97, 04, 21, 9b, 04, 1d, 15, 19, 8f, 04, 9f, 04, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, a3, 04, ae, 04, a7, 04, ab, 04, 25, 29, 2d, 31, b2, 04, 0d, b7, 04, 09, 05, 00, 44, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 00, 02, 06, 00, 07, 03, 03, 09, 00, 0a, b7, 04, 00, 10, 00, 1d, 09, 01, 09, 01, 0a, b2, 04, 02, 0f, 00, 1c, 0d, 01, 0c, 00, 19, 26, 00, 1d, 00, 2a, 22, 00, 2e, 00, 3c, 37, 00, 3d, 02, 0a, 41, 02, 0a, 00, 0b, 33, 01, 09, 01, 12, ae, 04, 03, 09, 00, 0f, 03, 03, 09, 01, 0c, 45, 01, 0d, 02, 06, 00, 02, 06, 00, 07, 83, 01, 02, 08, 00, 15, 49, 00, 16, 02, 06, 7e, 02, 0f, 00, 1c, 7a, 01, 0c, 00, 19, 76, 00, 1d, 00, 2a, 72, 00, 2e, 00, 3c, a3, 01, 00, 3d, 02, 0a, 59, 02, 0a, 00, 0b, 9f, 01, 01, 09, 00, 17, 31, 02, 09, 00, 0f, 9b, 01, 03, 08, 00, 0c, 5d, 01, 0d, 01, 10, 61, 01, 11, 02, 0a, 00, 02, 0a, 00, 0b, e3, 01, 02, 0c, 00, 19, 65, 00, 1a, 02, 0a, de, 01, 03, 11, 00, 1e, da, 01, 01, 10, 00, 1d, d6, 01, 00, 21, 00, 2e, d2, 01, 00, 32, 00, 40, 87, 02, 00, 41, 02, 0e, 75, 02, 0e, 00, 0f, 83, 02, 01, 0d, 00, 1b, 2d, 02, 0d, 00, 13, 00, 02, 06, 00, 07, fb, 01, 02, 09, 01, 0c, 79, 01, 0d, 02, 06, 00, 02, 06, 00, 07, e7, 03, 02, 09, 00, 0a, d7, 02, 00, 10, 00, 1d, 7d, 00, 1e, 02, 06, d2, 02, 02, 0f, 00, 1c, ce, 02, 01, 0c, 00, 19, ca, 02, 00, 1d, 00, 2a, c6, 02, 00, 2e, 00, 3c, ef, 03, 00, 3d, 02, 0a, 8d, 01, 02, 0a, 00, 0b, eb, 03, 01, 09, 00, 17, 29, 02, 0d, 02, 0f, 8f, 04, 05, 09, 00, 0a, e7, 03, 00, 10, 00, 1d, 11, 00, 1e, 02, 06, e2, 03, 02, 0f, 00, 1c, de, 03, 01, 0c, 00, 19, da, 03, 00, 1d, 00, 2a, d6, 03, 00, 2e, 00, 3c, 97, 04, 00, 3d, 02, 0a, 21, 02, 0a, 00, 0b, 93, 04, 01, 09, 00, 17, 25, 02, 09, 00, 0f, 8b, 04, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 144
Number of expressions: 142
- expression 0 operands: lhs = Counter(2), rhs = Expression(12, Add)
- expression 1 operands: lhs = Expression(13, Add), rhs = Counter(16)
- expression 2 operands: lhs = Expression(14, Add), rhs = Counter(15)
- expression 3 operands: lhs = Counter(13), rhs = Counter(14)
- expression 4 operands: lhs = Counter(1), rhs = Zero
- expression 5 operands: lhs = Expression(143, Add), rhs = Counter(2)
- expression 5 operands: lhs = Expression(141, Add), rhs = Counter(2)
- expression 6 operands: lhs = Counter(1), rhs = Zero
- expression 7 operands: lhs = Counter(3), rhs = Counter(13)
- expression 8 operands: lhs = Expression(9, Sub), rhs = Counter(14)
@ -18,145 +18,143 @@ Number of expressions: 144
- expression 12 operands: lhs = Expression(13, Add), rhs = Counter(16)
- expression 13 operands: lhs = Expression(14, Add), rhs = Counter(15)
- expression 14 operands: lhs = Counter(13), rhs = Counter(14)
- expression 15 operands: lhs = Expression(142, Sub), rhs = Counter(3)
- expression 16 operands: lhs = Expression(143, Add), rhs = Counter(2)
- expression 15 operands: lhs = Expression(140, Sub), rhs = Counter(3)
- expression 16 operands: lhs = Expression(141, Add), rhs = Counter(2)
- expression 17 operands: lhs = Counter(1), rhs = Zero
- expression 18 operands: lhs = Expression(0, Add), rhs = Zero
- expression 19 operands: lhs = Counter(17), rhs = Zero
- expression 20 operands: lhs = Expression(33, Add), rhs = Counter(18)
- expression 21 operands: lhs = Counter(17), rhs = Zero
- expression 22 operands: lhs = Expression(32, Sub), rhs = Counter(12)
- expression 23 operands: lhs = Expression(33, Add), rhs = Counter(18)
- expression 24 operands: lhs = Counter(17), rhs = Zero
- expression 25 operands: lhs = Expression(31, Sub), rhs = Counter(19)
- expression 26 operands: lhs = Expression(32, Sub), rhs = Counter(12)
- expression 27 operands: lhs = Expression(33, Add), rhs = Counter(18)
- expression 28 operands: lhs = Counter(17), rhs = Zero
- expression 29 operands: lhs = Expression(30, Sub), rhs = Counter(20)
- expression 30 operands: lhs = Expression(31, Sub), rhs = Counter(19)
- expression 31 operands: lhs = Expression(32, Sub), rhs = Counter(12)
- expression 32 operands: lhs = Expression(33, Add), rhs = Counter(18)
- expression 33 operands: lhs = Counter(17), rhs = Zero
- expression 34 operands: lhs = Expression(42, Add), rhs = Counter(21)
- expression 35 operands: lhs = Counter(19), rhs = Counter(20)
- expression 36 operands: lhs = Expression(41, Add), rhs = Counter(22)
- expression 37 operands: lhs = Expression(42, Add), rhs = Counter(21)
- expression 38 operands: lhs = Counter(19), rhs = Counter(20)
- expression 39 operands: lhs = Counter(18), rhs = Expression(40, Add)
- expression 40 operands: lhs = Expression(41, Add), rhs = Counter(22)
- expression 41 operands: lhs = Expression(42, Add), rhs = Counter(21)
- expression 42 operands: lhs = Counter(19), rhs = Counter(20)
- expression 43 operands: lhs = Counter(24), rhs = Zero
- expression 44 operands: lhs = Expression(57, Add), rhs = Counter(25)
- expression 45 operands: lhs = Counter(24), rhs = Zero
- expression 46 operands: lhs = Expression(56, Sub), rhs = Counter(11)
- expression 47 operands: lhs = Expression(57, Add), rhs = Counter(25)
- expression 48 operands: lhs = Counter(24), rhs = Zero
- expression 49 operands: lhs = Expression(55, Sub), rhs = Counter(26)
- expression 50 operands: lhs = Expression(56, Sub), rhs = Counter(11)
- expression 51 operands: lhs = Expression(57, Add), rhs = Counter(25)
- expression 52 operands: lhs = Counter(24), rhs = Zero
- expression 53 operands: lhs = Expression(54, Sub), rhs = Counter(27)
- expression 54 operands: lhs = Expression(55, Sub), rhs = Counter(26)
- expression 55 operands: lhs = Expression(56, Sub), rhs = Counter(11)
- expression 56 operands: lhs = Expression(57, Add), rhs = Counter(25)
- expression 57 operands: lhs = Counter(24), rhs = Zero
- expression 58 operands: lhs = Expression(67, Add), rhs = Counter(28)
- expression 59 operands: lhs = Counter(26), rhs = Counter(27)
- expression 60 operands: lhs = Expression(66, Add), rhs = Counter(29)
- expression 61 operands: lhs = Expression(67, Add), rhs = Counter(28)
- expression 62 operands: lhs = Counter(26), rhs = Counter(27)
- expression 63 operands: lhs = Expression(64, Add), rhs = Zero
- expression 64 operands: lhs = Counter(25), rhs = Expression(65, Add)
- expression 65 operands: lhs = Expression(66, Add), rhs = Counter(29)
- expression 66 operands: lhs = Expression(67, Add), rhs = Counter(28)
- expression 67 operands: lhs = Counter(26), rhs = Counter(27)
- expression 68 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 69 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 70 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 71 operands: lhs = Counter(32), rhs = Counter(33)
- expression 72 operands: lhs = Counter(30), rhs = Zero
- expression 73 operands: lhs = Expression(86, Add), rhs = Counter(31)
- expression 74 operands: lhs = Counter(30), rhs = Zero
- expression 75 operands: lhs = Expression(85, Sub), rhs = Counter(10)
- expression 76 operands: lhs = Expression(86, Add), rhs = Counter(31)
- expression 77 operands: lhs = Counter(30), rhs = Zero
- expression 78 operands: lhs = Expression(84, Sub), rhs = Counter(32)
- expression 79 operands: lhs = Expression(85, Sub), rhs = Counter(10)
- expression 80 operands: lhs = Expression(86, Add), rhs = Counter(31)
- expression 81 operands: lhs = Counter(30), rhs = Zero
- expression 82 operands: lhs = Expression(83, Sub), rhs = Counter(33)
- expression 83 operands: lhs = Expression(84, Sub), rhs = Counter(32)
- expression 84 operands: lhs = Expression(85, Sub), rhs = Counter(10)
- expression 85 operands: lhs = Expression(86, Add), rhs = Counter(31)
- expression 86 operands: lhs = Counter(30), rhs = Zero
- expression 87 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 88 operands: lhs = Counter(32), rhs = Counter(33)
- expression 89 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 90 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 91 operands: lhs = Counter(32), rhs = Counter(33)
- expression 92 operands: lhs = Counter(4), rhs = Expression(134, Add)
- expression 93 operands: lhs = Expression(135, Add), rhs = Counter(8)
- expression 94 operands: lhs = Expression(136, Add), rhs = Counter(7)
- expression 95 operands: lhs = Counter(5), rhs = Counter(6)
- expression 96 operands: lhs = Expression(123, Add), rhs = Zero
- expression 97 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 98 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 99 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 100 operands: lhs = Counter(32), rhs = Counter(33)
- expression 101 operands: lhs = Expression(123, Add), rhs = Counter(4)
- expression 102 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 103 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 104 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 105 operands: lhs = Counter(32), rhs = Counter(33)
- expression 106 operands: lhs = Expression(122, Sub), rhs = Counter(9)
- expression 107 operands: lhs = Expression(123, Add), rhs = Counter(4)
- expression 108 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 109 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 110 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 111 operands: lhs = Counter(32), rhs = Counter(33)
- expression 112 operands: lhs = Expression(121, Sub), rhs = Counter(5)
- expression 113 operands: lhs = Expression(122, Sub), rhs = Counter(9)
- expression 114 operands: lhs = Expression(123, Add), rhs = Counter(4)
- expression 115 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 116 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 117 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 118 operands: lhs = Counter(32), rhs = Counter(33)
- expression 119 operands: lhs = Expression(120, Sub), rhs = Counter(6)
- expression 120 operands: lhs = Expression(121, Sub), rhs = Counter(5)
- expression 121 operands: lhs = Expression(122, Sub), rhs = Counter(9)
- expression 122 operands: lhs = Expression(123, Add), rhs = Counter(4)
- expression 123 operands: lhs = Counter(31), rhs = Expression(124, Add)
- expression 124 operands: lhs = Expression(125, Add), rhs = Counter(35)
- expression 125 operands: lhs = Expression(126, Add), rhs = Counter(34)
- expression 126 operands: lhs = Counter(32), rhs = Counter(33)
- expression 127 operands: lhs = Expression(136, Add), rhs = Counter(7)
- expression 128 operands: lhs = Counter(5), rhs = Counter(6)
- expression 129 operands: lhs = Expression(135, Add), rhs = Counter(8)
- expression 130 operands: lhs = Expression(136, Add), rhs = Counter(7)
- expression 131 operands: lhs = Counter(5), rhs = Counter(6)
- expression 132 operands: lhs = Expression(133, Add), rhs = Expression(137, Add)
- expression 133 operands: lhs = Counter(4), rhs = Expression(134, Add)
- expression 134 operands: lhs = Expression(135, Add), rhs = Counter(8)
- expression 135 operands: lhs = Expression(136, Add), rhs = Counter(7)
- expression 136 operands: lhs = Counter(5), rhs = Counter(6)
- expression 137 operands: lhs = Expression(138, Add), rhs = Expression(141, Sub)
- expression 138 operands: lhs = Expression(139, Add), rhs = Expression(140, Add)
- expression 139 operands: lhs = Counter(9), rhs = Counter(10)
- expression 140 operands: lhs = Counter(11), rhs = Counter(12)
- expression 141 operands: lhs = Expression(142, Sub), rhs = Counter(3)
- expression 142 operands: lhs = Expression(143, Add), rhs = Counter(2)
- expression 143 operands: lhs = Counter(1), rhs = Zero
- expression 18 operands: lhs = Counter(17), rhs = Zero
- expression 19 operands: lhs = Expression(32, Add), rhs = Counter(18)
- expression 20 operands: lhs = Counter(17), rhs = Zero
- expression 21 operands: lhs = Expression(31, Sub), rhs = Counter(12)
- expression 22 operands: lhs = Expression(32, Add), rhs = Counter(18)
- expression 23 operands: lhs = Counter(17), rhs = Zero
- expression 24 operands: lhs = Expression(30, Sub), rhs = Counter(19)
- expression 25 operands: lhs = Expression(31, Sub), rhs = Counter(12)
- expression 26 operands: lhs = Expression(32, Add), rhs = Counter(18)
- expression 27 operands: lhs = Counter(17), rhs = Zero
- expression 28 operands: lhs = Expression(29, Sub), rhs = Counter(20)
- expression 29 operands: lhs = Expression(30, Sub), rhs = Counter(19)
- expression 30 operands: lhs = Expression(31, Sub), rhs = Counter(12)
- expression 31 operands: lhs = Expression(32, Add), rhs = Counter(18)
- expression 32 operands: lhs = Counter(17), rhs = Zero
- expression 33 operands: lhs = Expression(41, Add), rhs = Counter(21)
- expression 34 operands: lhs = Counter(19), rhs = Counter(20)
- expression 35 operands: lhs = Expression(40, Add), rhs = Counter(22)
- expression 36 operands: lhs = Expression(41, Add), rhs = Counter(21)
- expression 37 operands: lhs = Counter(19), rhs = Counter(20)
- expression 38 operands: lhs = Counter(18), rhs = Expression(39, Add)
- expression 39 operands: lhs = Expression(40, Add), rhs = Counter(22)
- expression 40 operands: lhs = Expression(41, Add), rhs = Counter(21)
- expression 41 operands: lhs = Counter(19), rhs = Counter(20)
- expression 42 operands: lhs = Counter(24), rhs = Zero
- expression 43 operands: lhs = Expression(56, Add), rhs = Counter(25)
- expression 44 operands: lhs = Counter(24), rhs = Zero
- expression 45 operands: lhs = Expression(55, Sub), rhs = Counter(11)
- expression 46 operands: lhs = Expression(56, Add), rhs = Counter(25)
- expression 47 operands: lhs = Counter(24), rhs = Zero
- expression 48 operands: lhs = Expression(54, Sub), rhs = Counter(26)
- expression 49 operands: lhs = Expression(55, Sub), rhs = Counter(11)
- expression 50 operands: lhs = Expression(56, Add), rhs = Counter(25)
- expression 51 operands: lhs = Counter(24), rhs = Zero
- expression 52 operands: lhs = Expression(53, Sub), rhs = Counter(27)
- expression 53 operands: lhs = Expression(54, Sub), rhs = Counter(26)
- expression 54 operands: lhs = Expression(55, Sub), rhs = Counter(11)
- expression 55 operands: lhs = Expression(56, Add), rhs = Counter(25)
- expression 56 operands: lhs = Counter(24), rhs = Zero
- expression 57 operands: lhs = Expression(66, Add), rhs = Counter(28)
- expression 58 operands: lhs = Counter(26), rhs = Counter(27)
- expression 59 operands: lhs = Expression(65, Add), rhs = Counter(29)
- expression 60 operands: lhs = Expression(66, Add), rhs = Counter(28)
- expression 61 operands: lhs = Counter(26), rhs = Counter(27)
- expression 62 operands: lhs = Expression(63, Add), rhs = Zero
- expression 63 operands: lhs = Counter(25), rhs = Expression(64, Add)
- expression 64 operands: lhs = Expression(65, Add), rhs = Counter(29)
- expression 65 operands: lhs = Expression(66, Add), rhs = Counter(28)
- expression 66 operands: lhs = Counter(26), rhs = Counter(27)
- expression 67 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 68 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 69 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 70 operands: lhs = Counter(32), rhs = Counter(33)
- expression 71 operands: lhs = Counter(30), rhs = Zero
- expression 72 operands: lhs = Expression(85, Add), rhs = Counter(31)
- expression 73 operands: lhs = Counter(30), rhs = Zero
- expression 74 operands: lhs = Expression(84, Sub), rhs = Counter(10)
- expression 75 operands: lhs = Expression(85, Add), rhs = Counter(31)
- expression 76 operands: lhs = Counter(30), rhs = Zero
- expression 77 operands: lhs = Expression(83, Sub), rhs = Counter(32)
- expression 78 operands: lhs = Expression(84, Sub), rhs = Counter(10)
- expression 79 operands: lhs = Expression(85, Add), rhs = Counter(31)
- expression 80 operands: lhs = Counter(30), rhs = Zero
- expression 81 operands: lhs = Expression(82, Sub), rhs = Counter(33)
- expression 82 operands: lhs = Expression(83, Sub), rhs = Counter(32)
- expression 83 operands: lhs = Expression(84, Sub), rhs = Counter(10)
- expression 84 operands: lhs = Expression(85, Add), rhs = Counter(31)
- expression 85 operands: lhs = Counter(30), rhs = Zero
- expression 86 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 87 operands: lhs = Counter(32), rhs = Counter(33)
- expression 88 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 89 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 90 operands: lhs = Counter(32), rhs = Counter(33)
- expression 91 operands: lhs = Counter(4), rhs = Expression(132, Add)
- expression 92 operands: lhs = Expression(133, Add), rhs = Counter(8)
- expression 93 operands: lhs = Expression(134, Add), rhs = Counter(7)
- expression 94 operands: lhs = Counter(5), rhs = Counter(6)
- expression 95 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 96 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 97 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 98 operands: lhs = Counter(32), rhs = Counter(33)
- expression 99 operands: lhs = Expression(121, Add), rhs = Counter(4)
- expression 100 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 101 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 102 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 103 operands: lhs = Counter(32), rhs = Counter(33)
- expression 104 operands: lhs = Expression(120, Sub), rhs = Counter(9)
- expression 105 operands: lhs = Expression(121, Add), rhs = Counter(4)
- expression 106 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 107 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 108 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 109 operands: lhs = Counter(32), rhs = Counter(33)
- expression 110 operands: lhs = Expression(119, Sub), rhs = Counter(5)
- expression 111 operands: lhs = Expression(120, Sub), rhs = Counter(9)
- expression 112 operands: lhs = Expression(121, Add), rhs = Counter(4)
- expression 113 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 114 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 115 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 116 operands: lhs = Counter(32), rhs = Counter(33)
- expression 117 operands: lhs = Expression(118, Sub), rhs = Counter(6)
- expression 118 operands: lhs = Expression(119, Sub), rhs = Counter(5)
- expression 119 operands: lhs = Expression(120, Sub), rhs = Counter(9)
- expression 120 operands: lhs = Expression(121, Add), rhs = Counter(4)
- expression 121 operands: lhs = Counter(31), rhs = Expression(122, Add)
- expression 122 operands: lhs = Expression(123, Add), rhs = Counter(35)
- expression 123 operands: lhs = Expression(124, Add), rhs = Counter(34)
- expression 124 operands: lhs = Counter(32), rhs = Counter(33)
- expression 125 operands: lhs = Expression(134, Add), rhs = Counter(7)
- expression 126 operands: lhs = Counter(5), rhs = Counter(6)
- expression 127 operands: lhs = Expression(133, Add), rhs = Counter(8)
- expression 128 operands: lhs = Expression(134, Add), rhs = Counter(7)
- expression 129 operands: lhs = Counter(5), rhs = Counter(6)
- expression 130 operands: lhs = Expression(131, Add), rhs = Expression(135, Add)
- expression 131 operands: lhs = Counter(4), rhs = Expression(132, Add)
- expression 132 operands: lhs = Expression(133, Add), rhs = Counter(8)
- expression 133 operands: lhs = Expression(134, Add), rhs = Counter(7)
- expression 134 operands: lhs = Counter(5), rhs = Counter(6)
- expression 135 operands: lhs = Expression(136, Add), rhs = Expression(139, Sub)
- expression 136 operands: lhs = Expression(137, Add), rhs = Expression(138, Add)
- expression 137 operands: lhs = Counter(9), rhs = Counter(10)
- expression 138 operands: lhs = Counter(11), rhs = Counter(12)
- expression 139 operands: lhs = Expression(140, Sub), rhs = Counter(3)
- expression 140 operands: lhs = Expression(141, Add), rhs = Counter(2)
- expression 141 operands: lhs = Counter(1), rhs = Zero
Number of file 0 mappings: 68
- Code(Counter(0)) at (prev + 3, 1) to (start + 2, 12)
- Code(Counter(1)) at (prev + 2, 13) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Expression(0, Add)) at (prev + 3, 9) to (start + 0, 10)
= (c2 + (((c13 + c14) + c15) + c16))
- Code(Expression(143, Add)) at (prev + 0, 16) to (start + 0, 29)
- Code(Expression(141, Add)) at (prev + 0, 16) to (start + 0, 29)
= (c1 + Zero)
- Code(Counter(2)) at (prev + 1, 9) to (start + 1, 10)
- Code(Expression(142, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(140, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c1 + Zero) - c2)
- Code(Counter(3)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(9, Sub)) at (prev + 0, 29) to (start + 0, 42)
@ -168,94 +166,94 @@ Number of file 0 mappings: 68
- Code(Counter(16)) at (prev + 2, 10) to (start + 0, 11)
- Code(Expression(12, Add)) at (prev + 1, 9) to (start + 1, 18)
= (((c13 + c14) + c15) + c16)
- Code(Expression(141, Sub)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(139, Sub)) at (prev + 3, 9) to (start + 0, 15)
= (((c1 + Zero) - c2) - c3)
- Code(Expression(18, Add)) at (prev + 3, 9) to (start + 1, 12)
= ((c2 + (((c13 + c14) + c15) + c16)) + Zero)
- Code(Expression(0, Add)) at (prev + 3, 9) to (start + 1, 12)
= (c2 + (((c13 + c14) + c15) + c16))
- Code(Counter(17)) at (prev + 1, 13) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Expression(33, Add)) at (prev + 2, 8) to (start + 0, 21)
- Code(Expression(32, Add)) at (prev + 2, 8) to (start + 0, 21)
= (c17 + Zero)
- Code(Counter(18)) at (prev + 0, 22) to (start + 2, 6)
- Code(Expression(32, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(31, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c17 + Zero) - c18)
- Code(Expression(31, Sub)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(30, Sub)) at (prev + 1, 12) to (start + 0, 25)
= (((c17 + Zero) - c18) - c12)
- Code(Expression(30, Sub)) at (prev + 0, 29) to (start + 0, 42)
- Code(Expression(29, Sub)) at (prev + 0, 29) to (start + 0, 42)
= ((((c17 + Zero) - c18) - c12) - c19)
- Code(Expression(29, Sub)) at (prev + 0, 46) to (start + 0, 60)
- Code(Expression(28, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (((((c17 + Zero) - c18) - c12) - c19) - c20)
- Code(Expression(41, Add)) at (prev + 0, 61) to (start + 2, 10)
- Code(Expression(40, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c19 + c20) + c21)
- Code(Counter(22)) at (prev + 2, 10) to (start + 0, 11)
- Code(Expression(40, Add)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(39, Add)) at (prev + 1, 9) to (start + 0, 23)
= (((c19 + c20) + c21) + c22)
- Code(Counter(12)) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(39, Add)) at (prev + 3, 8) to (start + 0, 12)
- Code(Expression(38, Add)) at (prev + 3, 8) to (start + 0, 12)
= (c18 + (((c19 + c20) + c21) + c22))
- Code(Counter(23)) at (prev + 1, 13) to (start + 1, 16)
- Code(Counter(24)) at (prev + 1, 17) to (start + 2, 10)
- Code(Zero) at (prev + 2, 10) to (start + 0, 11)
- Code(Expression(57, Add)) at (prev + 2, 12) to (start + 0, 25)
- Code(Expression(56, Add)) at (prev + 2, 12) to (start + 0, 25)
= (c24 + Zero)
- Code(Counter(25)) at (prev + 0, 26) to (start + 2, 10)
- Code(Expression(56, Sub)) at (prev + 3, 17) to (start + 0, 30)
- Code(Expression(55, Sub)) at (prev + 3, 17) to (start + 0, 30)
= ((c24 + Zero) - c25)
- Code(Expression(55, Sub)) at (prev + 1, 16) to (start + 0, 29)
- Code(Expression(54, Sub)) at (prev + 1, 16) to (start + 0, 29)
= (((c24 + Zero) - c25) - c11)
- Code(Expression(54, Sub)) at (prev + 0, 33) to (start + 0, 46)
- Code(Expression(53, Sub)) at (prev + 0, 33) to (start + 0, 46)
= ((((c24 + Zero) - c25) - c11) - c26)
- Code(Expression(53, Sub)) at (prev + 0, 50) to (start + 0, 64)
- Code(Expression(52, Sub)) at (prev + 0, 50) to (start + 0, 64)
= (((((c24 + Zero) - c25) - c11) - c26) - c27)
- Code(Expression(66, Add)) at (prev + 0, 65) to (start + 2, 14)
- Code(Expression(65, Add)) at (prev + 0, 65) to (start + 2, 14)
= ((c26 + c27) + c28)
- Code(Counter(29)) at (prev + 2, 14) to (start + 0, 15)
- Code(Expression(65, Add)) at (prev + 1, 13) to (start + 0, 27)
- Code(Expression(64, Add)) at (prev + 1, 13) to (start + 0, 27)
= (((c26 + c27) + c28) + c29)
- Code(Counter(11)) at (prev + 2, 13) to (start + 0, 19)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Expression(63, Add)) at (prev + 2, 9) to (start + 1, 12)
- Code(Expression(62, Add)) at (prev + 2, 9) to (start + 1, 12)
= ((c25 + (((c26 + c27) + c28) + c29)) + Zero)
- Code(Counter(30)) at (prev + 1, 13) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Expression(123, Add)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(121, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c31 + (((c32 + c33) + c34) + c35))
- Code(Expression(86, Add)) at (prev + 0, 16) to (start + 0, 29)
- Code(Expression(85, Add)) at (prev + 0, 16) to (start + 0, 29)
= (c30 + Zero)
- Code(Counter(31)) at (prev + 0, 30) to (start + 2, 6)
- Code(Expression(85, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(84, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c30 + Zero) - c31)
- Code(Expression(84, Sub)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(83, Sub)) at (prev + 1, 12) to (start + 0, 25)
= (((c30 + Zero) - c31) - c10)
- Code(Expression(83, Sub)) at (prev + 0, 29) to (start + 0, 42)
- Code(Expression(82, Sub)) at (prev + 0, 29) to (start + 0, 42)
= ((((c30 + Zero) - c31) - c10) - c32)
- Code(Expression(82, Sub)) at (prev + 0, 46) to (start + 0, 60)
- Code(Expression(81, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (((((c30 + Zero) - c31) - c10) - c32) - c33)
- Code(Expression(125, Add)) at (prev + 0, 61) to (start + 2, 10)
- Code(Expression(123, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c32 + c33) + c34)
- Code(Counter(35)) at (prev + 2, 10) to (start + 0, 11)
- Code(Expression(124, Add)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(122, Add)) at (prev + 1, 9) to (start + 0, 23)
= (((c32 + c33) + c34) + c35)
- Code(Counter(10)) at (prev + 2, 13) to (start + 2, 15)
- Code(Expression(133, Add)) at (prev + 5, 9) to (start + 0, 10)
- Code(Expression(131, Add)) at (prev + 5, 9) to (start + 0, 10)
= (c4 + (((c5 + c6) + c7) + c8))
- Code(Expression(96, Add)) at (prev + 0, 16) to (start + 0, 29)
= ((c31 + (((c32 + c33) + c34) + c35)) + Zero)
- Code(Expression(121, Add)) at (prev + 0, 16) to (start + 0, 29)
= (c31 + (((c32 + c33) + c34) + c35))
- Code(Counter(4)) at (prev + 0, 30) to (start + 2, 6)
- Code(Expression(122, Sub)) at (prev + 2, 15) to (start + 0, 28)
- Code(Expression(120, Sub)) at (prev + 2, 15) to (start + 0, 28)
= ((c31 + (((c32 + c33) + c34) + c35)) - c4)
- Code(Expression(121, Sub)) at (prev + 1, 12) to (start + 0, 25)
- Code(Expression(119, Sub)) at (prev + 1, 12) to (start + 0, 25)
= (((c31 + (((c32 + c33) + c34) + c35)) - c4) - c9)
- Code(Expression(120, Sub)) at (prev + 0, 29) to (start + 0, 42)
- Code(Expression(118, Sub)) at (prev + 0, 29) to (start + 0, 42)
= ((((c31 + (((c32 + c33) + c34) + c35)) - c4) - c9) - c5)
- Code(Expression(119, Sub)) at (prev + 0, 46) to (start + 0, 60)
- Code(Expression(117, Sub)) at (prev + 0, 46) to (start + 0, 60)
= (((((c31 + (((c32 + c33) + c34) + c35)) - c4) - c9) - c5) - c6)
- Code(Expression(135, Add)) at (prev + 0, 61) to (start + 2, 10)
- Code(Expression(133, Add)) at (prev + 0, 61) to (start + 2, 10)
= ((c5 + c6) + c7)
- Code(Counter(8)) at (prev + 2, 10) to (start + 0, 11)
- Code(Expression(134, Add)) at (prev + 1, 9) to (start + 0, 23)
- Code(Expression(132, Add)) at (prev + 1, 9) to (start + 0, 23)
= (((c5 + c6) + c7) + c8)
- Code(Counter(9)) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(132, Add)) at (prev + 2, 1) to (start + 0, 2)
- Code(Expression(130, Add)) at (prev + 2, 1) to (start + 0, 2)
= ((c4 + (((c5 + c6) + c7) + c8)) + (((c9 + c10) + (c11 + c12)) + (((c1 + Zero) - c2) - c3)))

74
tests/coverage-map/status-quo/continue.cov-map
View File

@ -1,8 +1,8 @@
Function name: continue::main
Raw bytes (216): 0x[01, 01, 1f, 01, 07, 05, 09, 03, 0d, 0d, 1f, 11, 15, 1b, 19, 0d, 1f, 11, 15, 15, 00, 19, 37, 1d, 21, 33, 25, 19, 37, 1d, 21, 1d, 00, 25, 4f, 29, 2d, 4b, 31, 25, 4f, 29, 2d, 31, 67, 35, 39, 5f, 3d, 31, 67, 35, 39, 35, 39, 3d, 41, 73, 45, 3d, 41, 41, 00, 49, 45, 1e, 01, 03, 01, 03, 12, 03, 04, 0e, 00, 13, 0a, 01, 0f, 00, 16, 05, 02, 11, 00, 19, 09, 02, 12, 04, 0e, 1b, 06, 0e, 00, 13, 16, 01, 0f, 00, 16, 15, 01, 16, 02, 0e, 11, 04, 11, 00, 19, 23, 03, 09, 00, 0e, 33, 02, 0e, 00, 13, 2e, 01, 0f, 00, 16, 1d, 01, 15, 02, 0e, 21, 04, 11, 00, 19, 3b, 03, 09, 00, 0e, 4b, 02, 0e, 00, 13, 46, 01, 0c, 00, 13, 29, 01, 0d, 00, 15, 2d, 01, 0a, 01, 0e, 5f, 03, 0e, 00, 13, 5a, 01, 0f, 00, 16, 39, 01, 16, 02, 0e, 35, 03, 12, 02, 0e, 67, 04, 09, 00, 0e, 73, 02, 0e, 00, 13, 6e, 01, 0f, 00, 16, 41, 01, 16, 02, 0e, 49, 04, 11, 00, 16, 77, 03, 09, 00, 0e, 7b, 02, 0d, 01, 02]
Raw bytes (210): 0x[01, 01, 1c, 01, 07, 05, 09, 03, 0d, 0d, 1f, 11, 15, 1b, 19, 0d, 1f, 11, 15, 19, 33, 1d, 21, 2f, 25, 19, 33, 1d, 21, 25, 47, 29, 2d, 43, 31, 25, 47, 29, 2d, 31, 5f, 35, 39, 57, 3d, 31, 5f, 35, 39, 35, 39, 3d, 41, 6b, 45, 3d, 41, 49, 45, 1e, 01, 03, 01, 03, 12, 03, 04, 0e, 00, 13, 0a, 01, 0f, 00, 16, 05, 02, 11, 00, 19, 09, 02, 12, 04, 0e, 1b, 06, 0e, 00, 13, 16, 01, 0f, 00, 16, 15, 01, 16, 02, 0e, 11, 04, 11, 00, 19, 15, 03, 09, 00, 0e, 2f, 02, 0e, 00, 13, 2a, 01, 0f, 00, 16, 1d, 01, 15, 02, 0e, 21, 04, 11, 00, 19, 1d, 03, 09, 00, 0e, 43, 02, 0e, 00, 13, 3e, 01, 0c, 00, 13, 29, 01, 0d, 00, 15, 2d, 01, 0a, 01, 0e, 57, 03, 0e, 00, 13, 52, 01, 0f, 00, 16, 39, 01, 16, 02, 0e, 35, 03, 12, 02, 0e, 5f, 04, 09, 00, 0e, 6b, 02, 0e, 00, 13, 66, 01, 0f, 00, 16, 41, 01, 16, 02, 0e, 49, 04, 11, 00, 16, 41, 03, 09, 00, 0e, 6f, 02, 0d, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 31
Number of expressions: 28
- expression 0 operands: lhs = Counter(0), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
@ -11,29 +11,26 @@ Number of expressions: 31
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(6)
- expression 6 operands: lhs = Counter(3), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5)
- expression 8 operands: lhs = Counter(5), rhs = Zero
- expression 9 operands: lhs = Counter(6), rhs = Expression(13, Add)
- expression 10 operands: lhs = Counter(7), rhs = Counter(8)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(9)
- expression 12 operands: lhs = Counter(6), rhs = Expression(13, Add)
- expression 13 operands: lhs = Counter(7), rhs = Counter(8)
- expression 14 operands: lhs = Counter(7), rhs = Zero
- expression 15 operands: lhs = Counter(9), rhs = Expression(19, Add)
- expression 16 operands: lhs = Counter(10), rhs = Counter(11)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(12)
- expression 18 operands: lhs = Counter(9), rhs = Expression(19, Add)
- expression 19 operands: lhs = Counter(10), rhs = Counter(11)
- expression 20 operands: lhs = Counter(12), rhs = Expression(25, Add)
- expression 21 operands: lhs = Counter(13), rhs = Counter(14)
- expression 22 operands: lhs = Expression(23, Add), rhs = Counter(15)
- expression 23 operands: lhs = Counter(12), rhs = Expression(25, Add)
- expression 24 operands: lhs = Counter(13), rhs = Counter(14)
- expression 25 operands: lhs = Counter(13), rhs = Counter(14)
- expression 8 operands: lhs = Counter(6), rhs = Expression(12, Add)
- expression 9 operands: lhs = Counter(7), rhs = Counter(8)
- expression 10 operands: lhs = Expression(11, Add), rhs = Counter(9)
- expression 11 operands: lhs = Counter(6), rhs = Expression(12, Add)
- expression 12 operands: lhs = Counter(7), rhs = Counter(8)
- expression 13 operands: lhs = Counter(9), rhs = Expression(17, Add)
- expression 14 operands: lhs = Counter(10), rhs = Counter(11)
- expression 15 operands: lhs = Expression(16, Add), rhs = Counter(12)
- expression 16 operands: lhs = Counter(9), rhs = Expression(17, Add)
- expression 17 operands: lhs = Counter(10), rhs = Counter(11)
- expression 18 operands: lhs = Counter(12), rhs = Expression(23, Add)
- expression 19 operands: lhs = Counter(13), rhs = Counter(14)
- expression 20 operands: lhs = Expression(21, Add), rhs = Counter(15)
- expression 21 operands: lhs = Counter(12), rhs = Expression(23, Add)
- expression 22 operands: lhs = Counter(13), rhs = Counter(14)
- expression 23 operands: lhs = Counter(13), rhs = Counter(14)
- expression 24 operands: lhs = Counter(15), rhs = Counter(16)
- expression 25 operands: lhs = Expression(26, Add), rhs = Counter(17)
- expression 26 operands: lhs = Counter(15), rhs = Counter(16)
- expression 27 operands: lhs = Expression(28, Add), rhs = Counter(17)
- expression 28 operands: lhs = Counter(15), rhs = Counter(16)
- expression 29 operands: lhs = Counter(16), rhs = Zero
- expression 30 operands: lhs = Counter(18), rhs = Counter(17)
- expression 27 operands: lhs = Counter(18), rhs = Counter(17)
Number of file 0 mappings: 30
- Code(Counter(0)) at (prev + 3, 1) to (start + 3, 18)
- Code(Expression(0, Add)) at (prev + 4, 14) to (start + 0, 19)
@ -48,38 +45,35 @@ Number of file 0 mappings: 30
= ((c3 + (c4 + c5)) - c6)
- Code(Counter(5)) at (prev + 1, 22) to (start + 2, 14)
- Code(Counter(4)) at (prev + 4, 17) to (start + 0, 25)
- Code(Expression(8, Add)) at (prev + 3, 9) to (start + 0, 14)
= (c5 + Zero)
- Code(Expression(12, Add)) at (prev + 2, 14) to (start + 0, 19)
- Code(Counter(5)) at (prev + 3, 9) to (start + 0, 14)
- Code(Expression(11, Add)) at (prev + 2, 14) to (start + 0, 19)
= (c6 + (c7 + c8))
- Code(Expression(11, Sub)) at (prev + 1, 15) to (start + 0, 22)
- Code(Expression(10, Sub)) at (prev + 1, 15) to (start + 0, 22)
= ((c6 + (c7 + c8)) - c9)
- Code(Counter(7)) at (prev + 1, 21) to (start + 2, 14)
- Code(Counter(8)) at (prev + 4, 17) to (start + 0, 25)
- Code(Expression(14, Add)) at (prev + 3, 9) to (start + 0, 14)
= (c7 + Zero)
- Code(Expression(18, Add)) at (prev + 2, 14) to (start + 0, 19)
- Code(Counter(7)) at (prev + 3, 9) to (start + 0, 14)
- Code(Expression(16, Add)) at (prev + 2, 14) to (start + 0, 19)
= (c9 + (c10 + c11))
- Code(Expression(17, Sub)) at (prev + 1, 12) to (start + 0, 19)
- Code(Expression(15, Sub)) at (prev + 1, 12) to (start + 0, 19)
= ((c9 + (c10 + c11)) - c12)
- Code(Counter(10)) at (prev + 1, 13) to (start + 0, 21)
- Code(Counter(11)) at (prev + 1, 10) to (start + 1, 14)
- Code(Expression(23, Add)) at (prev + 3, 14) to (start + 0, 19)
- Code(Expression(21, Add)) at (prev + 3, 14) to (start + 0, 19)
= (c12 + (c13 + c14))
- Code(Expression(22, Sub)) at (prev + 1, 15) to (start + 0, 22)
- Code(Expression(20, Sub)) at (prev + 1, 15) to (start + 0, 22)
= ((c12 + (c13 + c14)) - c15)
- Code(Counter(14)) at (prev + 1, 22) to (start + 2, 14)
- Code(Counter(13)) at (prev + 3, 18) to (start + 2, 14)
- Code(Expression(25, Add)) at (prev + 4, 9) to (start + 0, 14)
- Code(Expression(23, Add)) at (prev + 4, 9) to (start + 0, 14)
= (c13 + c14)
- Code(Expression(28, Add)) at (prev + 2, 14) to (start + 0, 19)
- Code(Expression(26, Add)) at (prev + 2, 14) to (start + 0, 19)
= (c15 + c16)
- Code(Expression(27, Sub)) at (prev + 1, 15) to (start + 0, 22)
- Code(Expression(25, Sub)) at (prev + 1, 15) to (start + 0, 22)
= ((c15 + c16) - c17)
- Code(Counter(16)) at (prev + 1, 22) to (start + 2, 14)
- Code(Counter(18)) at (prev + 4, 17) to (start + 0, 22)
- Code(Expression(29, Add)) at (prev + 3, 9) to (start + 0, 14)
= (c16 + Zero)
- Code(Expression(30, Add)) at (prev + 2, 13) to (start + 1, 2)
- Code(Counter(16)) at (prev + 3, 9) to (start + 0, 14)
- Code(Expression(27, Add)) at (prev + 2, 13) to (start + 1, 2)
= (c18 + c17)

8
tests/coverage-map/status-quo/dead_code.cov-map
View File

@ -14,23 +14,23 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1))
Function name: dead_code::unused_fn (unused)
Raw bytes (24): 0x[01, 01, 00, 04, 01, 0f, 01, 07, 0f, 00, 07, 10, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Raw bytes (24): 0x[01, 01, 00, 04, 00, 0f, 01, 07, 0f, 00, 07, 10, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 15, 1) to (start + 7, 15)
- Code(Zero) at (prev + 15, 1) to (start + 7, 15)
- Code(Zero) at (prev + 7, 16) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
Function name: dead_code::unused_pub_fn_not_in_library (unused)
Raw bytes (24): 0x[01, 01, 00, 04, 01, 03, 01, 07, 0f, 00, 07, 10, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Raw bytes (24): 0x[01, 01, 00, 04, 00, 03, 01, 07, 0f, 00, 07, 10, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 3, 1) to (start + 7, 15)
- Code(Zero) at (prev + 3, 1) to (start + 7, 15)
- Code(Zero) at (prev + 7, 16) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)

39
tests/coverage-map/status-quo/generator.cov-map
View File

@ -14,38 +14,33 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1))
Function name: generator::main
Raw bytes (71): 0x[01, 01, 0b, 01, 00, 05, 0b, 09, 0d, 11, 00, 11, 15, 2a, 19, 11, 15, 15, 19, 26, 00, 2a, 19, 11, 15, 09, 01, 0f, 01, 02, 16, 03, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 07, 01, 0e, 00, 35, 0f, 02, 0b, 00, 2e, 2a, 01, 22, 00, 27, 26, 00, 2c, 00, 2e, 1f, 01, 0e, 00, 35, 23, 02, 01, 00, 02]
Raw bytes (65): 0x[01, 01, 08, 05, 07, 09, 0d, 11, 15, 1e, 19, 11, 15, 15, 19, 1e, 19, 11, 15, 09, 01, 0f, 01, 02, 16, 01, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 03, 01, 0e, 00, 35, 11, 02, 0b, 00, 2e, 1e, 01, 22, 00, 27, 1a, 00, 2c, 00, 2e, 17, 01, 0e, 00, 35, 1a, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 11
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(1), rhs = Expression(2, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 3 operands: lhs = Counter(4), rhs = Zero
Number of expressions: 8
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(4), rhs = Counter(5)
- expression 3 operands: lhs = Expression(7, Sub), rhs = Counter(6)
- expression 4 operands: lhs = Counter(4), rhs = Counter(5)
- expression 5 operands: lhs = Expression(10, Sub), rhs = Counter(6)
- expression 6 operands: lhs = Counter(4), rhs = Counter(5)
- expression 7 operands: lhs = Counter(5), rhs = Counter(6)
- expression 8 operands: lhs = Expression(9, Sub), rhs = Zero
- expression 9 operands: lhs = Expression(10, Sub), rhs = Counter(6)
- expression 10 operands: lhs = Counter(4), rhs = Counter(5)
- expression 5 operands: lhs = Counter(5), rhs = Counter(6)
- expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(6)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 22)
- Code(Expression(0, Add)) at (prev + 7, 11) to (start + 0, 46)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 7, 11) to (start + 0, 46)
- Code(Counter(4)) at (prev + 1, 43) to (start + 0, 45)
- Code(Expression(1, Add)) at (prev + 1, 14) to (start + 0, 53)
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 53)
= (c1 + (c2 + c3))
- Code(Expression(3, Add)) at (prev + 2, 11) to (start + 0, 46)
= (c4 + Zero)
- Code(Expression(10, Sub)) at (prev + 1, 34) to (start + 0, 39)
- Code(Counter(4)) at (prev + 2, 11) to (start + 0, 46)
- Code(Expression(7, Sub)) at (prev + 1, 34) to (start + 0, 39)
= (c4 - c5)
- Code(Expression(9, Sub)) at (prev + 0, 44) to (start + 0, 46)
- Code(Expression(6, Sub)) at (prev + 0, 44) to (start + 0, 46)
= ((c4 - c5) - c6)
- Code(Expression(7, Add)) at (prev + 1, 14) to (start + 0, 53)
- Code(Expression(5, Add)) at (prev + 1, 14) to (start + 0, 53)
= (c5 + c6)
- Code(Expression(8, Add)) at (prev + 2, 1) to (start + 0, 2)
= (((c4 - c5) - c6) + Zero)
- Code(Expression(6, Sub)) at (prev + 2, 1) to (start + 0, 2)
= ((c4 - c5) - c6)
Function name: generator::main::{closure#0}
Raw bytes (14): 0x[01, 01, 00, 02, 01, 11, 1c, 01, 1f, 05, 02, 10, 01, 06]

12
tests/coverage-map/status-quo/inline-dead.cov-map
View File

@ -1,10 +1,10 @@
Function name: inline_dead::dead (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 19, 01, 02, 02]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 19, 01, 02, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 25, 1) to (start + 2, 2)
- Code(Zero) at (prev + 25, 1) to (start + 2, 2)
Function name: inline_dead::live::<false>
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 10, 01, 01, 09, 00, 02, 09, 00, 0f, 02, 02, 09, 00, 0a, 07, 02, 01, 00, 02]
@ -22,15 +22,13 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1))
Function name: inline_dead::main
Raw bytes (16): 0x[01, 01, 01, 01, 00, 02, 01, 04, 01, 03, 0d, 03, 07, 06, 02, 02]
Raw bytes (14): 0x[01, 01, 00, 02, 01, 04, 01, 03, 0d, 01, 07, 06, 02, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 1
- expression 0 operands: lhs = Counter(0), rhs = Zero
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 4, 1) to (start + 3, 13)
- Code(Expression(0, Add)) at (prev + 7, 6) to (start + 2, 2)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 7, 6) to (start + 2, 2)
Function name: inline_dead::main::{closure#0}
Raw bytes (16): 0x[01, 01, 01, 01, 05, 02, 00, 09, 0d, 00, 0e, 03, 02, 05, 00, 06]

26
tests/coverage-map/status-quo/inline.cov-map
View File

@ -1,19 +1,17 @@
Function name: inline::display::<char>
Raw bytes (35): 0x[01, 01, 03, 01, 05, 05, 00, 03, 05, 05, 01, 29, 01, 00, 22, 05, 01, 09, 00, 0a, 03, 00, 0e, 00, 10, 07, 00, 11, 02, 06, 0a, 03, 05, 01, 02]
Raw bytes (33): 0x[01, 01, 02, 01, 05, 03, 05, 05, 01, 29, 01, 00, 22, 05, 01, 09, 00, 0a, 03, 00, 0e, 00, 10, 05, 00, 11, 02, 06, 06, 03, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Zero
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Add), rhs = Counter(1)
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 41, 1) to (start + 0, 34)
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 16)
= (c0 + c1)
- Code(Expression(1, Add)) at (prev + 0, 17) to (start + 2, 6)
= (c1 + Zero)
- Code(Expression(2, Sub)) at (prev + 3, 5) to (start + 1, 2)
- Code(Counter(1)) at (prev + 0, 17) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 3, 5) to (start + 1, 2)
= ((c0 + c1) - c1)
Function name: inline::error
@ -41,15 +39,14 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 5, 1) to (start + 2, 2)
Function name: inline::permutate::<char>
Raw bytes (54): 0x[01, 01, 05, 01, 05, 02, 0d, 11, 00, 05, 13, 09, 0d, 08, 01, 0f, 01, 02, 0e, 05, 02, 0f, 02, 06, 02, 02, 0f, 00, 14, 11, 01, 0d, 00, 0e, 06, 00, 12, 00, 16, 0b, 00, 17, 04, 0a, 0d, 05, 0c, 02, 06, 0f, 03, 01, 00, 02]
Raw bytes (52): 0x[01, 01, 04, 01, 05, 02, 0d, 05, 0f, 09, 0d, 08, 01, 0f, 01, 02, 0e, 05, 02, 0f, 02, 06, 02, 02, 0f, 00, 14, 11, 01, 0d, 00, 0e, 06, 00, 12, 00, 16, 11, 00, 17, 04, 0a, 0d, 05, 0c, 02, 06, 0b, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 5
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Counter(3)
- expression 2 operands: lhs = Counter(4), rhs = Zero
- expression 3 operands: lhs = Counter(1), rhs = Expression(4, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 14)
- Code(Counter(1)) at (prev + 2, 15) to (start + 2, 6)
@ -58,10 +55,9 @@ Number of file 0 mappings: 8
- Code(Counter(4)) at (prev + 1, 13) to (start + 0, 14)
- Code(Expression(1, Sub)) at (prev + 0, 18) to (start + 0, 22)
= ((c0 - c1) - c3)
- Code(Expression(2, Add)) at (prev + 0, 23) to (start + 4, 10)
= (c4 + Zero)
- Code(Counter(4)) at (prev + 0, 23) to (start + 4, 10)
- Code(Counter(3)) at (prev + 5, 12) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 3, 1) to (start + 0, 2)
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c1 + (c2 + c3))
Function name: inline::permutations::<char>

8
tests/coverage-map/status-quo/issue-93054.cov-map
View File

@ -1,10 +1,10 @@
Function name: issue_93054::foo2 (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 16, 01, 00, 1d]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 16, 01, 00, 1d]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 29)
- Code(Zero) at (prev + 22, 1) to (start + 0, 29)
Function name: issue_93054::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1e, 01, 00, 0d]
@ -15,10 +15,10 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 30, 1) to (start + 0, 13)
Function name: issue_93054::make (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1a, 01, 02, 02]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 1a, 01, 02, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 26, 1) to (start + 2, 2)
- Code(Zero) at (prev + 26, 1) to (start + 2, 2)

380
tests/coverage-map/status-quo/lazy_boolean.cov-map
View File

@ -1,223 +1,219 @@
Function name: lazy_boolean::main
Raw bytes (646): 0x[01, 01, a8, 01, 01, 05, 09, 9a, 05, 9f, 05, 09, 05, 02, 05, 02, 9f, 05, 09, 05, 02, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 97, 05, 00, 09, 9a, 05, 9f, 05, 09, 05, 02, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 8f, 05, 00, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 87, 05, 00, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, ff, 04, 00, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 1d, f2, 04, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, ef, 04, 21, 1d, f2, 04, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 21, ea, 04, ef, 04, 21, 1d, f2, 04, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, e7, 04, 25, 21, ea, 04, ef, 04, 21, 1d, f2, 04, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 25, e2, 04, e7, 04, 25, 21, ea, 04, ef, 04, 21, 1d, f2, 04, f7, 04, 1d, 19, fa, 04, ff, 04, 19, 15, 82, 05, 87, 05, 15, 11, 8a, 05, 8f, 05, 11, 0d, 92, 05, 97, 05, 0d, 09, 9a, 05, 9f, 05, 09, 05, 02, 1c, 01, 03, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 06, 00, 07, 97, 05, 02, 09, 00, 11, 9f, 05, 02, 0d, 00, 12, 9a, 05, 02, 0d, 00, 12, 8f, 05, 03, 09, 00, 11, 33, 02, 0d, 00, 12, 92, 05, 02, 0d, 00, 12, 87, 05, 02, 09, 00, 11, 6f, 00, 14, 00, 19, 11, 00, 1d, 00, 22, ff, 04, 01, 09, 00, 11, ab, 01, 00, 14, 00, 19, 15, 00, 1d, 00, 22, cb, 01, 04, 09, 00, 10, fa, 04, 01, 05, 03, 06, 19, 03, 06, 00, 07, f7, 04, 03, 09, 00, 10, 1d, 01, 05, 03, 06, f2, 04, 05, 05, 03, 06, ef, 04, 05, 09, 00, 10, ea, 04, 00, 11, 02, 06, 21, 02, 06, 00, 07, e7, 04, 02, 08, 00, 0f, 25, 00, 10, 02, 06, e2, 04, 02, 0c, 02, 06, df, 04, 03, 01, 00, 02]
Raw bytes (636): 0x[01, 01, a4, 01, 01, 05, 09, 8a, 05, 8f, 05, 09, 05, 02, 05, 02, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 09, 8a, 05, 8f, 05, 09, 05, 02, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 25, d2, 04, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1c, 01, 03, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 06, 00, 07, 87, 05, 02, 09, 00, 11, 8f, 05, 02, 0d, 00, 12, 8a, 05, 02, 0d, 00, 12, ff, 04, 03, 09, 00, 11, 87, 05, 02, 0d, 00, 12, 82, 05, 02, 0d, 00, 12, f7, 04, 02, 09, 00, 11, ff, 04, 00, 14, 00, 19, 11, 00, 1d, 00, 22, ef, 04, 01, 09, 00, 11, f7, 04, 00, 14, 00, 19, 15, 00, 1d, 00, 22, ef, 04, 04, 09, 00, 10, ea, 04, 01, 05, 03, 06, 19, 03, 06, 00, 07, e7, 04, 03, 09, 00, 10, 1d, 01, 05, 03, 06, e2, 04, 05, 05, 03, 06, df, 04, 05, 09, 00, 10, da, 04, 00, 11, 02, 06, 21, 02, 06, 00, 07, d7, 04, 02, 08, 00, 0f, 25, 00, 10, 02, 06, d2, 04, 02, 0c, 02, 06, cf, 04, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 168
Number of expressions: 164
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 2 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 1 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 2 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 4 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 5 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 5 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 6 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 7 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 8 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 9 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 10 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 7 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 8 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 9 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 10 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 11 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 12 operands: lhs = Expression(165, Add), rhs = Zero
- expression 13 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 14 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 15 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 16 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 17 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 18 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 19 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 20 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 21 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 22 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 23 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 24 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 25 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 26 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 27 operands: lhs = Expression(163, Add), rhs = Zero
- expression 28 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 29 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 30 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 31 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 32 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 33 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 34 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 35 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 36 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 37 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 38 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 39 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 40 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 41 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 42 operands: lhs = Expression(161, Add), rhs = Zero
- expression 43 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 44 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 45 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 46 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 47 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 48 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 49 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 50 operands: lhs = Expression(159, Add), rhs = Zero
- expression 51 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 52 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 53 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 54 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 55 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 56 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 57 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 58 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 59 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 60 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 61 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 62 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 63 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 64 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 65 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 66 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 67 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 68 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 69 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 70 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 71 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 72 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 73 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 74 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 75 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 76 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 77 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 78 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 79 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 80 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 81 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 82 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 83 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 84 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 85 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 86 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 87 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 88 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 89 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 90 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 91 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 92 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 93 operands: lhs = Counter(7), rhs = Expression(156, Sub)
- expression 94 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 95 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 96 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 97 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 98 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 99 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 100 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 101 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 102 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 103 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 104 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 105 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 106 operands: lhs = Expression(155, Add), rhs = Counter(8)
- expression 107 operands: lhs = Counter(7), rhs = Expression(156, Sub)
- expression 108 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 109 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 110 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 111 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 112 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 113 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 114 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 115 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 116 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 117 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 118 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 119 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 120 operands: lhs = Counter(8), rhs = Expression(154, Sub)
- expression 121 operands: lhs = Expression(155, Add), rhs = Counter(8)
- expression 122 operands: lhs = Counter(7), rhs = Expression(156, Sub)
- expression 123 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 124 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 125 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 126 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 127 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 128 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 129 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 130 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 131 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 132 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 133 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 134 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 135 operands: lhs = Expression(153, Add), rhs = Counter(9)
- expression 136 operands: lhs = Counter(8), rhs = Expression(154, Sub)
- expression 137 operands: lhs = Expression(155, Add), rhs = Counter(8)
- expression 138 operands: lhs = Counter(7), rhs = Expression(156, Sub)
- expression 139 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 140 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 141 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 142 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 143 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 144 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 145 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 146 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 147 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 148 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 149 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 150 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 151 operands: lhs = Counter(9), rhs = Expression(152, Sub)
- expression 152 operands: lhs = Expression(153, Add), rhs = Counter(9)
- expression 153 operands: lhs = Counter(8), rhs = Expression(154, Sub)
- expression 154 operands: lhs = Expression(155, Add), rhs = Counter(8)
- expression 155 operands: lhs = Counter(7), rhs = Expression(156, Sub)
- expression 156 operands: lhs = Expression(157, Add), rhs = Counter(7)
- expression 157 operands: lhs = Counter(6), rhs = Expression(158, Sub)
- expression 158 operands: lhs = Expression(159, Add), rhs = Counter(6)
- expression 159 operands: lhs = Counter(5), rhs = Expression(160, Sub)
- expression 160 operands: lhs = Expression(161, Add), rhs = Counter(5)
- expression 161 operands: lhs = Counter(4), rhs = Expression(162, Sub)
- expression 162 operands: lhs = Expression(163, Add), rhs = Counter(4)
- expression 163 operands: lhs = Counter(3), rhs = Expression(164, Sub)
- expression 164 operands: lhs = Expression(165, Add), rhs = Counter(3)
- expression 165 operands: lhs = Counter(2), rhs = Expression(166, Sub)
- expression 166 operands: lhs = Expression(167, Add), rhs = Counter(2)
- expression 167 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 12 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 13 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 14 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 15 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 16 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 17 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 18 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 19 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 20 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 21 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 22 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 23 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 24 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 25 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 26 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 27 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 28 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 29 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 30 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 31 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 32 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 33 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 34 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 35 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 36 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 37 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 38 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 39 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 40 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 41 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 42 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 43 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 44 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 45 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 46 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 47 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 48 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 49 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 50 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 51 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 52 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 53 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 54 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 55 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 56 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 57 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 58 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 59 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 60 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 61 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 62 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 63 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 64 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 65 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 66 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 67 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 68 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 69 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 70 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 71 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 72 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 73 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 74 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 75 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 76 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 77 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 78 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 79 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 80 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 81 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 82 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 83 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 84 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 85 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 86 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 87 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 88 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 89 operands: lhs = Counter(7), rhs = Expression(152, Sub)
- expression 90 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 91 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 92 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 93 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 94 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 95 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 96 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 97 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 98 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 99 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 100 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 101 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 102 operands: lhs = Expression(151, Add), rhs = Counter(8)
- expression 103 operands: lhs = Counter(7), rhs = Expression(152, Sub)
- expression 104 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 105 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 106 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 107 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 108 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 109 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 110 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 111 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 112 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 113 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 114 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 115 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 116 operands: lhs = Counter(8), rhs = Expression(150, Sub)
- expression 117 operands: lhs = Expression(151, Add), rhs = Counter(8)
- expression 118 operands: lhs = Counter(7), rhs = Expression(152, Sub)
- expression 119 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 120 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 121 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 122 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 123 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 124 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 125 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 126 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 127 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 128 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 129 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 130 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 131 operands: lhs = Expression(149, Add), rhs = Counter(9)
- expression 132 operands: lhs = Counter(8), rhs = Expression(150, Sub)
- expression 133 operands: lhs = Expression(151, Add), rhs = Counter(8)
- expression 134 operands: lhs = Counter(7), rhs = Expression(152, Sub)
- expression 135 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 136 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 137 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 138 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 139 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 140 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 141 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 142 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 143 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 144 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 145 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 146 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 147 operands: lhs = Counter(9), rhs = Expression(148, Sub)
- expression 148 operands: lhs = Expression(149, Add), rhs = Counter(9)
- expression 149 operands: lhs = Counter(8), rhs = Expression(150, Sub)
- expression 150 operands: lhs = Expression(151, Add), rhs = Counter(8)
- expression 151 operands: lhs = Counter(7), rhs = Expression(152, Sub)
- expression 152 operands: lhs = Expression(153, Add), rhs = Counter(7)
- expression 153 operands: lhs = Counter(6), rhs = Expression(154, Sub)
- expression 154 operands: lhs = Expression(155, Add), rhs = Counter(6)
- expression 155 operands: lhs = Counter(5), rhs = Expression(156, Sub)
- expression 156 operands: lhs = Expression(157, Add), rhs = Counter(5)
- expression 157 operands: lhs = Counter(4), rhs = Expression(158, Sub)
- expression 158 operands: lhs = Expression(159, Add), rhs = Counter(4)
- expression 159 operands: lhs = Counter(3), rhs = Expression(160, Sub)
- expression 160 operands: lhs = Expression(161, Add), rhs = Counter(3)
- expression 161 operands: lhs = Counter(2), rhs = Expression(162, Sub)
- expression 162 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 163 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 28
- Code(Counter(0)) at (prev + 3, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 4, 6)
- Code(Expression(0, Sub)) at (prev + 4, 6) to (start + 0, 7)
= (c0 - c1)
- Code(Expression(165, Add)) at (prev + 2, 9) to (start + 0, 17)
= (c2 + ((c1 + (c0 - c1)) - c2))
- Code(Expression(167, Add)) at (prev + 2, 13) to (start + 0, 18)
= (c1 + (c0 - c1))
- Code(Expression(166, Sub)) at (prev + 2, 13) to (start + 0, 18)
= ((c1 + (c0 - c1)) - c2)
- Code(Expression(163, Add)) at (prev + 3, 9) to (start + 0, 17)
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
- Code(Expression(12, Add)) at (prev + 2, 13) to (start + 0, 18)
= ((c2 + ((c1 + (c0 - c1)) - c2)) + Zero)
- Code(Expression(164, Sub)) at (prev + 2, 13) to (start + 0, 18)
= ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)
- Code(Expression(161, Add)) at (prev + 2, 9) to (start + 0, 17)
= (c2 + ((c1 + (c0 - c1)) - c2))
- Code(Expression(163, Add)) at (prev + 2, 13) to (start + 0, 18)
= (c1 + (c0 - c1))
- Code(Expression(162, Sub)) at (prev + 2, 13) to (start + 0, 18)
= ((c1 + (c0 - c1)) - c2)
- Code(Expression(159, Add)) at (prev + 3, 9) to (start + 0, 17)
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
- Code(Expression(161, Add)) at (prev + 2, 13) to (start + 0, 18)
= (c2 + ((c1 + (c0 - c1)) - c2))
- Code(Expression(160, Sub)) at (prev + 2, 13) to (start + 0, 18)
= ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)
- Code(Expression(157, Add)) at (prev + 2, 9) to (start + 0, 17)
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
- Code(Expression(27, Add)) at (prev + 0, 20) to (start + 0, 25)
= ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) + Zero)
- Code(Expression(159, Add)) at (prev + 0, 20) to (start + 0, 25)
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
- Code(Counter(4)) at (prev + 0, 29) to (start + 0, 34)
- Code(Expression(159, Add)) at (prev + 1, 9) to (start + 0, 17)
- Code(Expression(155, Add)) at (prev + 1, 9) to (start + 0, 17)
= (c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5))
- Code(Expression(42, Add)) at (prev + 0, 20) to (start + 0, 25)
= ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) + Zero)
- Code(Expression(157, Add)) at (prev + 0, 20) to (start + 0, 25)
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
- Code(Counter(5)) at (prev + 0, 29) to (start + 0, 34)
- Code(Expression(50, Add)) at (prev + 4, 9) to (start + 0, 16)
= ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) + Zero)
- Code(Expression(158, Sub)) at (prev + 1, 5) to (start + 3, 6)
- Code(Expression(155, Add)) at (prev + 4, 9) to (start + 0, 16)
= (c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5))
- Code(Expression(154, Sub)) at (prev + 1, 5) to (start + 3, 6)
= ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)
- Code(Counter(6)) at (prev + 3, 6) to (start + 0, 7)
- Code(Expression(157, Add)) at (prev + 3, 9) to (start + 0, 16)
- Code(Expression(153, Add)) at (prev + 3, 9) to (start + 0, 16)
= (c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6))
- Code(Counter(7)) at (prev + 1, 5) to (start + 3, 6)
- Code(Expression(156, Sub)) at (prev + 5, 5) to (start + 3, 6)
- Code(Expression(152, Sub)) at (prev + 5, 5) to (start + 3, 6)
= ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7)
- Code(Expression(155, Add)) at (prev + 5, 9) to (start + 0, 16)
- Code(Expression(151, Add)) at (prev + 5, 9) to (start + 0, 16)
= (c7 + ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7))
- Code(Expression(154, Sub)) at (prev + 0, 17) to (start + 2, 6)
- Code(Expression(150, Sub)) at (prev + 0, 17) to (start + 2, 6)
= ((c7 + ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7)) - c8)
- Code(Counter(8)) at (prev + 2, 6) to (start + 0, 7)
- Code(Expression(153, Add)) at (prev + 2, 8) to (start + 0, 15)
- Code(Expression(149, Add)) at (prev + 2, 8) to (start + 0, 15)
= (c8 + ((c7 + ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7)) - c8))
- Code(Counter(9)) at (prev + 0, 16) to (start + 2, 6)
- Code(Expression(152, Sub)) at (prev + 2, 12) to (start + 2, 6)
- Code(Expression(148, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c8 + ((c7 + ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7)) - c8)) - c9)
- Code(Expression(151, Add)) at (prev + 3, 1) to (start + 0, 2)
- Code(Expression(147, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c9 + ((c8 + ((c7 + ((c6 + ((c5 + ((c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) - c5)) - c6)) - c7)) - c8)) - c9))

218
tests/coverage-map/status-quo/loops_branches.cov-map
View File

@ -1,58 +1,57 @@
Function name: <loops_branches::DebugTest as core::fmt::Debug>::fmt
Raw bytes (251): 0x[01, 01, 32, 05, 09, 00, 02, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, c3, 01, c7, 01, 0d, 00, 11, 15, ba, 01, 00, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, ba, 01, 15, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, b6, 01, 1d, ba, 01, 15, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, 00, b2, 01, b6, 01, 1d, ba, 01, 15, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, af, 01, 11, 00, b2, 01, b6, 01, 1d, ba, 01, 15, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, 25, a7, 01, aa, 01, 19, af, 01, 11, 00, b2, 01, b6, 01, 1d, ba, 01, 15, bf, 01, 19, c3, 01, c7, 01, 0d, 00, 11, 15, 14, 01, 09, 05, 01, 10, 05, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 02, 01, 0e, 00, 0f, 07, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, ba, 01, 03, 0d, 00, 0e, bf, 01, 00, 12, 00, 17, 27, 01, 10, 00, 14, b6, 01, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, b2, 01, 01, 12, 00, 13, af, 01, 01, 11, 00, 22, aa, 01, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 19, 03, 09, 00, 0f, a3, 01, 01, 05, 00, 06]
Raw bytes (249): 0x[01, 01, 31, 05, 09, 00, 02, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, bf, 01, c3, 01, 0d, 00, 11, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, b6, 01, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, b2, 01, 1d, b6, 01, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, 00, ae, 01, b2, 01, 1d, b6, 01, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, ab, 01, 11, 00, ae, 01, b2, 01, 1d, b6, 01, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, 25, a3, 01, a6, 01, 19, ab, 01, 11, 00, ae, 01, b2, 01, 1d, b6, 01, 15, bb, 01, 19, bf, 01, c3, 01, 0d, 00, 11, 15, 14, 01, 09, 05, 01, 10, 05, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 02, 01, 0e, 00, 0f, 07, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, b6, 01, 03, 0d, 00, 0e, bb, 01, 00, 12, 00, 17, b6, 01, 01, 10, 00, 14, b2, 01, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, ae, 01, 01, 12, 00, 13, ab, 01, 01, 11, 00, 22, a6, 01, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 19, 03, 09, 00, 0f, 9f, 01, 01, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 50
Number of expressions: 49
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
- expression 2 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 3 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 2 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 3 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 4 operands: lhs = Counter(3), rhs = Zero
- expression 5 operands: lhs = Counter(4), rhs = Counter(5)
- expression 6 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 6 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 7 operands: lhs = Counter(3), rhs = Zero
- expression 8 operands: lhs = Counter(4), rhs = Counter(5)
- expression 9 operands: lhs = Expression(46, Sub), rhs = Zero
- expression 10 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 11 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 12 operands: lhs = Counter(3), rhs = Zero
- expression 13 operands: lhs = Counter(4), rhs = Counter(5)
- expression 14 operands: lhs = Expression(46, Sub), rhs = Counter(5)
- expression 15 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 16 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 17 operands: lhs = Counter(3), rhs = Zero
- expression 18 operands: lhs = Counter(4), rhs = Counter(5)
- expression 19 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 20 operands: lhs = Expression(46, Sub), rhs = Counter(5)
- expression 21 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 22 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 23 operands: lhs = Counter(3), rhs = Zero
- expression 24 operands: lhs = Counter(4), rhs = Counter(5)
- expression 25 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 26 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 27 operands: lhs = Expression(46, Sub), rhs = Counter(5)
- expression 28 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 29 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 30 operands: lhs = Counter(3), rhs = Zero
- expression 31 operands: lhs = Counter(4), rhs = Counter(5)
- expression 32 operands: lhs = Expression(43, Add), rhs = Counter(4)
- expression 33 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 34 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 35 operands: lhs = Expression(46, Sub), rhs = Counter(5)
- expression 36 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 37 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 38 operands: lhs = Counter(3), rhs = Zero
- expression 39 operands: lhs = Counter(4), rhs = Counter(5)
- expression 40 operands: lhs = Counter(9), rhs = Expression(41, Add)
- expression 41 operands: lhs = Expression(42, Sub), rhs = Counter(6)
- expression 42 operands: lhs = Expression(43, Add), rhs = Counter(4)
- expression 43 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 44 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 45 operands: lhs = Expression(46, Sub), rhs = Counter(5)
- expression 46 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 47 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 48 operands: lhs = Counter(3), rhs = Zero
- expression 49 operands: lhs = Counter(4), rhs = Counter(5)
- expression 9 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 10 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 11 operands: lhs = Counter(3), rhs = Zero
- expression 12 operands: lhs = Counter(4), rhs = Counter(5)
- expression 13 operands: lhs = Expression(45, Sub), rhs = Counter(5)
- expression 14 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 15 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 16 operands: lhs = Counter(3), rhs = Zero
- expression 17 operands: lhs = Counter(4), rhs = Counter(5)
- expression 18 operands: lhs = Expression(44, Sub), rhs = Counter(7)
- expression 19 operands: lhs = Expression(45, Sub), rhs = Counter(5)
- expression 20 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 21 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 22 operands: lhs = Counter(3), rhs = Zero
- expression 23 operands: lhs = Counter(4), rhs = Counter(5)
- expression 24 operands: lhs = Zero, rhs = Expression(43, Sub)
- expression 25 operands: lhs = Expression(44, Sub), rhs = Counter(7)
- expression 26 operands: lhs = Expression(45, Sub), rhs = Counter(5)
- expression 27 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 28 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 29 operands: lhs = Counter(3), rhs = Zero
- expression 30 operands: lhs = Counter(4), rhs = Counter(5)
- expression 31 operands: lhs = Expression(42, Add), rhs = Counter(4)
- expression 32 operands: lhs = Zero, rhs = Expression(43, Sub)
- expression 33 operands: lhs = Expression(44, Sub), rhs = Counter(7)
- expression 34 operands: lhs = Expression(45, Sub), rhs = Counter(5)
- expression 35 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 36 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 37 operands: lhs = Counter(3), rhs = Zero
- expression 38 operands: lhs = Counter(4), rhs = Counter(5)
- expression 39 operands: lhs = Counter(9), rhs = Expression(40, Add)
- expression 40 operands: lhs = Expression(41, Sub), rhs = Counter(6)
- expression 41 operands: lhs = Expression(42, Add), rhs = Counter(4)
- expression 42 operands: lhs = Zero, rhs = Expression(43, Sub)
- expression 43 operands: lhs = Expression(44, Sub), rhs = Counter(7)
- expression 44 operands: lhs = Expression(45, Sub), rhs = Counter(5)
- expression 45 operands: lhs = Expression(46, Add), rhs = Counter(6)
- expression 46 operands: lhs = Expression(47, Add), rhs = Expression(48, Add)
- expression 47 operands: lhs = Counter(3), rhs = Zero
- expression 48 operands: lhs = Counter(4), rhs = Counter(5)
Number of file 0 mappings: 20
- Code(Counter(0)) at (prev + 9, 5) to (start + 1, 16)
- Code(Counter(1)) at (prev + 2, 16) to (start + 0, 21)
@ -64,84 +63,83 @@ Number of file 0 mappings: 20
= (Zero + (c1 - c2))
- Code(Counter(9)) at (prev + 0, 30) to (start + 0, 31)
- Code(Zero) at (prev + 1, 16) to (start + 1, 10)
- Code(Expression(46, Sub)) at (prev + 3, 13) to (start + 0, 14)
- Code(Expression(45, Sub)) at (prev + 3, 13) to (start + 0, 14)
= (((c3 + Zero) + (c4 + c5)) - c6)
- Code(Expression(47, Add)) at (prev + 0, 18) to (start + 0, 23)
- Code(Expression(46, Add)) at (prev + 0, 18) to (start + 0, 23)
= ((c3 + Zero) + (c4 + c5))
- Code(Expression(9, Add)) at (prev + 1, 16) to (start + 0, 20)
= ((((c3 + Zero) + (c4 + c5)) - c6) + Zero)
- Code(Expression(45, Sub)) at (prev + 1, 20) to (start + 0, 25)
- Code(Expression(45, Sub)) at (prev + 1, 16) to (start + 0, 20)
= (((c3 + Zero) + (c4 + c5)) - c6)
- Code(Expression(44, Sub)) at (prev + 1, 20) to (start + 0, 25)
= ((((c3 + Zero) + (c4 + c5)) - c6) - c5)
- Code(Zero) at (prev + 1, 27) to (start + 0, 31)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
- Code(Expression(44, Sub)) at (prev + 1, 18) to (start + 0, 19)
- Code(Expression(43, Sub)) at (prev + 1, 18) to (start + 0, 19)
= (((((c3 + Zero) + (c4 + c5)) - c6) - c5) - c7)
- Code(Expression(43, Add)) at (prev + 1, 17) to (start + 0, 34)
- Code(Expression(42, Add)) at (prev + 1, 17) to (start + 0, 34)
= (Zero + (((((c3 + Zero) + (c4 + c5)) - c6) - c5) - c7))
- Code(Expression(42, Sub)) at (prev + 0, 34) to (start + 0, 35)
- Code(Expression(41, Sub)) at (prev + 0, 34) to (start + 0, 35)
= ((Zero + (((((c3 + Zero) + (c4 + c5)) - c6) - c5) - c7)) - c4)
- Code(Zero) at (prev + 1, 20) to (start + 1, 14)
- Code(Counter(6)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(40, Add)) at (prev + 1, 5) to (start + 0, 6)
- Code(Expression(39, Add)) at (prev + 1, 5) to (start + 0, 6)
= (c9 + (((Zero + (((((c3 + Zero) + (c4 + c5)) - c6) - c5) - c7)) - c4) + c6))
Function name: <loops_branches::DisplayTest as core::fmt::Display>::fmt
Raw bytes (255): 0x[01, 01, 34, 01, 05, 02, 09, 00, 0e, 02, 09, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, c7, 01, cb, 01, 05, 0d, 11, 15, be, 01, 00, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, be, 01, 11, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, ba, 01, 1d, be, 01, 11, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, 00, b6, 01, ba, 01, 1d, be, 01, 11, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, b3, 01, 15, 00, b6, 01, ba, 01, 1d, be, 01, 11, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, ae, 01, cf, 01, b3, 01, 15, 00, b6, 01, ba, 01, 1d, be, 01, 11, c3, 01, 19, c7, 01, cb, 01, 05, 0d, 11, 15, 19, 25, 14, 01, 22, 05, 01, 11, 00, 01, 12, 01, 0a, 02, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 0e, 01, 0e, 00, 0f, 0b, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, be, 01, 02, 0d, 00, 0e, c3, 01, 00, 12, 00, 17, 2f, 01, 10, 00, 15, 00, 00, 16, 01, 0e, ba, 01, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, b6, 01, 01, 12, 00, 13, b3, 01, 01, 11, 00, 22, ae, 01, 00, 22, 00, 23, 19, 03, 09, 00, 0f, ab, 01, 01, 05, 00, 06]
Raw bytes (253): 0x[01, 01, 33, 01, 05, 02, 09, 00, 0e, 02, 09, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, c3, 01, c7, 01, 05, 0d, 11, 15, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, ba, 01, 11, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, b6, 01, 1d, ba, 01, 11, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, 00, b2, 01, b6, 01, 1d, ba, 01, 11, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, af, 01, 15, 00, b2, 01, b6, 01, 1d, ba, 01, 11, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, aa, 01, cb, 01, af, 01, 15, 00, b2, 01, b6, 01, 1d, ba, 01, 11, bf, 01, 19, c3, 01, c7, 01, 05, 0d, 11, 15, 19, 25, 14, 01, 22, 05, 01, 11, 00, 01, 12, 01, 0a, 02, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 0e, 01, 0e, 00, 0f, 0b, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, ba, 01, 02, 0d, 00, 0e, bf, 01, 00, 12, 00, 17, ba, 01, 01, 10, 00, 15, 00, 00, 16, 01, 0e, b6, 01, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, b2, 01, 01, 12, 00, 13, af, 01, 01, 11, 00, 22, aa, 01, 00, 22, 00, 23, 19, 03, 09, 00, 0f, a7, 01, 01, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 52
Number of expressions: 51
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 2 operands: lhs = Zero, rhs = Expression(3, Sub)
- expression 3 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 4 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 5 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 4 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 5 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 6 operands: lhs = Counter(1), rhs = Counter(3)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5)
- expression 8 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 8 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 9 operands: lhs = Counter(1), rhs = Counter(3)
- expression 10 operands: lhs = Counter(4), rhs = Counter(5)
- expression 11 operands: lhs = Expression(47, Sub), rhs = Zero
- expression 12 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 13 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 14 operands: lhs = Counter(1), rhs = Counter(3)
- expression 15 operands: lhs = Counter(4), rhs = Counter(5)
- expression 16 operands: lhs = Expression(47, Sub), rhs = Counter(4)
- expression 17 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 18 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 19 operands: lhs = Counter(1), rhs = Counter(3)
- expression 20 operands: lhs = Counter(4), rhs = Counter(5)
- expression 21 operands: lhs = Expression(46, Sub), rhs = Counter(7)
- expression 22 operands: lhs = Expression(47, Sub), rhs = Counter(4)
- expression 23 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 24 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 25 operands: lhs = Counter(1), rhs = Counter(3)
- expression 26 operands: lhs = Counter(4), rhs = Counter(5)
- expression 27 operands: lhs = Zero, rhs = Expression(45, Sub)
- expression 28 operands: lhs = Expression(46, Sub), rhs = Counter(7)
- expression 29 operands: lhs = Expression(47, Sub), rhs = Counter(4)
- expression 30 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 31 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 32 operands: lhs = Counter(1), rhs = Counter(3)
- expression 33 operands: lhs = Counter(4), rhs = Counter(5)
- expression 34 operands: lhs = Expression(44, Add), rhs = Counter(5)
- expression 35 operands: lhs = Zero, rhs = Expression(45, Sub)
- expression 36 operands: lhs = Expression(46, Sub), rhs = Counter(7)
- expression 37 operands: lhs = Expression(47, Sub), rhs = Counter(4)
- expression 38 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 39 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 40 operands: lhs = Counter(1), rhs = Counter(3)
- expression 41 operands: lhs = Counter(4), rhs = Counter(5)
- expression 42 operands: lhs = Expression(43, Sub), rhs = Expression(51, Add)
- expression 43 operands: lhs = Expression(44, Add), rhs = Counter(5)
- expression 44 operands: lhs = Zero, rhs = Expression(45, Sub)
- expression 45 operands: lhs = Expression(46, Sub), rhs = Counter(7)
- expression 46 operands: lhs = Expression(47, Sub), rhs = Counter(4)
- expression 47 operands: lhs = Expression(48, Add), rhs = Counter(6)
- expression 48 operands: lhs = Expression(49, Add), rhs = Expression(50, Add)
- expression 49 operands: lhs = Counter(1), rhs = Counter(3)
- expression 50 operands: lhs = Counter(4), rhs = Counter(5)
- expression 51 operands: lhs = Counter(6), rhs = Counter(9)
- expression 11 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 12 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 13 operands: lhs = Counter(1), rhs = Counter(3)
- expression 14 operands: lhs = Counter(4), rhs = Counter(5)
- expression 15 operands: lhs = Expression(46, Sub), rhs = Counter(4)
- expression 16 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 17 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 18 operands: lhs = Counter(1), rhs = Counter(3)
- expression 19 operands: lhs = Counter(4), rhs = Counter(5)
- expression 20 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 21 operands: lhs = Expression(46, Sub), rhs = Counter(4)
- expression 22 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 23 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 24 operands: lhs = Counter(1), rhs = Counter(3)
- expression 25 operands: lhs = Counter(4), rhs = Counter(5)
- expression 26 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 27 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 28 operands: lhs = Expression(46, Sub), rhs = Counter(4)
- expression 29 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 30 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 31 operands: lhs = Counter(1), rhs = Counter(3)
- expression 32 operands: lhs = Counter(4), rhs = Counter(5)
- expression 33 operands: lhs = Expression(43, Add), rhs = Counter(5)
- expression 34 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 35 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 36 operands: lhs = Expression(46, Sub), rhs = Counter(4)
- expression 37 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 38 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 39 operands: lhs = Counter(1), rhs = Counter(3)
- expression 40 operands: lhs = Counter(4), rhs = Counter(5)
- expression 41 operands: lhs = Expression(42, Sub), rhs = Expression(50, Add)
- expression 42 operands: lhs = Expression(43, Add), rhs = Counter(5)
- expression 43 operands: lhs = Zero, rhs = Expression(44, Sub)
- expression 44 operands: lhs = Expression(45, Sub), rhs = Counter(7)
- expression 45 operands: lhs = Expression(46, Sub), rhs = Counter(4)
- expression 46 operands: lhs = Expression(47, Add), rhs = Counter(6)
- expression 47 operands: lhs = Expression(48, Add), rhs = Expression(49, Add)
- expression 48 operands: lhs = Counter(1), rhs = Counter(3)
- expression 49 operands: lhs = Counter(4), rhs = Counter(5)
- expression 50 operands: lhs = Counter(6), rhs = Counter(9)
Number of file 0 mappings: 20
- Code(Counter(0)) at (prev + 34, 5) to (start + 1, 17)
- Code(Zero) at (prev + 1, 18) to (start + 1, 10)
@ -154,25 +152,25 @@ Number of file 0 mappings: 20
- Code(Expression(2, Add)) at (prev + 1, 13) to (start + 0, 30)
= (Zero + ((c0 - c1) - c2))
- Code(Counter(9)) at (prev + 0, 30) to (start + 0, 31)
- Code(Expression(47, Sub)) at (prev + 2, 13) to (start + 0, 14)
- Code(Expression(46, Sub)) at (prev + 2, 13) to (start + 0, 14)
= (((c1 + c3) + (c4 + c5)) - c6)
- Code(Expression(48, Add)) at (prev + 0, 18) to (start + 0, 23)
- Code(Expression(47, Add)) at (prev + 0, 18) to (start + 0, 23)
= ((c1 + c3) + (c4 + c5))
- Code(Expression(11, Add)) at (prev + 1, 16) to (start + 0, 21)
= ((((c1 + c3) + (c4 + c5)) - c6) + Zero)
- Code(Expression(46, Sub)) at (prev + 1, 16) to (start + 0, 21)
= (((c1 + c3) + (c4 + c5)) - c6)
- Code(Zero) at (prev + 0, 22) to (start + 1, 14)
- Code(Expression(46, Sub)) at (prev + 2, 20) to (start + 0, 25)
- Code(Expression(45, Sub)) at (prev + 2, 20) to (start + 0, 25)
= ((((c1 + c3) + (c4 + c5)) - c6) - c4)
- Code(Zero) at (prev + 1, 27) to (start + 0, 31)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
- Code(Expression(45, Sub)) at (prev + 1, 18) to (start + 0, 19)
- Code(Expression(44, Sub)) at (prev + 1, 18) to (start + 0, 19)
= (((((c1 + c3) + (c4 + c5)) - c6) - c4) - c7)
- Code(Expression(44, Add)) at (prev + 1, 17) to (start + 0, 34)
- Code(Expression(43, Add)) at (prev + 1, 17) to (start + 0, 34)
= (Zero + (((((c1 + c3) + (c4 + c5)) - c6) - c4) - c7))
- Code(Expression(43, Sub)) at (prev + 0, 34) to (start + 0, 35)
- Code(Expression(42, Sub)) at (prev + 0, 34) to (start + 0, 35)
= ((Zero + (((((c1 + c3) + (c4 + c5)) - c6) - c4) - c7)) - c5)
- Code(Counter(6)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(42, Add)) at (prev + 1, 5) to (start + 0, 6)
- Code(Expression(41, Add)) at (prev + 1, 5) to (start + 0, 6)
= (((Zero + (((((c1 + c3) + (c4 + c5)) - c6) - c4) - c7)) - c5) + (c6 + c9))
Function name: loops_branches::main

4
tests/coverage-map/status-quo/no_cov_crate.cov-map
View File

@ -15,12 +15,12 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 24, 1) to (start + 2, 2)
Function name: no_cov_crate::add_coverage_not_called (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1d, 01, 02, 02]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 1d, 01, 02, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 29, 1) to (start + 2, 2)
- Code(Zero) at (prev + 29, 1) to (start + 2, 2)
Function name: no_cov_crate::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 4d, 01, 0b, 02]

12
tests/coverage-map/status-quo/partial_eq.cov-map
View File

@ -1,27 +1,27 @@
Function name: <partial_eq::Version as core::clone::Clone>::clone (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 04, 0a, 00, 0f]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 04, 0a, 00, 0f]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 4, 10) to (start + 0, 15)
- Code(Zero) at (prev + 4, 10) to (start + 0, 15)
Function name: <partial_eq::Version as core::cmp::Ord>::cmp (unused)
Raw bytes (14): 0x[01, 01, 00, 02, 01, 04, 33, 00, 34, 00, 00, 35, 00, 36]
Raw bytes (14): 0x[01, 01, 00, 02, 00, 04, 33, 00, 34, 00, 00, 35, 00, 36]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 4, 51) to (start + 0, 52)
- Code(Zero) at (prev + 4, 51) to (start + 0, 52)
- Code(Zero) at (prev + 0, 53) to (start + 0, 54)
Function name: <partial_eq::Version as core::cmp::PartialEq>::eq (unused)
Raw bytes (14): 0x[01, 01, 00, 02, 01, 04, 18, 00, 19, 00, 00, 20, 00, 21]
Raw bytes (14): 0x[01, 01, 00, 02, 00, 04, 18, 00, 19, 00, 00, 20, 00, 21]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 4, 24) to (start + 0, 25)
- Code(Zero) at (prev + 4, 24) to (start + 0, 25)
- Code(Zero) at (prev + 0, 32) to (start + 0, 33)
Function name: <partial_eq::Version as core::cmp::PartialOrd>::partial_cmp

23
tests/coverage-map/status-quo/simple_loop.cov-map
View File

@ -1,28 +1,27 @@
Function name: simple_loop::main
Raw bytes (59): 0x[01, 01, 0a, 01, 05, 27, 09, 05, 02, 23, 09, 27, 09, 05, 02, 1e, 00, 23, 09, 27, 09, 05, 02, 07, 01, 03, 01, 09, 10, 05, 0a, 05, 05, 06, 02, 05, 06, 00, 07, 23, 05, 0d, 02, 0e, 1e, 04, 0d, 00, 12, 09, 02, 0a, 03, 0a, 1b, 06, 01, 00, 02]
Raw bytes (57): 0x[01, 01, 09, 01, 05, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 07, 01, 03, 01, 09, 10, 05, 0a, 05, 05, 06, 02, 05, 06, 00, 07, 1f, 05, 0d, 02, 0e, 1a, 04, 0d, 00, 12, 09, 02, 0a, 03, 0a, 1a, 06, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 10
Number of expressions: 9
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(9, Add), rhs = Counter(2)
- expression 1 operands: lhs = Expression(8, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 3 operands: lhs = Expression(8, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(9, Add), rhs = Counter(2)
- expression 3 operands: lhs = Expression(7, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(8, Add), rhs = Counter(2)
- expression 5 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 6 operands: lhs = Expression(7, Sub), rhs = Zero
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(2)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(2)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(2)
- expression 9 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 8 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 3, 1) to (start + 9, 16)
- Code(Counter(1)) at (prev + 10, 5) to (start + 5, 6)
- Code(Expression(0, Sub)) at (prev + 5, 6) to (start + 0, 7)
= (c0 - c1)
- Code(Expression(8, Add)) at (prev + 5, 13) to (start + 2, 14)
- Code(Expression(7, Add)) at (prev + 5, 13) to (start + 2, 14)
= ((c1 + (c0 - c1)) + c2)
- Code(Expression(7, Sub)) at (prev + 4, 13) to (start + 0, 18)
- Code(Expression(6, Sub)) at (prev + 4, 13) to (start + 0, 18)
= (((c1 + (c0 - c1)) + c2) - c2)
- Code(Counter(2)) at (prev + 2, 10) to (start + 3, 10)
- Code(Expression(6, Add)) at (prev + 6, 1) to (start + 0, 2)
= ((((c1 + (c0 - c1)) + c2) - c2) + Zero)
- Code(Expression(6, Sub)) at (prev + 6, 1) to (start + 0, 2)
= (((c1 + (c0 - c1)) + c2) - c2)

31
tests/coverage-map/status-quo/simple_match.cov-map
View File

@ -1,36 +1,33 @@
Function name: simple_match::main
Raw bytes (82): 0x[01, 01, 0e, 01, 05, 2f, 33, 05, 02, 09, 0d, 2b, 11, 2f, 33, 05, 02, 09, 0d, 26, 00, 2b, 11, 2f, 33, 05, 02, 09, 0d, 09, 00, 0a, 01, 03, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 06, 00, 07, 2b, 05, 09, 00, 0d, 26, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 23, 02, 11, 02, 12, 37, 04, 0d, 07, 0e, 0d, 0a, 0d, 00, 0f, 11, 03, 01, 00, 02]
Raw bytes (78): 0x[01, 01, 0c, 01, 05, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 0a, 01, 03, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 06, 00, 07, 27, 05, 09, 00, 0d, 22, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 22, 02, 11, 02, 12, 09, 04, 0d, 07, 0e, 0d, 0a, 0d, 00, 0f, 11, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 14
Number of expressions: 12
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(11, Add), rhs = Expression(12, Add)
- expression 1 operands: lhs = Expression(10, Add), rhs = Expression(11, Add)
- expression 2 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(10, Add), rhs = Counter(4)
- expression 5 operands: lhs = Expression(11, Add), rhs = Expression(12, Add)
- expression 4 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 5 operands: lhs = Expression(10, Add), rhs = Expression(11, Add)
- expression 6 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 8 operands: lhs = Expression(9, Sub), rhs = Zero
- expression 9 operands: lhs = Expression(10, Add), rhs = Counter(4)
- expression 10 operands: lhs = Expression(11, Add), rhs = Expression(12, Add)
- expression 11 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
- expression 13 operands: lhs = Counter(2), rhs = Zero
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 9 operands: lhs = Expression(10, Add), rhs = Expression(11, Add)
- expression 10 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 11 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 3, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 2, 6)
- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
= (c0 - c1)
- Code(Expression(10, Add)) at (prev + 5, 9) to (start + 0, 13)
- Code(Expression(9, Add)) at (prev + 5, 9) to (start + 0, 13)
= ((c1 + (c0 - c1)) + (c2 + c3))
- Code(Expression(9, Sub)) at (prev + 5, 13) to (start + 0, 22)
- Code(Expression(8, Sub)) at (prev + 5, 13) to (start + 0, 22)
= (((c1 + (c0 - c1)) + (c2 + c3)) - c4)
- Code(Counter(2)) at (prev + 2, 13) to (start + 0, 14)
- Code(Expression(8, Add)) at (prev + 2, 17) to (start + 2, 18)
= ((((c1 + (c0 - c1)) + (c2 + c3)) - c4) + Zero)
- Code(Expression(13, Add)) at (prev + 4, 13) to (start + 7, 14)
= (c2 + Zero)
- Code(Expression(8, Sub)) at (prev + 2, 17) to (start + 2, 18)
= (((c1 + (c0 - c1)) + (c2 + c3)) - c4)
- Code(Counter(2)) at (prev + 4, 13) to (start + 7, 14)
- Code(Counter(3)) at (prev + 10, 13) to (start + 0, 15)
- Code(Counter(4)) at (prev + 3, 1) to (start + 0, 2)

4
tests/coverage-map/status-quo/test_harness.cov-map
View File

@ -15,10 +15,10 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 9, 1) to (start + 0, 8)
Function name: test_harness::unused (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 00, 0f]
Raw bytes (9): 0x[01, 01, 00, 01, 00, 07, 01, 00, 0f]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 15)
- Code(Zero) at (prev + 7, 1) to (start + 0, 15)

166
tests/coverage-map/status-quo/try_error_result.cov-map
View File

@ -91,136 +91,130 @@ Number of file 0 mappings: 11
= ((c4 + (c5 + c6)) + c3)
Function name: try_error_result::test2
Raw bytes (373): 0x[01, 01, 41, 01, 07, 05, 09, 03, 0d, 41, 11, 52, 15, 41, 11, 4a, 1d, 4e, 19, 52, 15, 41, 11, 4e, 00, 52, 15, 41, 11, 4e, 19, 52, 15, 41, 11, 46, 00, 4a, 1d, 4e, 19, 52, 15, 41, 11, 6a, 25, 49, 21, 49, 21, 66, 00, 6a, 25, 49, 21, 9a, 01, 2d, 9e, 01, 29, a2, 01, 41, 03, 0d, a2, 01, 41, 03, 0d, 9e, 01, 29, a2, 01, 41, 03, 0d, 96, 01, 00, 9a, 01, 2d, 9e, 01, 29, a2, 01, 41, 03, 0d, ba, 01, 35, 45, 31, 45, 31, b6, 01, 00, ba, 01, 35, 45, 31, d2, 01, 3d, 4d, 39, 4d, 39, ce, 01, 00, d2, 01, 3d, 4d, 39, db, 01, 0d, 11, df, 01, e3, 01, f3, 01, 15, e7, 01, eb, 01, ef, 01, 19, 1d, 21, 25, f7, 01, fb, 01, 29, 2d, ff, 01, 83, 02, 31, 35, 39, 3d, 28, 01, 3c, 01, 03, 17, 03, 08, 09, 00, 0e, a2, 01, 02, 09, 04, 1a, 41, 06, 0d, 00, 2f, 11, 00, 2f, 00, 30, 52, 00, 31, 03, 35, 15, 04, 11, 00, 12, 4e, 02, 11, 04, 12, 46, 05, 11, 00, 14, 2b, 00, 17, 00, 41, 19, 00, 41, 00, 42, 4a, 00, 43, 00, 5f, 1d, 00, 5f, 00, 60, 43, 01, 0d, 00, 20, 66, 01, 11, 00, 14, 49, 00, 17, 00, 41, 21, 00, 41, 00, 42, 6a, 00, 43, 00, 60, 25, 00, 60, 00, 61, 63, 01, 0d, 00, 20, 96, 01, 04, 11, 00, 14, 9e, 01, 00, 17, 00, 42, 29, 00, 42, 00, 43, 9a, 01, 00, 44, 00, 61, 2d, 00, 61, 00, 62, 93, 01, 01, 0d, 00, 20, b6, 01, 01, 11, 00, 14, 45, 00, 17, 01, 36, 31, 01, 36, 00, 37, ba, 01, 01, 12, 00, 2f, 35, 00, 2f, 00, 30, b3, 01, 01, 0d, 00, 20, ce, 01, 01, 11, 00, 14, 4d, 00, 17, 01, 36, 39, 02, 11, 00, 12, d2, 01, 01, 12, 00, 2f, 3d, 01, 11, 00, 12, cb, 01, 02, 0d, 00, 20, 0d, 03, 05, 00, 0b, d7, 01, 01, 01, 00, 02]
Raw bytes (358): 0x[01, 01, 3b, 01, 07, 05, 09, 03, 0d, 41, 11, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 4a, 15, 41, 11, 46, 19, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 5e, 25, 49, 21, 49, 21, 5e, 25, 49, 21, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, 92, 01, 41, 03, 0d, 8e, 01, 29, 92, 01, 41, 03, 0d, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, a6, 01, 35, 45, 31, 45, 31, a6, 01, 35, 45, 31, ba, 01, 3d, 4d, 39, 4d, 39, ba, 01, 3d, 4d, 39, c3, 01, 0d, 11, c7, 01, cb, 01, db, 01, 15, cf, 01, d3, 01, d7, 01, 19, 1d, 21, 25, df, 01, e3, 01, 29, 2d, e7, 01, eb, 01, 31, 35, 39, 3d, 28, 01, 3c, 01, 03, 17, 03, 08, 09, 00, 0e, 92, 01, 02, 09, 04, 1a, 41, 06, 0d, 00, 2f, 11, 00, 2f, 00, 30, 4a, 00, 31, 03, 35, 15, 04, 11, 00, 12, 46, 02, 11, 04, 12, 3e, 05, 11, 00, 14, 46, 00, 17, 00, 41, 19, 00, 41, 00, 42, 42, 00, 43, 00, 5f, 1d, 00, 5f, 00, 60, 3e, 01, 0d, 00, 20, 5a, 01, 11, 00, 14, 49, 00, 17, 00, 41, 21, 00, 41, 00, 42, 5e, 00, 43, 00, 60, 25, 00, 60, 00, 61, 5a, 01, 0d, 00, 20, 86, 01, 04, 11, 00, 14, 8e, 01, 00, 17, 00, 42, 29, 00, 42, 00, 43, 8a, 01, 00, 44, 00, 61, 2d, 00, 61, 00, 62, 86, 01, 01, 0d, 00, 20, a2, 01, 01, 11, 00, 14, 45, 00, 17, 01, 36, 31, 01, 36, 00, 37, a6, 01, 01, 12, 00, 2f, 35, 00, 2f, 00, 30, a2, 01, 01, 0d, 00, 20, b6, 01, 01, 11, 00, 14, 4d, 00, 17, 01, 36, 39, 02, 11, 00, 12, ba, 01, 01, 12, 00, 2f, 3d, 01, 11, 00, 12, b6, 01, 02, 0d, 00, 20, 0d, 03, 05, 00, 0b, bf, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 65
Number of expressions: 59
- expression 0 operands: lhs = Counter(0), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(16), rhs = Counter(4)
- expression 4 operands: lhs = Expression(20, Sub), rhs = Counter(5)
- expression 4 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 5 operands: lhs = Counter(16), rhs = Counter(4)
- expression 6 operands: lhs = Expression(18, Sub), rhs = Counter(7)
- expression 7 operands: lhs = Expression(19, Sub), rhs = Counter(6)
- expression 8 operands: lhs = Expression(20, Sub), rhs = Counter(5)
- expression 6 operands: lhs = Expression(16, Sub), rhs = Counter(7)
- expression 7 operands: lhs = Expression(17, Sub), rhs = Counter(6)
- expression 8 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 9 operands: lhs = Counter(16), rhs = Counter(4)
- expression 10 operands: lhs = Expression(19, Sub), rhs = Zero
- expression 11 operands: lhs = Expression(20, Sub), rhs = Counter(5)
- expression 12 operands: lhs = Counter(16), rhs = Counter(4)
- expression 13 operands: lhs = Expression(19, Sub), rhs = Counter(6)
- expression 14 operands: lhs = Expression(20, Sub), rhs = Counter(5)
- expression 15 operands: lhs = Counter(16), rhs = Counter(4)
- expression 16 operands: lhs = Expression(17, Sub), rhs = Zero
- expression 17 operands: lhs = Expression(18, Sub), rhs = Counter(7)
- expression 18 operands: lhs = Expression(19, Sub), rhs = Counter(6)
- expression 19 operands: lhs = Expression(20, Sub), rhs = Counter(5)
- expression 20 operands: lhs = Counter(16), rhs = Counter(4)
- expression 21 operands: lhs = Expression(26, Sub), rhs = Counter(9)
- expression 22 operands: lhs = Counter(18), rhs = Counter(8)
- expression 10 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 11 operands: lhs = Counter(16), rhs = Counter(4)
- expression 12 operands: lhs = Expression(17, Sub), rhs = Counter(6)
- expression 13 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 14 operands: lhs = Counter(16), rhs = Counter(4)
- expression 15 operands: lhs = Expression(16, Sub), rhs = Counter(7)
- expression 16 operands: lhs = Expression(17, Sub), rhs = Counter(6)
- expression 17 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 18 operands: lhs = Counter(16), rhs = Counter(4)
- expression 19 operands: lhs = Expression(23, Sub), rhs = Counter(9)
- expression 20 operands: lhs = Counter(18), rhs = Counter(8)
- expression 21 operands: lhs = Counter(18), rhs = Counter(8)
- expression 22 operands: lhs = Expression(23, Sub), rhs = Counter(9)
- expression 23 operands: lhs = Counter(18), rhs = Counter(8)
- expression 24 operands: lhs = Expression(25, Sub), rhs = Zero
- expression 25 operands: lhs = Expression(26, Sub), rhs = Counter(9)
- expression 26 operands: lhs = Counter(18), rhs = Counter(8)
- expression 27 operands: lhs = Expression(38, Sub), rhs = Counter(11)
- expression 28 operands: lhs = Expression(39, Sub), rhs = Counter(10)
- expression 29 operands: lhs = Expression(40, Sub), rhs = Counter(16)
- expression 30 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 31 operands: lhs = Expression(40, Sub), rhs = Counter(16)
- expression 24 operands: lhs = Expression(34, Sub), rhs = Counter(11)
- expression 25 operands: lhs = Expression(35, Sub), rhs = Counter(10)
- expression 26 operands: lhs = Expression(36, Sub), rhs = Counter(16)
- expression 27 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 28 operands: lhs = Expression(36, Sub), rhs = Counter(16)
- expression 29 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 30 operands: lhs = Expression(35, Sub), rhs = Counter(10)
- expression 31 operands: lhs = Expression(36, Sub), rhs = Counter(16)
- expression 32 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 33 operands: lhs = Expression(39, Sub), rhs = Counter(10)
- expression 34 operands: lhs = Expression(40, Sub), rhs = Counter(16)
- expression 35 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 36 operands: lhs = Expression(37, Sub), rhs = Zero
- expression 37 operands: lhs = Expression(38, Sub), rhs = Counter(11)
- expression 38 operands: lhs = Expression(39, Sub), rhs = Counter(10)
- expression 39 operands: lhs = Expression(40, Sub), rhs = Counter(16)
- expression 40 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 41 operands: lhs = Expression(46, Sub), rhs = Counter(13)
- expression 42 operands: lhs = Counter(17), rhs = Counter(12)
- expression 43 operands: lhs = Counter(17), rhs = Counter(12)
- expression 44 operands: lhs = Expression(45, Sub), rhs = Zero
- expression 45 operands: lhs = Expression(46, Sub), rhs = Counter(13)
- expression 46 operands: lhs = Counter(17), rhs = Counter(12)
- expression 47 operands: lhs = Expression(52, Sub), rhs = Counter(15)
- expression 48 operands: lhs = Counter(19), rhs = Counter(14)
- expression 49 operands: lhs = Counter(19), rhs = Counter(14)
- expression 50 operands: lhs = Expression(51, Sub), rhs = Zero
- expression 51 operands: lhs = Expression(52, Sub), rhs = Counter(15)
- expression 52 operands: lhs = Counter(19), rhs = Counter(14)
- expression 53 operands: lhs = Expression(54, Add), rhs = Counter(3)
- expression 54 operands: lhs = Counter(4), rhs = Expression(55, Add)
- expression 55 operands: lhs = Expression(56, Add), rhs = Expression(60, Add)
- expression 56 operands: lhs = Counter(5), rhs = Expression(57, Add)
- expression 57 operands: lhs = Expression(58, Add), rhs = Expression(59, Add)
- expression 58 operands: lhs = Counter(6), rhs = Counter(7)
- expression 59 operands: lhs = Counter(8), rhs = Counter(9)
- expression 60 operands: lhs = Expression(61, Add), rhs = Expression(62, Add)
- expression 61 operands: lhs = Counter(10), rhs = Counter(11)
- expression 62 operands: lhs = Expression(63, Add), rhs = Expression(64, Add)
- expression 63 operands: lhs = Counter(12), rhs = Counter(13)
- expression 64 operands: lhs = Counter(14), rhs = Counter(15)
- expression 33 operands: lhs = Expression(34, Sub), rhs = Counter(11)
- expression 34 operands: lhs = Expression(35, Sub), rhs = Counter(10)
- expression 35 operands: lhs = Expression(36, Sub), rhs = Counter(16)
- expression 36 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 37 operands: lhs = Expression(41, Sub), rhs = Counter(13)
- expression 38 operands: lhs = Counter(17), rhs = Counter(12)
- expression 39 operands: lhs = Counter(17), rhs = Counter(12)
- expression 40 operands: lhs = Expression(41, Sub), rhs = Counter(13)
- expression 41 operands: lhs = Counter(17), rhs = Counter(12)
- expression 42 operands: lhs = Expression(46, Sub), rhs = Counter(15)
- expression 43 operands: lhs = Counter(19), rhs = Counter(14)
- expression 44 operands: lhs = Counter(19), rhs = Counter(14)
- expression 45 operands: lhs = Expression(46, Sub), rhs = Counter(15)
- expression 46 operands: lhs = Counter(19), rhs = Counter(14)
- expression 47 operands: lhs = Expression(48, Add), rhs = Counter(3)
- expression 48 operands: lhs = Counter(4), rhs = Expression(49, Add)
- expression 49 operands: lhs = Expression(50, Add), rhs = Expression(54, Add)
- expression 50 operands: lhs = Counter(5), rhs = Expression(51, Add)
- expression 51 operands: lhs = Expression(52, Add), rhs = Expression(53, Add)
- expression 52 operands: lhs = Counter(6), rhs = Counter(7)
- expression 53 operands: lhs = Counter(8), rhs = Counter(9)
- expression 54 operands: lhs = Expression(55, Add), rhs = Expression(56, Add)
- expression 55 operands: lhs = Counter(10), rhs = Counter(11)
- expression 56 operands: lhs = Expression(57, Add), rhs = Expression(58, Add)
- expression 57 operands: lhs = Counter(12), rhs = Counter(13)
- expression 58 operands: lhs = Counter(14), rhs = Counter(15)
Number of file 0 mappings: 40
- Code(Counter(0)) at (prev + 60, 1) to (start + 3, 23)
- Code(Expression(0, Add)) at (prev + 8, 9) to (start + 0, 14)
= (c0 + (c1 + c2))
- Code(Expression(40, Sub)) at (prev + 2, 9) to (start + 4, 26)
- Code(Expression(36, Sub)) at (prev + 2, 9) to (start + 4, 26)
= ((c0 + (c1 + c2)) - c3)
- Code(Counter(16)) at (prev + 6, 13) to (start + 0, 47)
- Code(Counter(4)) at (prev + 0, 47) to (start + 0, 48)
- Code(Expression(20, Sub)) at (prev + 0, 49) to (start + 3, 53)
- Code(Expression(18, Sub)) at (prev + 0, 49) to (start + 3, 53)
= (c16 - c4)
- Code(Counter(5)) at (prev + 4, 17) to (start + 0, 18)
- Code(Expression(19, Sub)) at (prev + 2, 17) to (start + 4, 18)
- Code(Expression(17, Sub)) at (prev + 2, 17) to (start + 4, 18)
= ((c16 - c4) - c5)
- Code(Expression(17, Sub)) at (prev + 5, 17) to (start + 0, 20)
- Code(Expression(15, Sub)) at (prev + 5, 17) to (start + 0, 20)
= ((((c16 - c4) - c5) - c6) - c7)
- Code(Expression(10, Add)) at (prev + 0, 23) to (start + 0, 65)
= (((c16 - c4) - c5) + Zero)
- Code(Expression(17, Sub)) at (prev + 0, 23) to (start + 0, 65)
= ((c16 - c4) - c5)
- Code(Counter(6)) at (prev + 0, 65) to (start + 0, 66)
- Code(Expression(18, Sub)) at (prev + 0, 67) to (start + 0, 95)
- Code(Expression(16, Sub)) at (prev + 0, 67) to (start + 0, 95)
= (((c16 - c4) - c5) - c6)
- Code(Counter(7)) at (prev + 0, 95) to (start + 0, 96)
- Code(Expression(16, Add)) at (prev + 1, 13) to (start + 0, 32)
= (((((c16 - c4) - c5) - c6) - c7) + Zero)
- Code(Expression(25, Sub)) at (prev + 1, 17) to (start + 0, 20)
- Code(Expression(15, Sub)) at (prev + 1, 13) to (start + 0, 32)
= ((((c16 - c4) - c5) - c6) - c7)
- Code(Expression(22, Sub)) at (prev + 1, 17) to (start + 0, 20)
= ((c18 - c8) - c9)
- Code(Counter(18)) at (prev + 0, 23) to (start + 0, 65)
- Code(Counter(8)) at (prev + 0, 65) to (start + 0, 66)
- Code(Expression(26, Sub)) at (prev + 0, 67) to (start + 0, 96)
- Code(Expression(23, Sub)) at (prev + 0, 67) to (start + 0, 96)
= (c18 - c8)
- Code(Counter(9)) at (prev + 0, 96) to (start + 0, 97)
- Code(Expression(24, Add)) at (prev + 1, 13) to (start + 0, 32)
= (((c18 - c8) - c9) + Zero)
- Code(Expression(37, Sub)) at (prev + 4, 17) to (start + 0, 20)
- Code(Expression(22, Sub)) at (prev + 1, 13) to (start + 0, 32)
= ((c18 - c8) - c9)
- Code(Expression(33, Sub)) at (prev + 4, 17) to (start + 0, 20)
= (((((c0 + (c1 + c2)) - c3) - c16) - c10) - c11)
- Code(Expression(39, Sub)) at (prev + 0, 23) to (start + 0, 66)
- Code(Expression(35, Sub)) at (prev + 0, 23) to (start + 0, 66)
= (((c0 + (c1 + c2)) - c3) - c16)
- Code(Counter(10)) at (prev + 0, 66) to (start + 0, 67)
- Code(Expression(38, Sub)) at (prev + 0, 68) to (start + 0, 97)
- Code(Expression(34, Sub)) at (prev + 0, 68) to (start + 0, 97)
= ((((c0 + (c1 + c2)) - c3) - c16) - c10)
- Code(Counter(11)) at (prev + 0, 97) to (start + 0, 98)
- Code(Expression(36, Add)) at (prev + 1, 13) to (start + 0, 32)
= ((((((c0 + (c1 + c2)) - c3) - c16) - c10) - c11) + Zero)
- Code(Expression(45, Sub)) at (prev + 1, 17) to (start + 0, 20)
- Code(Expression(33, Sub)) at (prev + 1, 13) to (start + 0, 32)
= (((((c0 + (c1 + c2)) - c3) - c16) - c10) - c11)
- Code(Expression(40, Sub)) at (prev + 1, 17) to (start + 0, 20)
= ((c17 - c12) - c13)
- Code(Counter(17)) at (prev + 0, 23) to (start + 1, 54)
- Code(Counter(12)) at (prev + 1, 54) to (start + 0, 55)
- Code(Expression(46, Sub)) at (prev + 1, 18) to (start + 0, 47)
- Code(Expression(41, Sub)) at (prev + 1, 18) to (start + 0, 47)
= (c17 - c12)
- Code(Counter(13)) at (prev + 0, 47) to (start + 0, 48)
- Code(Expression(44, Add)) at (prev + 1, 13) to (start + 0, 32)
= (((c17 - c12) - c13) + Zero)
- Code(Expression(51, Sub)) at (prev + 1, 17) to (start + 0, 20)
- Code(Expression(40, Sub)) at (prev + 1, 13) to (start + 0, 32)
= ((c17 - c12) - c13)
- Code(Expression(45, Sub)) at (prev + 1, 17) to (start + 0, 20)
= ((c19 - c14) - c15)
- Code(Counter(19)) at (prev + 0, 23) to (start + 1, 54)
- Code(Counter(14)) at (prev + 2, 17) to (start + 0, 18)
- Code(Expression(52, Sub)) at (prev + 1, 18) to (start + 0, 47)
- Code(Expression(46, Sub)) at (prev + 1, 18) to (start + 0, 47)
= (c19 - c14)
- Code(Counter(15)) at (prev + 1, 17) to (start + 0, 18)
- Code(Expression(50, Add)) at (prev + 2, 13) to (start + 0, 32)
= (((c19 - c14) - c15) + Zero)
- Code(Expression(45, Sub)) at (prev + 2, 13) to (start + 0, 32)
= ((c19 - c14) - c15)
- Code(Counter(3)) at (prev + 3, 5) to (start + 0, 11)
- Code(Expression(53, Add)) at (prev + 1, 1) to (start + 0, 2)
- Code(Expression(47, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c4 + ((c5 + ((c6 + c7) + (c8 + c9))) + ((c10 + c11) + ((c12 + c13) + (c14 + c15))))) + c3)

16
tests/coverage-map/status-quo/unused.cov-map
View File

@ -47,45 +47,45 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 37, 1) to (start + 4, 2)
Function name: unused::unused_func (unused)
Raw bytes (24): 0x[01, 01, 00, 04, 01, 13, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Raw bytes (24): 0x[01, 01, 00, 04, 00, 13, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 19, 1) to (start + 1, 14)
- Code(Zero) at (prev + 19, 1) to (start + 1, 14)
- Code(Zero) at (prev + 1, 15) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
Function name: unused::unused_func2 (unused)
Raw bytes (24): 0x[01, 01, 00, 04, 01, 19, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Raw bytes (24): 0x[01, 01, 00, 04, 00, 19, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 25, 1) to (start + 1, 14)
- Code(Zero) at (prev + 25, 1) to (start + 1, 14)
- Code(Zero) at (prev + 1, 15) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
Function name: unused::unused_func3 (unused)
Raw bytes (24): 0x[01, 01, 00, 04, 01, 1f, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Raw bytes (24): 0x[01, 01, 00, 04, 00, 1f, 01, 01, 0e, 00, 01, 0f, 02, 06, 00, 02, 06, 00, 07, 00, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 31, 1) to (start + 1, 14)
- Code(Zero) at (prev + 31, 1) to (start + 1, 14)
- Code(Zero) at (prev + 1, 15) to (start + 2, 6)
- Code(Zero) at (prev + 2, 6) to (start + 0, 7)
- Code(Zero) at (prev + 1, 1) to (start + 0, 2)
Function name: unused::unused_template_func::<_> (unused)
Raw bytes (34): 0x[01, 01, 00, 06, 01, 0b, 01, 01, 12, 00, 02, 0b, 00, 11, 00, 01, 09, 00, 0f, 00, 00, 13, 00, 19, 00, 01, 09, 00, 0f, 00, 02, 01, 00, 02]
Raw bytes (34): 0x[01, 01, 00, 06, 00, 0b, 01, 01, 12, 00, 02, 0b, 00, 11, 00, 01, 09, 00, 0f, 00, 00, 13, 00, 19, 00, 01, 09, 00, 0f, 00, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 18)
- Code(Zero) at (prev + 11, 1) to (start + 1, 18)
- Code(Zero) at (prev + 2, 11) to (start + 0, 17)
- Code(Zero) at (prev + 1, 9) to (start + 0, 15)
- Code(Zero) at (prev + 0, 19) to (start + 0, 25)

62
tests/coverage-map/status-quo/yield.cov-map
View File

@ -1,54 +1,44 @@
Function name: yield::main
Raw bytes (118): 0x[01, 01, 11, 01, 00, 05, 09, 0d, 00, 0d, 11, 32, 15, 0d, 11, 11, 15, 2e, 00, 32, 15, 0d, 11, 2e, 00, 32, 15, 0d, 11, 19, 1d, 21, 00, 25, 29, 2d, 00, 10, 01, 07, 01, 01, 16, 03, 06, 0b, 00, 2e, 0d, 01, 27, 00, 29, 07, 01, 0e, 00, 34, 0b, 02, 0b, 00, 2e, 32, 01, 22, 00, 27, 2e, 00, 2c, 00, 2e, 1b, 01, 0e, 00, 34, 1f, 03, 09, 00, 16, 2b, 07, 0b, 00, 2e, 21, 01, 27, 00, 29, 37, 01, 0e, 00, 34, 3b, 02, 0b, 00, 2e, 2d, 01, 27, 00, 29, 3f, 01, 0e, 00, 34, 43, 02, 01, 00, 02]
Raw bytes (106): 0x[01, 01, 0b, 05, 09, 0d, 11, 22, 15, 0d, 11, 11, 15, 22, 15, 0d, 11, 22, 15, 0d, 11, 19, 1d, 25, 29, 10, 01, 07, 01, 01, 16, 01, 06, 0b, 00, 2e, 0d, 01, 27, 00, 29, 03, 01, 0e, 00, 34, 0d, 02, 0b, 00, 2e, 22, 01, 22, 00, 27, 1e, 00, 2c, 00, 2e, 13, 01, 0e, 00, 34, 1e, 03, 09, 00, 16, 1e, 07, 0b, 00, 2e, 21, 01, 27, 00, 29, 27, 01, 0e, 00, 34, 21, 02, 0b, 00, 2e, 2d, 01, 27, 00, 29, 2b, 01, 0e, 00, 34, 2d, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 17
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(3), rhs = Zero
Number of expressions: 11
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Counter(3), rhs = Counter(4)
- expression 2 operands: lhs = Expression(8, Sub), rhs = Counter(5)
- expression 3 operands: lhs = Counter(3), rhs = Counter(4)
- expression 4 operands: lhs = Expression(12, Sub), rhs = Counter(5)
- expression 5 operands: lhs = Counter(3), rhs = Counter(4)
- expression 6 operands: lhs = Counter(4), rhs = Counter(5)
- expression 7 operands: lhs = Expression(11, Sub), rhs = Zero
- expression 8 operands: lhs = Expression(12, Sub), rhs = Counter(5)
- expression 9 operands: lhs = Counter(3), rhs = Counter(4)
- expression 10 operands: lhs = Expression(11, Sub), rhs = Zero
- expression 11 operands: lhs = Expression(12, Sub), rhs = Counter(5)
- expression 12 operands: lhs = Counter(3), rhs = Counter(4)
- expression 13 operands: lhs = Counter(6), rhs = Counter(7)
- expression 14 operands: lhs = Counter(8), rhs = Zero
- expression 15 operands: lhs = Counter(9), rhs = Counter(10)
- expression 16 operands: lhs = Counter(11), rhs = Zero
- expression 4 operands: lhs = Counter(4), rhs = Counter(5)
- expression 5 operands: lhs = Expression(8, Sub), rhs = Counter(5)
- expression 6 operands: lhs = Counter(3), rhs = Counter(4)
- expression 7 operands: lhs = Expression(8, Sub), rhs = Counter(5)
- expression 8 operands: lhs = Counter(3), rhs = Counter(4)
- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
- expression 10 operands: lhs = Counter(9), rhs = Counter(10)
Number of file 0 mappings: 16
- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 22)
- Code(Expression(0, Add)) at (prev + 6, 11) to (start + 0, 46)
= (c0 + Zero)
- Code(Counter(0)) at (prev + 6, 11) to (start + 0, 46)
- Code(Counter(3)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(1, Add)) at (prev + 1, 14) to (start + 0, 52)
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c1 + c2)
- Code(Expression(2, Add)) at (prev + 2, 11) to (start + 0, 46)
= (c3 + Zero)
- Code(Expression(12, Sub)) at (prev + 1, 34) to (start + 0, 39)
- Code(Counter(3)) at (prev + 2, 11) to (start + 0, 46)
- Code(Expression(8, Sub)) at (prev + 1, 34) to (start + 0, 39)
= (c3 - c4)
- Code(Expression(11, Sub)) at (prev + 0, 44) to (start + 0, 46)
- Code(Expression(7, Sub)) at (prev + 0, 44) to (start + 0, 46)
= ((c3 - c4) - c5)
- Code(Expression(6, Add)) at (prev + 1, 14) to (start + 0, 52)
- Code(Expression(4, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c4 + c5)
- Code(Expression(7, Add)) at (prev + 3, 9) to (start + 0, 22)
= (((c3 - c4) - c5) + Zero)
- Code(Expression(10, Add)) at (prev + 7, 11) to (start + 0, 46)
= (((c3 - c4) - c5) + Zero)
- Code(Expression(7, Sub)) at (prev + 3, 9) to (start + 0, 22)
= ((c3 - c4) - c5)
- Code(Expression(7, Sub)) at (prev + 7, 11) to (start + 0, 46)
= ((c3 - c4) - c5)
- Code(Counter(8)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(13, Add)) at (prev + 1, 14) to (start + 0, 52)
- Code(Expression(9, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c6 + c7)
- Code(Expression(14, Add)) at (prev + 2, 11) to (start + 0, 46)
= (c8 + Zero)
- Code(Counter(8)) at (prev + 2, 11) to (start + 0, 46)
- Code(Counter(11)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(15, Add)) at (prev + 1, 14) to (start + 0, 52)
- Code(Expression(10, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c9 + c10)
- Code(Expression(16, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c11 + Zero)
- Code(Counter(11)) at (prev + 2, 1) to (start + 0, 2)
Function name: yield::main::{closure#0}
Raw bytes (14): 0x[01, 01, 00, 02, 01, 08, 1c, 01, 10, 05, 02, 10, 01, 06]

2
tests/mir-opt/instrument_coverage.bar.InstrumentCoverage.diff
View File

@ -5,7 +5,7 @@
let mut _0: bool;
bb0: {
+ Coverage::Counter(0) for /the/src/instrument_coverage.rs:20:1 - 22:2;
+ Coverage::Counter(0) for [/the/src/instrument_coverage.rs:20:1 - 22:2];
_0 = const true;
return;
}

9
tests/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
View File

@ -8,12 +8,12 @@
let mut _3: !;
bb0: {
+ Coverage::Counter(0) for /the/src/instrument_coverage.rs:11:1 - 11:11;
+ Coverage::Counter(0) for [/the/src/instrument_coverage.rs:11:1 - 11:11];
goto -> bb1;
}
bb1: {
+ Coverage::Expression(0) = Counter(0) + Counter(1) for /the/src/instrument_coverage.rs:12:5 - 13:17;
+ Coverage::Expression(0) = Counter(0) + Counter(1) for [/the/src/instrument_coverage.rs:12:5 - 13:17];
falseUnwind -> [real: bb2, unwind: bb6];
}
@ -27,15 +27,14 @@
}
bb4: {
+ Coverage::Expression(2) = Expression(1) + Zero for /the/src/instrument_coverage.rs:17:1 - 17:2;
+ Coverage::Expression(1) = Expression(0) - Counter(1) for /the/src/instrument_coverage.rs:14:13 - 14:18;
+ Coverage::Expression(1) = Expression(0) - Counter(1) for [/the/src/instrument_coverage.rs:14:13 - 14:18, /the/src/instrument_coverage.rs:17:1 - 17:2];
_0 = const ();
StorageDead(_2);
return;
}
bb5: {
+ Coverage::Counter(1) for /the/src/instrument_coverage.rs:15:10 - 15:11;
+ Coverage::Counter(1) for [/the/src/instrument_coverage.rs:15:10 - 15:11];
_1 = const ();
StorageDead(_2);
goto -> bb1;