nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-14 02:49:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #133849 - Zalathar:replay, r=oli-obk

Browse Source 
coverage: Use a separate counter type and simplification step during counter creation

When instrumenting a function's MIR for coverage, there is a point where we need to decide, for each node in the control-flow graph, whether its execution count will be tracked by a physical counter, or by an expression that combines physical counters from other parts of the graph.

Currently the code for doing that is heavily tied to the final form of the LLVM coverage mapping format, and performs some important simplification steps on-the-fly. These factors make the code extremely difficult to modify without breaking or massively worsening the resulting coverage-instrumentation metadata.

---

This PR aims to improve that situation somewhat by adding an extra intermediate representation between the code that chooses how each node will be counted, and the code that converts those decisions into actual tables of physical counters and trees of counter expressions.

As part of doing that, some of the simplifications that are currently performed during the main counter creation step have been pulled out into a separate step.

In most cases the resulting coverage metadata is equivalent, slightly better, or slightly worse. The biggest outlier is `counters.rs`, where the coverage metadata ends up about 10% larger. This seems to be the result of the new approach having less subexpression sharing (because it relies on flatten-sort-cancel), and therefore being less effective at taking advantage of MIR optimizations to replace counters for unused control-flow with zeroes. I think the modest downside is acceptable in light of the future possibilities opened up by this decoupling.
This commit is contained in:
Matthias Krüger 2024-12-04 18:23:42 +01:00 committed by GitHub
commit 553db5faee
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
38 changed files with 1720 additions and 1590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,3 +1,4 @@
use std::cmp::Ordering;
use std::fmt::{self, Debug};
use rustc_data_structures::captures::Captures;
@ -10,9 +11,12 @@ use tracing::{debug, debug_span, instrument};
use crate::coverage::graph::{BasicCoverageBlock, CoverageGraph, TraverseCoverageGraphWithLoops};
#[cfg(test)]
mod tests;
/// The coverage counter or counter expression associated with a particular
/// BCB node or BCB edge.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum BcbCounter {
Counter { id: CounterId },
Expression { id: ExpressionId },
@ -43,8 +47,9 @@ struct BcbExpression {
rhs: BcbCounter,
}
#[derive(Debug)]
pub(super) enum CounterIncrementSite {
/// Enum representing either a node or an edge in the coverage graph.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(super) enum Site {
Node { bcb: BasicCoverageBlock },
Edge { from_bcb: BasicCoverageBlock, to_bcb: BasicCoverageBlock },
}
@ -54,16 +59,10 @@ pub(super) enum CounterIncrementSite {
pub(super) struct CoverageCounters {
/// List of places where a counter-increment statement should be injected
/// into MIR, each with its corresponding counter ID.
counter_increment_sites: IndexVec<CounterId, CounterIncrementSite>,
counter_increment_sites: IndexVec<CounterId, Site>,
/// Coverage counters/expressions that are associated with individual BCBs.
node_counters: IndexVec<BasicCoverageBlock, Option<BcbCounter>>,
/// Coverage counters/expressions that are associated with the control-flow
/// edge between two BCBs.
///
/// We currently don't iterate over this map, but if we do in the future,
/// switch it back to `FxIndexMap` to avoid query stability hazards.
edge_counters: FxHashMap<(BasicCoverageBlock, BasicCoverageBlock), BcbCounter>,
/// Table of expression data, associating each expression ID with its
/// corresponding operator (+ or -) and its LHS/RHS operands.
@ -83,93 +82,30 @@ impl CoverageCounters {
let mut builder = CountersBuilder::new(graph, bcb_needs_counter);
builder.make_bcb_counters();
builder.counters
builder.into_coverage_counters()
}
fn with_num_bcbs(num_bcbs: usize) -> Self {
Self {
counter_increment_sites: IndexVec::new(),
node_counters: IndexVec::from_elem_n(None, num_bcbs),
edge_counters: FxHashMap::default(),
expressions: IndexVec::new(),
expressions_memo: FxHashMap::default(),
}
}
/// Shared helper used by [`Self::make_phys_node_counter`] and
/// [`Self::make_phys_edge_counter`]. Don't call this directly.
fn make_counter_inner(&mut self, site: CounterIncrementSite) -> BcbCounter {
/// Creates a new physical counter for a BCB node or edge.
fn make_phys_counter(&mut self, site: Site) -> BcbCounter {
let id = self.counter_increment_sites.push(site);
BcbCounter::Counter { id }
}
/// Creates a new physical counter for a BCB node.
fn make_phys_node_counter(&mut self, bcb: BasicCoverageBlock) -> BcbCounter {
self.make_counter_inner(CounterIncrementSite::Node { bcb })
}
/// Creates a new physical counter for a BCB edge.
fn make_phys_edge_counter(
&mut self,
from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock,
) -> BcbCounter {
self.make_counter_inner(CounterIncrementSite::Edge { from_bcb, to_bcb })
}
fn make_expression(&mut self, lhs: BcbCounter, op: Op, rhs: BcbCounter) -> BcbCounter {
let new_expr = BcbExpression { lhs, op, rhs };
*self
.expressions_memo
.entry(new_expr)
.or_insert_with(|| Self::make_expression_inner(&mut self.expressions, new_expr))
}
/// This is an associated function so that we can call it while borrowing
/// `&mut self.expressions_memo`.
fn make_expression_inner(
expressions: &mut IndexVec<ExpressionId, BcbExpression>,
new_expr: BcbExpression,
) -> BcbCounter {
// Simplify expressions using basic algebra.
//
// Some of these cases might not actually occur in practice, depending
// on the details of how the instrumentor builds expressions.
let BcbExpression { lhs, op, rhs } = new_expr;
if let BcbCounter::Expression { id } = lhs {
let lhs_expr = &expressions[id];
// Simplify `(a - b) + b` to `a`.
if lhs_expr.op == Op::Subtract && op == Op::Add && lhs_expr.rhs == rhs {
return lhs_expr.lhs;
}
// Simplify `(a + b) - b` to `a`.
if lhs_expr.op == Op::Add && op == Op::Subtract && lhs_expr.rhs == rhs {
return lhs_expr.lhs;
}
// Simplify `(a + b) - a` to `b`.
if lhs_expr.op == Op::Add && op == Op::Subtract && lhs_expr.lhs == rhs {
return lhs_expr.rhs;
}
}
if let BcbCounter::Expression { id } = rhs {
let rhs_expr = &expressions[id];
// Simplify `a + (b - a)` to `b`.
if op == Op::Add && rhs_expr.op == Op::Subtract && lhs == rhs_expr.rhs {
return rhs_expr.lhs;
}
// Simplify `a - (a - b)` to `b`.
if op == Op::Subtract && rhs_expr.op == Op::Subtract && lhs == rhs_expr.lhs {
return rhs_expr.rhs;
}
}
// Simplification failed, so actually create the new expression.
let id = expressions.push(new_expr);
BcbCounter::Expression { id }
*self.expressions_memo.entry(new_expr).or_insert_with(|| {
let id = self.expressions.push(new_expr);
BcbCounter::Expression { id }
})
}
/// Creates a counter that is the sum of the given counters.
@ -182,6 +118,12 @@ impl CoverageCounters {
.reduce(|accum, counter| self.make_expression(accum, Op::Add, counter))
}
/// Creates a counter whose value is `lhs - SUM(rhs)`.
fn make_subtracted_sum(&mut self, lhs: BcbCounter, rhs: &[BcbCounter]) -> BcbCounter {
let Some(rhs_sum) = self.make_sum(rhs) else { return lhs };
self.make_expression(lhs, Op::Subtract, rhs_sum)
}
pub(super) fn num_counters(&self) -> usize {
self.counter_increment_sites.len()
}
@ -195,20 +137,6 @@ impl CoverageCounters {
counter
}
fn set_edge_counter(
&mut self,
from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock,
counter: BcbCounter,
) -> BcbCounter {
let existing = self.edge_counters.insert((from_bcb, to_bcb), counter);
assert!(
existing.is_none(),
"edge ({from_bcb:?} -> {to_bcb:?}) already has a counter: {existing:?} => {counter:?}"
);
counter
}
pub(super) fn term_for_bcb(&self, bcb: BasicCoverageBlock) -> Option<CovTerm> {
self.node_counters[bcb].map(|counter| counter.as_term())
}
@ -218,8 +146,8 @@ impl CoverageCounters {
/// each site's corresponding counter ID.
pub(super) fn counter_increment_sites(
&self,
) -> impl Iterator<Item = (CounterId, &CounterIncrementSite)> {
self.counter_increment_sites.iter_enumerated()
) -> impl Iterator<Item = (CounterId, Site)> + Captures<'_> {
self.counter_increment_sites.iter_enumerated().map(|(id, &site)| (id, site))
}
/// Returns an iterator over the subset of BCB nodes that have been associated
@ -254,22 +182,53 @@ impl CoverageCounters {
}
}
/// Symbolic representation of the coverage counter to be used for a particular
/// node or edge in the coverage graph. The same site counter can be used for
/// multiple sites, if they have been determined to have the same count.
#[derive(Clone, Copy, Debug)]
enum SiteCounter {
/// A physical counter at some node/edge.
Phys { site: Site },
/// A counter expression for a node that takes the sum of all its in-edge
/// counters.
NodeSumExpr { bcb: BasicCoverageBlock },
/// A counter expression for an edge that takes the counter of its source
/// node, and subtracts the counters of all its sibling out-edges.
EdgeDiffExpr { from_bcb: BasicCoverageBlock, to_bcb: BasicCoverageBlock },
}
/// Yields the graph successors of `from_bcb` that aren't `to_bcb`. This is
/// used when creating a counter expression for [`SiteCounter::EdgeDiffExpr`].
///
/// For example, in this diagram the sibling out-edge targets of edge `AC` are
/// the nodes `B` and `D`.
///
/// ```text
/// A
/// / | \
/// B C D
/// ```
fn sibling_out_edge_targets(
graph: &CoverageGraph,
from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock,
) -> impl Iterator<Item = BasicCoverageBlock> + Captures<'_> {
graph.successors[from_bcb].iter().copied().filter(move |&t| t != to_bcb)
}
/// Helper struct that allows counter creation to inspect the BCB graph, and
/// the set of nodes that need counters.
struct CountersBuilder<'a> {
counters: CoverageCounters,
graph: &'a CoverageGraph,
bcb_needs_counter: &'a BitSet<BasicCoverageBlock>,
site_counters: FxHashMap<Site, SiteCounter>,
}
impl<'a> CountersBuilder<'a> {
fn new(graph: &'a CoverageGraph, bcb_needs_counter: &'a BitSet<BasicCoverageBlock>) -> Self {
assert_eq!(graph.num_nodes(), bcb_needs_counter.domain_size());
Self {
counters: CoverageCounters::with_num_bcbs(graph.num_nodes()),
graph,
bcb_needs_counter,
}
Self { graph, bcb_needs_counter, site_counters: FxHashMap::default() }
}
fn make_bcb_counters(&mut self) {
@ -302,9 +261,7 @@ impl<'a> CountersBuilder<'a> {
fn make_node_counter_and_out_edge_counters(&mut self, from_bcb: BasicCoverageBlock) {
// First, ensure that this node has a counter of some kind.
// We might also use that counter to compute one of the out-edge counters.
let node_counter = self.get_or_make_node_counter(from_bcb);
let successors = self.graph.successors[from_bcb].as_slice();
self.get_or_make_node_counter(from_bcb);
// If this node's out-edges won't sum to the node's counter,
// then there's no reason to create edge counters here.
@ -315,11 +272,11 @@ impl<'a> CountersBuilder<'a> {
// When choosing which out-edge should be given a counter expression, ignore edges that
// already have counters, or could use the existing counter of their target node.
let out_edge_has_counter = |to_bcb| {
if self.counters.edge_counters.contains_key(&(from_bcb, to_bcb)) {
if self.site_counters.contains_key(&Site::Edge { from_bcb, to_bcb }) {
return true;
}
self.graph.sole_predecessor(to_bcb) == Some(from_bcb)
&& self.counters.node_counters[to_bcb].is_some()
&& self.site_counters.contains_key(&Site::Node { bcb: to_bcb })
};
// Determine the set of out-edges that could benefit from being given an expression.
@ -332,51 +289,41 @@ impl<'a> CountersBuilder<'a> {
// If there are out-edges without counters, choose one to be given an expression
// (computed from this node and the other out-edges) instead of a physical counter.
let Some(target_bcb) = self.choose_out_edge_for_expression(from_bcb, &candidate_successors)
let Some(to_bcb) = self.choose_out_edge_for_expression(from_bcb, &candidate_successors)
else {
return;
};
// For each out-edge other than the one that was chosen to get an expression,
// ensure that it has a counter (existing counter/expression or a new counter),
// and accumulate the corresponding counters into a single sum expression.
let other_out_edge_counters = successors
.iter()
.copied()
// Skip the chosen edge, since we'll calculate its count from this sum.
.filter(|&edge_target_bcb| edge_target_bcb != target_bcb)
.map(|to_bcb| self.get_or_make_edge_counter(from_bcb, to_bcb))
.collect::<Vec<_>>();
let Some(sum_of_all_other_out_edges) = self.counters.make_sum(&other_out_edge_counters)
else {
return;
};
// ensure that it has a counter (existing counter/expression or a new counter).
for target in sibling_out_edge_targets(self.graph, from_bcb, to_bcb) {
self.get_or_make_edge_counter(from_bcb, target);
}
// Now create an expression for the chosen edge, by taking the counter
// for its source node and subtracting the sum of its sibling out-edges.
let expression =
self.counters.make_expression(node_counter, Op::Subtract, sum_of_all_other_out_edges);
debug!("{target_bcb:?} gets an expression: {expression:?}");
self.counters.set_edge_counter(from_bcb, target_bcb, expression);
let counter = SiteCounter::EdgeDiffExpr { from_bcb, to_bcb };
self.site_counters.insert(Site::Edge { from_bcb, to_bcb }, counter);
}
#[instrument(level = "debug", skip(self))]
fn get_or_make_node_counter(&mut self, bcb: BasicCoverageBlock) -> BcbCounter {
fn get_or_make_node_counter(&mut self, bcb: BasicCoverageBlock) -> SiteCounter {
// If the BCB already has a counter, return it.
if let Some(counter) = self.counters.node_counters[bcb] {
if let Some(&counter) = self.site_counters.get(&Site::Node { bcb }) {
debug!("{bcb:?} already has a counter: {counter:?}");
return counter;
}
let counter = self.make_node_counter_inner(bcb);
self.counters.set_node_counter(bcb, counter)
self.site_counters.insert(Site::Node { bcb }, counter);
counter
}
fn make_node_counter_inner(&mut self, bcb: BasicCoverageBlock) -> BcbCounter {
fn make_node_counter_inner(&mut self, bcb: BasicCoverageBlock) -> SiteCounter {
// If the node's sole in-edge already has a counter, use that.
if let Some(sole_pred) = self.graph.sole_predecessor(bcb)
&& let Some(&edge_counter) = self.counters.edge_counters.get(&(sole_pred, bcb))
&& let Some(&edge_counter) =
self.site_counters.get(&Site::Edge { from_bcb: sole_pred, to_bcb: bcb })
{
return edge_counter;
}
@ -390,20 +337,17 @@ impl<'a> CountersBuilder<'a> {
// leading to infinite recursion.
if predecessors.len() <= 1 || predecessors.contains(&bcb) {
debug!(?bcb, ?predecessors, "node has <=1 predecessors or is its own predecessor");
let counter = self.counters.make_phys_node_counter(bcb);
let counter = SiteCounter::Phys { site: Site::Node { bcb } };
debug!(?bcb, ?counter, "node gets a physical counter");
return counter;
}
// A BCB with multiple incoming edges can compute its count by ensuring that counters
// exist for each of those edges, and then adding them up to get a total count.
let in_edge_counters = predecessors
.iter()
.copied()
.map(|from_bcb| self.get_or_make_edge_counter(from_bcb, bcb))
.collect::<Vec<_>>();
let sum_of_in_edges: BcbCounter =
self.counters.make_sum(&in_edge_counters).expect("there must be at least one in-edge");
for &from_bcb in predecessors {
self.get_or_make_edge_counter(from_bcb, bcb);
}
let sum_of_in_edges = SiteCounter::NodeSumExpr { bcb };
debug!("{bcb:?} gets a new counter (sum of predecessor counters): {sum_of_in_edges:?}");
sum_of_in_edges
@ -414,22 +358,23 @@ impl<'a> CountersBuilder<'a> {
&mut self,
from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock,
) -> BcbCounter {
) -> SiteCounter {
// If the edge already has a counter, return it.
if let Some(&counter) = self.counters.edge_counters.get(&(from_bcb, to_bcb)) {
if let Some(&counter) = self.site_counters.get(&Site::Edge { from_bcb, to_bcb }) {
debug!("Edge {from_bcb:?}->{to_bcb:?} already has a counter: {counter:?}");
return counter;
}
let counter = self.make_edge_counter_inner(from_bcb, to_bcb);
self.counters.set_edge_counter(from_bcb, to_bcb, counter)
self.site_counters.insert(Site::Edge { from_bcb, to_bcb }, counter);
counter
}
fn make_edge_counter_inner(
&mut self,
from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock,
) -> BcbCounter {
) -> SiteCounter {
// If the target node has exactly one in-edge (i.e. this one), then just
// use the node's counter, since it will have the same value.
if let Some(sole_pred) = self.graph.sole_predecessor(to_bcb) {
@ -447,7 +392,7 @@ impl<'a> CountersBuilder<'a> {
}
// Make a new counter to count this edge.
let counter = self.counters.make_phys_edge_counter(from_bcb, to_bcb);
let counter = SiteCounter::Phys { site: Site::Edge { from_bcb, to_bcb } };
debug!(?from_bcb, ?to_bcb, ?counter, "edge gets a physical counter");
counter
}
@ -510,4 +455,145 @@ impl<'a> CountersBuilder<'a> {
None
}
fn into_coverage_counters(self) -> CoverageCounters {
Transcriber::new(&self).transcribe_counters()
}
}
/// Helper struct for converting `CountersBuilder` into a final `CoverageCounters`.
struct Transcriber<'a> {
old: &'a CountersBuilder<'a>,
new: CoverageCounters,
phys_counter_for_site: FxHashMap<Site, BcbCounter>,
}
impl<'a> Transcriber<'a> {
fn new(old: &'a CountersBuilder<'a>) -> Self {
Self {
old,
new: CoverageCounters::with_num_bcbs(old.graph.num_nodes()),
phys_counter_for_site: FxHashMap::default(),
}
}
fn transcribe_counters(mut self) -> CoverageCounters {
for bcb in self.old.bcb_needs_counter.iter() {
let site = Site::Node { bcb };
let site_counter = self.site_counter(site);
// Resolve the site counter into flat lists of nodes/edges whose
// physical counts contribute to the counter for this node.
// Distinguish between counts that will be added vs subtracted.
let mut pos = vec![];
let mut neg = vec![];
self.push_resolved_sites(site_counter, &mut pos, &mut neg);
// Simplify by cancelling out sites that appear on both sides.
let (mut pos, mut neg) = sort_and_cancel(pos, neg);
if pos.is_empty() {
// If we somehow end up with no positive terms after cancellation,
// fall back to creating a physical counter. There's no known way
// for this to happen, but it's hard to confidently rule it out.
debug_assert!(false, "{site:?} has no positive counter terms");
pos = vec![Some(site)];
neg = vec![];
}
let mut new_counters_for_sites = |sites: Vec<Option<Site>>| {
sites
.into_iter()
.filter_map(|id| try { self.ensure_phys_counter(id?) })
.collect::<Vec<_>>()
};
let mut pos = new_counters_for_sites(pos);
let mut neg = new_counters_for_sites(neg);
pos.sort();
neg.sort();
let pos_counter = self.new.make_sum(&pos).expect("`pos` should not be empty");
let new_counter = self.new.make_subtracted_sum(pos_counter, &neg);
self.new.set_node_counter(bcb, new_counter);
}
self.new
}
fn site_counter(&self, site: Site) -> SiteCounter {
self.old.site_counters.get(&site).copied().unwrap_or_else(|| {
// We should have already created all necessary site counters.
// But if we somehow didn't, avoid crashing in release builds,
// and just use an extra physical counter instead.
debug_assert!(false, "{site:?} should have a counter");
SiteCounter::Phys { site }
})
}
fn ensure_phys_counter(&mut self, site: Site) -> BcbCounter {
*self.phys_counter_for_site.entry(site).or_insert_with(|| self.new.make_phys_counter(site))
}
/// Resolves the given counter into flat lists of nodes/edges, whose counters
/// will then be added and subtracted to form a counter expression.
fn push_resolved_sites(&self, counter: SiteCounter, pos: &mut Vec<Site>, neg: &mut Vec<Site>) {
match counter {
SiteCounter::Phys { site } => pos.push(site),
SiteCounter::NodeSumExpr { bcb } => {
for &from_bcb in &self.old.graph.predecessors[bcb] {
let edge_counter = self.site_counter(Site::Edge { from_bcb, to_bcb: bcb });
self.push_resolved_sites(edge_counter, pos, neg);
}
}
SiteCounter::EdgeDiffExpr { from_bcb, to_bcb } => {
// First, add the count for `from_bcb`.
let node_counter = self.site_counter(Site::Node { bcb: from_bcb });
self.push_resolved_sites(node_counter, pos, neg);
// Then subtract the counts for the other out-edges.
for target in sibling_out_edge_targets(self.old.graph, from_bcb, to_bcb) {
let edge_counter = self.site_counter(Site::Edge { from_bcb, to_bcb: target });
// Swap `neg` and `pos` so that the counter is subtracted.
self.push_resolved_sites(edge_counter, neg, pos);
}
}
}
}
}
/// Given two lists:
/// - Sorts each list.
/// - Converts each list to `Vec<Option<T>>`.
/// - Scans for values that appear in both lists, and cancels them out by
/// replacing matching pairs of values with `None`.
fn sort_and_cancel<T: Ord>(mut pos: Vec<T>, mut neg: Vec<T>) -> (Vec<Option<T>>, Vec<Option<T>>) {
pos.sort();
neg.sort();
// Convert to `Vec<Option<T>>`. If `T` has a niche, this should be zero-cost.
let mut pos = pos.into_iter().map(Some).collect::<Vec<_>>();
let mut neg = neg.into_iter().map(Some).collect::<Vec<_>>();
// Scan through the lists using two cursors. When either cursor reaches the
// end of its list, there can be no more equal pairs, so stop.
let mut p = 0;
let mut n = 0;
while p < pos.len() && n < neg.len() {
// If the values are equal, remove them and advance both cursors.
// Otherwise, advance whichever cursor points to the lesser value.
// (Choosing which cursor to advance relies on both lists being sorted.)
match pos[p].cmp(&neg[n]) {
Ordering::Less => p += 1,
Ordering::Equal => {
pos[p] = None;
neg[n] = None;
p += 1;
n += 1;
}
Ordering::Greater => n += 1,
}
}
(pos, neg)
}

41
compiler/rustc_mir_transform/src/coverage/counters/tests.rs Normal file
View File

@ -0,0 +1,41 @@
use std::fmt::Debug;
use super::sort_and_cancel;
fn flatten<T>(input: Vec<Option<T>>) -> Vec<T> {
input.into_iter().flatten().collect()
}
fn sort_and_cancel_and_flatten<T: Clone + Ord>(pos: Vec<T>, neg: Vec<T>) -> (Vec<T>, Vec<T>) {
let (pos_actual, neg_actual) = sort_and_cancel(pos, neg);
(flatten(pos_actual), flatten(neg_actual))
}
#[track_caller]
fn check_test_case<T: Clone + Debug + Ord>(
pos: Vec<T>,
neg: Vec<T>,
pos_expected: Vec<T>,
neg_expected: Vec<T>,
) {
eprintln!("pos = {pos:?}; neg = {neg:?}");
let output = sort_and_cancel_and_flatten(pos, neg);
assert_eq!(output, (pos_expected, neg_expected));
}
#[test]
fn cancellation() {
let cases: &[(Vec<u32>, Vec<u32>, Vec<u32>, Vec<u32>)] = &[
(vec![], vec![], vec![], vec![]),
(vec![4, 2, 1, 5, 3], vec![], vec![1, 2, 3, 4, 5], vec![]),
(vec![5, 5, 5, 5, 5], vec![5], vec![5, 5, 5, 5], vec![]),
(vec![1, 1, 2, 2, 3, 3], vec![1, 2, 3], vec![1, 2, 3], vec![]),
(vec![1, 1, 2, 2, 3, 3], vec![2, 4, 2], vec![1, 1, 3, 3], vec![4]),
];
for (pos, neg, pos_expected, neg_expected) in cases {
check_test_case(pos.to_vec(), neg.to_vec(), pos_expected.to_vec(), neg_expected.to_vec());
// Same test case, but with its inputs flipped and its outputs flipped.
check_test_case(neg.to_vec(), pos.to_vec(), neg_expected.to_vec(), pos_expected.to_vec());
}
}

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

@ -25,7 +25,7 @@ use rustc_span::source_map::SourceMap;
use rustc_span::{BytePos, Pos, SourceFile, Span};
use tracing::{debug, debug_span, trace};
use crate::coverage::counters::{CounterIncrementSite, CoverageCounters};
use crate::coverage::counters::{CoverageCounters, Site};
use crate::coverage::graph::CoverageGraph;
use crate::coverage::mappings::ExtractedMappings;
@ -265,13 +265,13 @@ fn inject_coverage_statements<'tcx>(
coverage_counters: &CoverageCounters,
) {
// Inject counter-increment statements into MIR.
for (id, counter_increment_site) in coverage_counters.counter_increment_sites() {
for (id, site) in coverage_counters.counter_increment_sites() {
// Determine the block to inject a counter-increment statement into.
// For BCB nodes this is just their first block, but for edges we need
// to create a new block between the two BCBs, and inject into that.
let target_bb = match *counter_increment_site {
CounterIncrementSite::Node { bcb } => basic_coverage_blocks[bcb].leader_bb(),
CounterIncrementSite::Edge { from_bcb, to_bcb } => {
let target_bb = match site {
Site::Node { bcb } => basic_coverage_blocks[bcb].leader_bb(),
Site::Edge { from_bcb, to_bcb } => {
// Create a new block between the last block of `from_bcb` and
// the first block of `to_bcb`.
let from_bb = basic_coverage_blocks[from_bcb].last_bb();

26
tests/coverage/abort.cov-map
View File

@ -1,34 +1,34 @@
Function name: abort::main
Raw bytes (89): 0x[01, 01, 0a, 01, 27, 05, 09, 03, 0d, 22, 11, 03, 0d, 03, 0d, 22, 15, 03, 0d, 03, 0d, 05, 09, 0d, 01, 0d, 01, 01, 1b, 03, 02, 0b, 00, 18, 22, 01, 0c, 00, 19, 11, 00, 1a, 02, 0a, 0e, 02, 09, 00, 0a, 22, 02, 0c, 00, 19, 15, 00, 1a, 00, 31, 1a, 00, 30, 00, 31, 22, 04, 0c, 00, 19, 05, 00, 1a, 00, 31, 09, 00, 30, 00, 31, 27, 01, 09, 00, 17, 0d, 02, 05, 01, 02]
Raw bytes (89): 0x[01, 01, 0a, 07, 09, 01, 05, 03, 0d, 03, 13, 0d, 11, 03, 0d, 03, 1f, 0d, 15, 03, 0d, 05, 09, 0d, 01, 0d, 01, 01, 1b, 03, 02, 0b, 00, 18, 22, 01, 0c, 00, 19, 11, 00, 1a, 02, 0a, 0e, 02, 09, 00, 0a, 22, 02, 0c, 00, 19, 15, 00, 1a, 00, 31, 1a, 00, 30, 00, 31, 22, 04, 0c, 00, 19, 05, 00, 1a, 00, 31, 09, 00, 30, 00, 31, 27, 01, 09, 00, 17, 0d, 02, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 10
- expression 0 operands: lhs = Counter(0), rhs = Expression(9, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Expression(8, Sub), rhs = Counter(4)
- expression 4 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Expression(0, Add), rhs = Expression(4, Add)
- expression 4 operands: lhs = Counter(3), rhs = Counter(4)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 6 operands: lhs = Expression(8, Sub), rhs = Counter(5)
- expression 7 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 6 operands: lhs = Expression(0, Add), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(3), rhs = Counter(5)
- expression 8 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 9 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 13
- Code(Counter(0)) at (prev + 13, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
= (c0 + (c1 + c2))
= ((c0 + c1) + c2)
- Code(Expression(8, Sub)) at (prev + 1, 12) to (start + 0, 25)
= ((c0 + (c1 + c2)) - c3)
= (((c0 + c1) + c2) - c3)
- Code(Counter(4)) at (prev + 0, 26) to (start + 2, 10)
- Code(Expression(3, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (((c0 + (c1 + c2)) - c3) - c4)
= (((c0 + c1) + c2) - (c3 + c4))
- Code(Expression(8, Sub)) at (prev + 2, 12) to (start + 0, 25)
= ((c0 + (c1 + c2)) - c3)
= (((c0 + c1) + c2) - c3)
- Code(Counter(5)) at (prev + 0, 26) to (start + 0, 49)
- Code(Expression(6, Sub)) at (prev + 0, 48) to (start + 0, 49)
= (((c0 + (c1 + c2)) - c3) - c5)
= (((c0 + c1) + c2) - (c3 + c5))
- Code(Expression(8, Sub)) at (prev + 4, 12) to (start + 0, 25)
= ((c0 + (c1 + c2)) - c3)
= (((c0 + c1) + c2) - c3)
- Code(Counter(1)) at (prev + 0, 26) to (start + 0, 49)
- Code(Counter(2)) at (prev + 0, 48) to (start + 0, 49)
- Code(Expression(9, Add)) at (prev + 1, 9) to (start + 0, 23)

31
tests/coverage/assert.cov-map
View File

@ -1,29 +1,30 @@
Function name: assert::main
Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 09, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 02, 0a, 12, 02, 13, 00, 20, 09, 00, 21, 02, 0a, 0d, 02, 09, 00, 0a, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Raw bytes (67): 0x[01, 01, 09, 07, 0d, 0b, 09, 01, 05, 03, 11, 17, 11, 1b, 0d, 01, 09, 23, 0d, 05, 09, 09, 01, 09, 01, 01, 1b, 03, 02, 0b, 00, 18, 0e, 01, 0c, 00, 1a, 05, 00, 1b, 02, 0a, 12, 02, 13, 00, 20, 09, 00, 21, 02, 0a, 0d, 02, 09, 00, 0a, 1f, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
- expression 0 operands: lhs = Counter(0), rhs = Expression(6, Add)
- expression 1 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
Number of expressions: 9
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Counter(1)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(3)
- expression 6 operands: lhs = Counter(0), rhs = Counter(2)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 9, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
= (c0 + (c1 + (c2 + c3)))
- Code(Expression(5, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((c0 + (c1 + (c2 + c3))) - c4)
= (((c0 + c1) + c2) + c3)
- Code(Expression(3, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((((c0 + c1) + c2) + c3) - c4)
- Code(Counter(1)) at (prev + 0, 27) to (start + 2, 10)
- Code(Expression(4, Sub)) at (prev + 2, 19) to (start + 0, 32)
= (((c0 + (c1 + (c2 + c3))) - c4) - c1)
= (((c0 + c2) + c3) - c4)
- Code(Counter(2)) at (prev + 0, 33) to (start + 2, 10)
- Code(Counter(3)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(6, Add)) at (prev + 1, 9) to (start + 0, 23)
= (c1 + (c2 + c3))
- Code(Expression(7, Add)) at (prev + 1, 9) to (start + 0, 23)
= ((c1 + c2) + c3)
- Code(Counter(4)) at (prev + 2, 5) to (start + 1, 2)
Highest counter ID seen: c4

27
tests/coverage/async.cov-map
View File

@ -155,25 +155,25 @@ Number of file 0 mappings: 1
Highest counter ID seen: c0
Function name: async::i::{closure#0}
Raw bytes (63): 0x[01, 01, 02, 07, 19, 11, 15, 0b, 01, 2d, 13, 04, 0c, 09, 05, 09, 00, 0a, 01, 00, 0e, 00, 18, 05, 00, 1c, 00, 21, 09, 00, 27, 00, 30, 15, 01, 09, 00, 0a, 0d, 00, 0e, 00, 17, 1d, 00, 1b, 00, 20, 15, 00, 24, 00, 26, 19, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Raw bytes (63): 0x[01, 01, 02, 07, 15, 0d, 11, 0b, 01, 2d, 13, 04, 0c, 09, 05, 09, 00, 0a, 01, 00, 0e, 00, 18, 05, 00, 1c, 00, 21, 09, 00, 27, 00, 30, 11, 01, 09, 00, 0a, 19, 00, 0e, 00, 17, 1d, 00, 1b, 00, 20, 11, 00, 24, 00, 26, 15, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(6)
- expression 1 operands: lhs = Counter(4), rhs = Counter(5)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(5)
- expression 1 operands: lhs = Counter(3), rhs = Counter(4)
Number of file 0 mappings: 11
- Code(Counter(0)) at (prev + 45, 19) to (start + 4, 12)
- Code(Counter(2)) at (prev + 5, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 24)
- Code(Counter(1)) at (prev + 0, 28) to (start + 0, 33)
- Code(Counter(2)) at (prev + 0, 39) to (start + 0, 48)
- Code(Counter(5)) at (prev + 1, 9) to (start + 0, 10)
- Code(Counter(3)) at (prev + 0, 14) to (start + 0, 23)
- Code(Counter(4)) at (prev + 1, 9) to (start + 0, 10)
- Code(Counter(6)) at (prev + 0, 14) to (start + 0, 23)
- Code(Counter(7)) at (prev + 0, 27) to (start + 0, 32)
- Code(Counter(5)) at (prev + 0, 36) to (start + 0, 38)
- Code(Counter(6)) at (prev + 1, 14) to (start + 0, 16)
- Code(Counter(4)) at (prev + 0, 36) to (start + 0, 38)
- Code(Counter(5)) at (prev + 1, 14) to (start + 0, 16)
- Code(Expression(0, Add)) at (prev + 2, 1) to (start + 0, 2)
= ((c4 + c5) + c6)
= ((c3 + c4) + c5)
Highest counter ID seen: c7
Function name: async::j
@ -243,22 +243,19 @@ Number of file 0 mappings: 5
Highest counter ID seen: (none)
Function name: async::l
Raw bytes (37): 0x[01, 01, 04, 01, 07, 05, 09, 0f, 02, 09, 05, 05, 01, 52, 01, 01, 0c, 02, 02, 0e, 00, 10, 05, 01, 0e, 00, 10, 09, 01, 0e, 00, 10, 0b, 02, 01, 00, 02]
Raw bytes (33): 0x[01, 01, 02, 01, 07, 05, 09, 05, 01, 52, 01, 01, 0c, 02, 02, 0e, 00, 10, 09, 01, 0e, 00, 10, 05, 01, 0e, 00, 10, 01, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Expression(1, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Expression(3, Add), rhs = Expression(0, Sub)
- expression 3 operands: lhs = Counter(2), rhs = Counter(1)
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 82, 1) to (start + 1, 12)
- Code(Expression(0, Sub)) at (prev + 2, 14) to (start + 0, 16)
= (c0 - (c1 + c2))
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 16)
- Code(Counter(2)) at (prev + 1, 14) to (start + 0, 16)
- Code(Expression(2, Add)) at (prev + 2, 1) to (start + 0, 2)
= ((c2 + c1) + (c0 - (c1 + c2)))
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 16)
- Code(Counter(0)) at (prev + 2, 1) to (start + 0, 2)
Highest counter ID seen: c2
Function name: async::m

14
tests/coverage/branch/guard.cov-map
View File

@ -1,5 +1,5 @@
Function name: guard::branch_match_guard
Raw bytes (85): 0x[01, 01, 06, 19, 0d, 05, 09, 0f, 15, 13, 11, 17, 0d, 05, 09, 0d, 01, 0c, 01, 01, 10, 1d, 03, 0b, 00, 0c, 15, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 19, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 11, 03, 0e, 00, 0f, 1d, 00, 14, 00, 19, 20, 11, 09, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 17, 03, 0e, 02, 0a, 0b, 04, 01, 00, 02]
Raw bytes (85): 0x[01, 01, 06, 19, 0d, 05, 09, 0f, 15, 13, 11, 17, 0d, 05, 09, 0d, 01, 0c, 01, 01, 10, 02, 03, 0b, 00, 0c, 15, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 19, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 11, 03, 0e, 00, 0f, 02, 00, 14, 00, 19, 20, 11, 05, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 17, 03, 0e, 02, 0a, 0b, 04, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 6
@ -11,7 +11,8 @@ Number of expressions: 6
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 13
- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
- Code(Counter(7)) at (prev + 3, 11) to (start + 0, 12)
- Code(Expression(0, Sub)) at (prev + 3, 11) to (start + 0, 12)
= (c6 - c3)
- Code(Counter(5)) at (prev + 1, 20) to (start + 2, 10)
- Code(Counter(3)) at (prev + 3, 14) to (start + 0, 15)
- Code(Counter(6)) at (prev + 0, 20) to (start + 0, 25)
@ -20,14 +21,15 @@ Number of file 0 mappings: 13
false = (c6 - c3)
- Code(Counter(3)) at (prev + 0, 29) to (start + 2, 10)
- Code(Counter(4)) at (prev + 3, 14) to (start + 0, 15)
- Code(Counter(7)) at (prev + 0, 20) to (start + 0, 25)
- Branch { true: Counter(4), false: Counter(2) } at (prev + 0, 20) to (start + 0, 30)
- Code(Expression(0, Sub)) at (prev + 0, 20) to (start + 0, 25)
= (c6 - c3)
- Branch { true: Counter(4), false: Counter(1) } at (prev + 0, 20) to (start + 0, 30)
true = c4
false = c2
false = c1
- Code(Counter(4)) at (prev + 0, 29) to (start + 2, 10)
- Code(Expression(5, Add)) at (prev + 3, 14) to (start + 2, 10)
= (c1 + c2)
- Code(Expression(2, Add)) at (prev + 4, 1) to (start + 0, 2)
= ((((c1 + c2) + c3) + c4) + c5)
Highest counter ID seen: c7
Highest counter ID seen: c6

28
tests/coverage/branch/if.cov-map
View File

@ -1,12 +1,14 @@
Function name: if::branch_and
Raw bytes (56): 0x[01, 01, 04, 05, 09, 0d, 02, 11, 0f, 0d, 02, 08, 01, 2b, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 00, 0d, 00, 0e, 20, 11, 0d, 00, 0d, 00, 0e, 11, 00, 0f, 02, 06, 0f, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
Raw bytes (60): 0x[01, 01, 06, 05, 09, 0b, 09, 05, 11, 13, 09, 17, 11, 05, 0d, 08, 01, 2b, 01, 01, 10, 05, 03, 08, 00, 09, 20, 09, 02, 00, 08, 00, 09, 09, 00, 0d, 00, 0e, 20, 0d, 11, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 06, 02, 0c, 02, 06, 0e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 6
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Counter(3), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(4), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(3), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
- expression 5 operands: lhs = Counter(1), rhs = Counter(3)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 43, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 3, 8) to (start + 0, 9)
@ -14,14 +16,14 @@ Number of file 0 mappings: 8
true = c2
false = (c1 - c2)
- Code(Counter(2)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(4), false: Counter(3) } at (prev + 0, 13) to (start + 0, 14)
true = c4
false = c3
- Code(Counter(4)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c3 + (c1 - c2))
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c4 + (c3 + (c1 - c2)))
- Branch { true: Counter(3), false: Counter(4) } at (prev + 0, 13) to (start + 0, 14)
true = c3
false = c4
- Code(Counter(3)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c1 + c4) - c2)
- Code(Expression(3, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c1 + c3) + c4) - c2)
Highest counter ID seen: c4
Function name: if::branch_not

170
tests/coverage/branch/lazy-boolean.cov-map
View File

@ -34,39 +34,49 @@ Number of file 0 mappings: 6
Highest counter ID seen: c2
Function name: lazy_boolean::chain
Raw bytes (149): 0x[01, 01, 13, 11, 07, 0b, 16, 15, 1a, 09, 0d, 05, 09, 05, 09, 09, 0d, 47, 25, 4b, 21, 19, 1d, 03, 19, 03, 19, 3e, 1d, 03, 19, 3e, 1d, 03, 19, 47, 25, 4b, 21, 19, 1d, 13, 01, 24, 01, 01, 10, 03, 04, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 09, 16, 00, 0d, 00, 12, 09, 00, 16, 00, 1b, 20, 0d, 1a, 00, 16, 00, 1b, 0d, 00, 1f, 00, 24, 20, 11, 15, 00, 1f, 00, 24, 11, 00, 28, 00, 2d, 03, 01, 05, 00, 11, 43, 03, 09, 00, 0a, 03, 00, 0d, 00, 12, 20, 19, 3e, 00, 0d, 00, 12, 3e, 00, 16, 00, 1b, 20, 1d, 3a, 00, 16, 00, 1b, 3a, 00, 1f, 00, 24, 20, 21, 25, 00, 1f, 00, 24, 25, 00, 28, 00, 2d, 43, 01, 05, 01, 02]
Raw bytes (169): 0x[01, 01, 1d, 5b, 0d, 5f, 15, 05, 11, 05, 09, 09, 0d, 6f, 25, 73, 21, 19, 1d, 5b, 67, 5f, 15, 05, 11, 0d, 19, 5b, 67, 5f, 15, 05, 11, 0d, 19, 5b, 63, 5f, 15, 05, 11, 67, 1d, 0d, 19, 5b, 63, 5f, 15, 05, 11, 67, 1d, 0d, 19, 6f, 25, 73, 21, 19, 1d, 13, 01, 24, 01, 01, 10, 02, 04, 09, 00, 0a, 05, 00, 0d, 00, 12, 20, 09, 0e, 00, 0d, 00, 12, 09, 00, 16, 00, 1b, 20, 0d, 12, 00, 16, 00, 1b, 0d, 00, 1f, 00, 24, 20, 11, 15, 00, 1f, 00, 24, 11, 00, 28, 00, 2d, 02, 01, 05, 00, 11, 6b, 03, 09, 00, 0a, 02, 00, 0d, 00, 12, 20, 19, 32, 00, 0d, 00, 12, 32, 00, 16, 00, 1b, 20, 1d, 56, 00, 16, 00, 1b, 56, 00, 1f, 00, 24, 20, 21, 25, 00, 1f, 00, 24, 25, 00, 28, 00, 2d, 6b, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 19
- expression 0 operands: lhs = Counter(4), rhs = Expression(1, Add)
- expression 1 operands: lhs = Expression(2, Add), rhs = Expression(5, Sub)
- expression 2 operands: lhs = Counter(5), rhs = Expression(6, Sub)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Counter(1), rhs = Counter(2)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Counter(2), rhs = Counter(3)
- expression 7 operands: lhs = Expression(17, Add), rhs = Counter(9)
- expression 8 operands: lhs = Expression(18, Add), rhs = Counter(8)
- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
- expression 10 operands: lhs = Expression(0, Add), rhs = Counter(6)
- expression 11 operands: lhs = Expression(0, Add), rhs = Counter(6)
- expression 12 operands: lhs = Expression(15, Sub), rhs = Counter(7)
- expression 13 operands: lhs = Expression(0, Add), rhs = Counter(6)
- expression 14 operands: lhs = Expression(15, Sub), rhs = Counter(7)
- expression 15 operands: lhs = Expression(0, Add), rhs = Counter(6)
- expression 16 operands: lhs = Expression(17, Add), rhs = Counter(9)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(8)
- expression 18 operands: lhs = Counter(6), rhs = Counter(7)
Number of expressions: 29
- expression 0 operands: lhs = Expression(22, Add), rhs = Counter(3)
- expression 1 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 5 operands: lhs = Expression(27, Add), rhs = Counter(9)
- expression 6 operands: lhs = Expression(28, Add), rhs = Counter(8)
- expression 7 operands: lhs = Counter(6), rhs = Counter(7)
- expression 8 operands: lhs = Expression(22, Add), rhs = Expression(25, Add)
- expression 9 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 10 operands: lhs = Counter(1), rhs = Counter(4)
- expression 11 operands: lhs = Counter(3), rhs = Counter(6)
- expression 12 operands: lhs = Expression(22, Add), rhs = Expression(25, Add)
- expression 13 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 14 operands: lhs = Counter(1), rhs = Counter(4)
- expression 15 operands: lhs = Counter(3), rhs = Counter(6)
- expression 16 operands: lhs = Expression(22, Add), rhs = Expression(24, Add)
- expression 17 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 18 operands: lhs = Counter(1), rhs = Counter(4)
- expression 19 operands: lhs = Expression(25, Add), rhs = Counter(7)
- expression 20 operands: lhs = Counter(3), rhs = Counter(6)
- expression 21 operands: lhs = Expression(22, Add), rhs = Expression(24, Add)
- expression 22 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 23 operands: lhs = Counter(1), rhs = Counter(4)
- expression 24 operands: lhs = Expression(25, Add), rhs = Counter(7)
- expression 25 operands: lhs = Counter(3), rhs = Counter(6)
- expression 26 operands: lhs = Expression(27, Add), rhs = Counter(9)
- expression 27 operands: lhs = Expression(28, Add), rhs = Counter(8)
- expression 28 operands: lhs = Counter(6), rhs = Counter(7)
Number of file 0 mappings: 19
- Code(Counter(0)) at (prev + 36, 1) to (start + 1, 16)
- Code(Expression(0, Add)) at (prev + 4, 9) to (start + 0, 10)
= (c4 + ((c5 + (c2 - c3)) + (c1 - c2)))
- Code(Expression(0, Sub)) at (prev + 4, 9) to (start + 0, 10)
= (((c1 + c4) + c5) - c3)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 18)
- Branch { true: Counter(2), false: Expression(5, Sub) } at (prev + 0, 13) to (start + 0, 18)
- Branch { true: Counter(2), false: Expression(3, Sub) } at (prev + 0, 13) to (start + 0, 18)
true = c2
false = (c1 - c2)
- Code(Counter(2)) at (prev + 0, 22) to (start + 0, 27)
- Branch { true: Counter(3), false: Expression(6, Sub) } at (prev + 0, 22) to (start + 0, 27)
- Branch { true: Counter(3), false: Expression(4, Sub) } at (prev + 0, 22) to (start + 0, 27)
true = c3
false = (c2 - c3)
- Code(Counter(3)) at (prev + 0, 31) to (start + 0, 36)
@ -74,97 +84,87 @@ Number of file 0 mappings: 19
true = c4
false = c5
- Code(Counter(4)) at (prev + 0, 40) to (start + 0, 45)
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 17)
= (c4 + ((c5 + (c2 - c3)) + (c1 - c2)))
- Code(Expression(16, Add)) at (prev + 3, 9) to (start + 0, 10)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 17)
= (((c1 + c4) + c5) - c3)
- Code(Expression(26, Add)) at (prev + 3, 9) to (start + 0, 10)
= (((c6 + c7) + c8) + c9)
- Code(Expression(0, Add)) at (prev + 0, 13) to (start + 0, 18)
= (c4 + ((c5 + (c2 - c3)) + (c1 - c2)))
- Branch { true: Counter(6), false: Expression(15, Sub) } at (prev + 0, 13) to (start + 0, 18)
- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 18)
= (((c1 + c4) + c5) - c3)
- Branch { true: Counter(6), false: Expression(12, Sub) } at (prev + 0, 13) to (start + 0, 18)
true = c6
false = ((c4 + ((c5 + (c2 - c3)) + (c1 - c2))) - c6)
- Code(Expression(15, Sub)) at (prev + 0, 22) to (start + 0, 27)
= ((c4 + ((c5 + (c2 - c3)) + (c1 - c2))) - c6)
- Branch { true: Counter(7), false: Expression(14, Sub) } at (prev + 0, 22) to (start + 0, 27)
false = (((c1 + c4) + c5) - (c3 + c6))
- Code(Expression(12, Sub)) at (prev + 0, 22) to (start + 0, 27)
= (((c1 + c4) + c5) - (c3 + c6))
- Branch { true: Counter(7), false: Expression(21, Sub) } at (prev + 0, 22) to (start + 0, 27)
true = c7
false = (((c4 + ((c5 + (c2 - c3)) + (c1 - c2))) - c6) - c7)
- Code(Expression(14, Sub)) at (prev + 0, 31) to (start + 0, 36)
= (((c4 + ((c5 + (c2 - c3)) + (c1 - c2))) - c6) - c7)
false = (((c1 + c4) + c5) - ((c3 + c6) + c7))
- Code(Expression(21, Sub)) at (prev + 0, 31) to (start + 0, 36)
= (((c1 + c4) + c5) - ((c3 + c6) + c7))
- Branch { true: Counter(8), false: Counter(9) } at (prev + 0, 31) to (start + 0, 36)
true = c8
false = c9
- Code(Counter(9)) at (prev + 0, 40) to (start + 0, 45)
- Code(Expression(16, Add)) at (prev + 1, 5) to (start + 1, 2)
- Code(Expression(26, Add)) at (prev + 1, 5) to (start + 1, 2)
= (((c6 + c7) + c8) + c9)
Highest counter ID seen: c9
Function name: lazy_boolean::nested_mixed
Raw bytes (155): 0x[01, 01, 16, 33, 1a, 09, 0d, 1e, 0d, 05, 09, 05, 09, 05, 09, 1e, 0d, 05, 09, 09, 0d, 33, 11, 09, 0d, 33, 11, 09, 0d, 19, 57, 1d, 21, 03, 15, 15, 19, 4a, 4e, 15, 19, 03, 15, 19, 57, 1d, 21, 13, 01, 31, 01, 01, 10, 03, 04, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 09, 1e, 00, 0e, 00, 13, 1e, 00, 17, 00, 1d, 20, 0d, 1a, 00, 17, 00, 1d, 33, 00, 23, 00, 28, 20, 11, 2e, 00, 23, 00, 28, 2e, 00, 2c, 00, 33, 03, 01, 05, 00, 11, 53, 03, 09, 00, 0a, 03, 00, 0e, 00, 13, 20, 15, 4e, 00, 0e, 00, 13, 15, 00, 17, 00, 1c, 20, 19, 4a, 00, 17, 00, 1c, 47, 00, 22, 00, 28, 20, 1d, 21, 00, 22, 00, 28, 1d, 00, 2c, 00, 33, 53, 01, 05, 01, 02]
Raw bytes (141): 0x[01, 01, 0f, 05, 09, 05, 1f, 09, 0d, 09, 0d, 1f, 11, 09, 0d, 1f, 11, 09, 0d, 3b, 21, 19, 1d, 05, 15, 15, 19, 05, 19, 3b, 21, 19, 1d, 13, 01, 31, 01, 01, 10, 05, 04, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 09, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 0d, 06, 00, 17, 00, 1d, 1f, 00, 23, 00, 28, 20, 11, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 05, 01, 05, 00, 11, 37, 03, 09, 00, 0a, 05, 00, 0e, 00, 13, 20, 15, 2a, 00, 0e, 00, 13, 15, 00, 17, 00, 1c, 20, 19, 2e, 00, 17, 00, 1c, 32, 00, 22, 00, 28, 20, 1d, 21, 00, 22, 00, 28, 1d, 00, 2c, 00, 33, 37, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 22
- expression 0 operands: lhs = Expression(12, Add), rhs = Expression(6, Sub)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Expression(7, Sub), rhs = Counter(3)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Counter(1), rhs = Counter(2)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(3)
- expression 7 operands: lhs = Counter(1), rhs = Counter(2)
- expression 8 operands: lhs = Counter(2), rhs = Counter(3)
- expression 9 operands: lhs = Expression(12, Add), rhs = Counter(4)
- expression 10 operands: lhs = Counter(2), rhs = Counter(3)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(4)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
- expression 13 operands: lhs = Counter(6), rhs = Expression(21, Add)
- expression 14 operands: lhs = Counter(7), rhs = Counter(8)
- expression 15 operands: lhs = Expression(0, Add), rhs = Counter(5)
- expression 16 operands: lhs = Counter(5), rhs = Counter(6)
- expression 17 operands: lhs = Expression(18, Sub), rhs = Expression(19, Sub)
- expression 18 operands: lhs = Counter(5), rhs = Counter(6)
- expression 19 operands: lhs = Expression(0, Add), rhs = Counter(5)
- expression 20 operands: lhs = Counter(6), rhs = Expression(21, Add)
- expression 21 operands: lhs = Counter(7), rhs = Counter(8)
Number of expressions: 15
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(7, Add), rhs = Counter(4)
- expression 5 operands: lhs = Counter(2), rhs = Counter(3)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 8 operands: lhs = Expression(14, Add), rhs = Counter(8)
- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
- expression 10 operands: lhs = Counter(1), rhs = Counter(5)
- expression 11 operands: lhs = Counter(5), rhs = Counter(6)
- expression 12 operands: lhs = Counter(1), rhs = Counter(6)
- expression 13 operands: lhs = Expression(14, Add), rhs = Counter(8)
- expression 14 operands: lhs = Counter(6), rhs = Counter(7)
Number of file 0 mappings: 19
- Code(Counter(0)) at (prev + 49, 1) to (start + 1, 16)
- Code(Expression(0, Add)) at (prev + 4, 9) to (start + 0, 10)
= ((c2 + c3) + ((c1 - c2) - c3))
- Code(Counter(1)) at (prev + 4, 9) to (start + 0, 10)
- Code(Counter(1)) at (prev + 0, 14) to (start + 0, 19)
- Branch { true: Counter(2), false: Expression(7, Sub) } at (prev + 0, 14) to (start + 0, 19)
- Branch { true: Counter(2), false: Expression(0, Sub) } at (prev + 0, 14) to (start + 0, 19)
true = c2
false = (c1 - c2)
- Code(Expression(7, Sub)) at (prev + 0, 23) to (start + 0, 29)
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 29)
= (c1 - c2)
- Branch { true: Counter(3), false: Expression(6, Sub) } at (prev + 0, 23) to (start + 0, 29)
- Branch { true: Counter(3), false: Expression(1, Sub) } at (prev + 0, 23) to (start + 0, 29)
true = c3
false = ((c1 - c2) - c3)
- Code(Expression(12, Add)) at (prev + 0, 35) to (start + 0, 40)
false = (c1 - (c2 + c3))
- Code(Expression(7, Add)) at (prev + 0, 35) to (start + 0, 40)
= (c2 + c3)
- Branch { true: Counter(4), false: Expression(11, Sub) } at (prev + 0, 35) to (start + 0, 40)
- Branch { true: Counter(4), false: Expression(6, Sub) } at (prev + 0, 35) to (start + 0, 40)
true = c4
false = ((c2 + c3) - c4)
- Code(Expression(11, Sub)) at (prev + 0, 44) to (start + 0, 51)
- Code(Expression(6, Sub)) at (prev + 0, 44) to (start + 0, 51)
= ((c2 + c3) - c4)
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 17)
= ((c2 + c3) + ((c1 - c2) - c3))
- Code(Expression(20, Add)) at (prev + 3, 9) to (start + 0, 10)
= (c6 + (c7 + c8))
- Code(Expression(0, Add)) at (prev + 0, 14) to (start + 0, 19)
= ((c2 + c3) + ((c1 - c2) - c3))
- Branch { true: Counter(5), false: Expression(19, Sub) } at (prev + 0, 14) to (start + 0, 19)
- Code(Counter(1)) at (prev + 1, 5) to (start + 0, 17)
- Code(Expression(13, Add)) at (prev + 3, 9) to (start + 0, 10)
= ((c6 + c7) + c8)
- Code(Counter(1)) at (prev + 0, 14) to (start + 0, 19)
- Branch { true: Counter(5), false: Expression(10, Sub) } at (prev + 0, 14) to (start + 0, 19)
true = c5
false = (((c2 + c3) + ((c1 - c2) - c3)) - c5)
false = (c1 - c5)
- Code(Counter(5)) at (prev + 0, 23) to (start + 0, 28)
- Branch { true: Counter(6), false: Expression(18, Sub) } at (prev + 0, 23) to (start + 0, 28)
- Branch { true: Counter(6), false: Expression(11, Sub) } at (prev + 0, 23) to (start + 0, 28)
true = c6
false = (c5 - c6)
- Code(Expression(17, Add)) at (prev + 0, 34) to (start + 0, 40)
= ((c5 - c6) + (((c2 + c3) + ((c1 - c2) - c3)) - c5))
- Code(Expression(12, Sub)) at (prev + 0, 34) to (start + 0, 40)
= (c1 - c6)
- Branch { true: Counter(7), false: Counter(8) } at (prev + 0, 34) to (start + 0, 40)
true = c7
false = c8
- Code(Counter(7)) at (prev + 0, 44) to (start + 0, 51)
- Code(Expression(20, Add)) at (prev + 1, 5) to (start + 1, 2)
= (c6 + (c7 + c8))
- Code(Expression(13, Add)) at (prev + 1, 5) to (start + 1, 2)
= ((c6 + c7) + c8)
Highest counter ID seen: c8

76
tests/coverage/branch/match-arms.cov-map
View File

@ -1,12 +1,12 @@
Function name: match_arms::guards
Raw bytes (88): 0x[01, 01, 08, 07, 15, 0b, 11, 0f, 0d, 00, 09, 17, 25, 1b, 21, 1f, 1d, 03, 19, 0c, 01, 30, 01, 01, 10, 29, 03, 0b, 00, 10, 19, 01, 11, 00, 29, 20, 19, 09, 00, 17, 00, 1b, 1d, 01, 11, 00, 29, 20, 1d, 0d, 00, 17, 00, 1b, 21, 01, 11, 00, 29, 20, 21, 11, 00, 17, 00, 1b, 25, 01, 11, 00, 29, 20, 25, 15, 00, 17, 00, 1b, 03, 01, 0e, 00, 18, 13, 03, 05, 01, 02]
Raw bytes (88): 0x[01, 01, 08, 07, 00, 0b, 11, 0f, 0d, 05, 09, 17, 25, 1b, 21, 1f, 1d, 03, 19, 0c, 01, 30, 01, 01, 10, 29, 03, 0b, 00, 10, 19, 01, 11, 00, 29, 20, 19, 05, 00, 17, 00, 1b, 1d, 01, 11, 00, 29, 20, 1d, 09, 00, 17, 00, 1b, 21, 01, 11, 00, 29, 20, 21, 0d, 00, 17, 00, 1b, 25, 01, 11, 00, 29, 20, 25, 11, 00, 17, 00, 1b, 03, 01, 0e, 00, 18, 13, 03, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(5)
- expression 0 operands: lhs = Expression(1, Add), rhs = Zero
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
- expression 3 operands: lhs = Zero, rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(9)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(8)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(7)
@ -15,81 +15,67 @@ Number of file 0 mappings: 12
- Code(Counter(0)) at (prev + 48, 1) to (start + 1, 16)
- Code(Counter(10)) at (prev + 3, 11) to (start + 0, 16)
- Code(Counter(6)) at (prev + 1, 17) to (start + 0, 41)
- Branch { true: Counter(6), false: Counter(2) } at (prev + 0, 23) to (start + 0, 27)
- Branch { true: Counter(6), false: Counter(1) } at (prev + 0, 23) to (start + 0, 27)
true = c6
false = c2
false = c1
- Code(Counter(7)) at (prev + 1, 17) to (start + 0, 41)
- Branch { true: Counter(7), false: Counter(3) } at (prev + 0, 23) to (start + 0, 27)
- Branch { true: Counter(7), false: Counter(2) } at (prev + 0, 23) to (start + 0, 27)
true = c7
false = c3
false = c2
- Code(Counter(8)) at (prev + 1, 17) to (start + 0, 41)
- Branch { true: Counter(8), false: Counter(4) } at (prev + 0, 23) to (start + 0, 27)
- Branch { true: Counter(8), false: Counter(3) } at (prev + 0, 23) to (start + 0, 27)
true = c8
false = c4
false = c3
- Code(Counter(9)) at (prev + 1, 17) to (start + 0, 41)
- Branch { true: Counter(9), false: Counter(5) } at (prev + 0, 23) to (start + 0, 27)
- Branch { true: Counter(9), false: Counter(4) } at (prev + 0, 23) to (start + 0, 27)
true = c9
false = c5
false = c4
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 24)
= ((((Zero + c2) + c3) + c4) + c5)
= ((((c1 + c2) + c3) + c4) + Zero)
- Code(Expression(4, Add)) at (prev + 3, 5) to (start + 1, 2)
= ((((((((Zero + c2) + c3) + c4) + c5) + c6) + c7) + c8) + c9)
= ((((((((c1 + c2) + c3) + c4) + Zero) + c6) + c7) + c8) + c9)
Highest counter ID seen: c10
Function name: match_arms::match_arms
Raw bytes (51): 0x[01, 01, 06, 05, 07, 0b, 11, 09, 0d, 13, 02, 17, 09, 11, 0d, 07, 01, 18, 01, 01, 10, 05, 03, 0b, 00, 10, 11, 01, 11, 00, 21, 0d, 01, 11, 00, 21, 09, 01, 11, 00, 21, 02, 01, 11, 00, 21, 0f, 03, 05, 01, 02]
Raw bytes (45): 0x[01, 01, 03, 05, 07, 0b, 11, 09, 0d, 07, 01, 18, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 21, 0d, 01, 11, 00, 21, 11, 01, 11, 00, 21, 02, 01, 11, 00, 21, 05, 03, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 6
Number of expressions: 3
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Expression(0, Sub)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(2)
- expression 5 operands: lhs = Counter(4), rhs = Counter(3)
Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 24, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 3, 11) to (start + 0, 16)
- Code(Counter(4)) at (prev + 1, 17) to (start + 0, 33)
- Code(Counter(3)) at (prev + 1, 17) to (start + 0, 33)
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 33)
- Code(Counter(3)) at (prev + 1, 17) to (start + 0, 33)
- Code(Counter(4)) at (prev + 1, 17) to (start + 0, 33)
- Code(Expression(0, Sub)) at (prev + 1, 17) to (start + 0, 33)
= (c1 - ((c2 + c3) + c4))
- Code(Expression(3, Add)) at (prev + 3, 5) to (start + 1, 2)
= (((c4 + c3) + c2) + (c1 - ((c2 + c3) + c4)))
- Code(Counter(1)) at (prev + 3, 5) to (start + 1, 2)
Highest counter ID seen: c4
Function name: match_arms::or_patterns
Raw bytes (75): 0x[01, 01, 0d, 11, 0d, 05, 2f, 33, 11, 09, 0d, 09, 2a, 05, 2f, 33, 11, 09, 0d, 03, 27, 09, 2a, 05, 2f, 33, 11, 09, 0d, 09, 01, 25, 01, 01, 10, 05, 03, 0b, 00, 10, 11, 01, 11, 00, 12, 0d, 00, 1e, 00, 1f, 03, 00, 24, 00, 2e, 09, 01, 11, 00, 12, 2a, 00, 1e, 00, 1f, 27, 00, 24, 00, 2e, 23, 03, 05, 01, 02]
Raw bytes (57): 0x[01, 01, 04, 09, 0d, 05, 0b, 03, 11, 05, 03, 09, 01, 25, 01, 01, 10, 05, 03, 0b, 00, 10, 09, 01, 11, 00, 12, 0d, 00, 1e, 00, 1f, 03, 00, 24, 00, 2e, 11, 01, 11, 00, 12, 06, 00, 1e, 00, 1f, 0e, 00, 24, 00, 2e, 05, 03, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 13
- expression 0 operands: lhs = Counter(4), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Expression(11, Add)
- expression 2 operands: lhs = Expression(12, Add), rhs = Counter(4)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Counter(2), rhs = Expression(10, Sub)
- expression 5 operands: lhs = Counter(1), rhs = Expression(11, Add)
- expression 6 operands: lhs = Expression(12, Add), rhs = Counter(4)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 8 operands: lhs = Expression(0, Add), rhs = Expression(9, Add)
- expression 9 operands: lhs = Counter(2), rhs = Expression(10, Sub)
- expression 10 operands: lhs = Counter(1), rhs = Expression(11, Add)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(4)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
Number of expressions: 4
- expression 0 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Expression(2, Add)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 3 operands: lhs = Counter(1), rhs = Expression(0, Add)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 37, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 3, 11) to (start + 0, 16)
- Code(Counter(4)) at (prev + 1, 17) to (start + 0, 18)
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
- Code(Counter(3)) at (prev + 0, 30) to (start + 0, 31)
- Code(Expression(0, Add)) at (prev + 0, 36) to (start + 0, 46)
= (c4 + c3)
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 18)
- Code(Expression(10, Sub)) at (prev + 0, 30) to (start + 0, 31)
= (c2 + c3)
- Code(Counter(4)) at (prev + 1, 17) to (start + 0, 18)
- Code(Expression(1, Sub)) at (prev + 0, 30) to (start + 0, 31)
= (c1 - ((c2 + c3) + c4))
- Code(Expression(9, Add)) at (prev + 0, 36) to (start + 0, 46)
= (c2 + (c1 - ((c2 + c3) + c4)))
- Code(Expression(8, Add)) at (prev + 3, 5) to (start + 1, 2)
= ((c4 + c3) + (c2 + (c1 - ((c2 + c3) + c4))))
- Code(Expression(3, Sub)) at (prev + 0, 36) to (start + 0, 46)
= (c1 - (c2 + c3))
- Code(Counter(1)) at (prev + 3, 5) to (start + 1, 2)
Highest counter ID seen: c4

14
tests/coverage/branch/no-mir-spans.cov-map
View File

@ -23,19 +23,19 @@ Number of file 0 mappings: 2
Highest counter ID seen: c2
Function name: no_mir_spans::while_op_and
Raw bytes (25): 0x[01, 01, 01, 09, 0d, 03, 01, 22, 01, 00, 13, 20, 09, 05, 05, 0b, 00, 10, 20, 02, 0d, 00, 14, 00, 19]
Raw bytes (25): 0x[01, 01, 01, 05, 09, 03, 01, 22, 01, 00, 13, 20, 05, 0d, 05, 0b, 00, 10, 20, 02, 09, 00, 14, 00, 19]
Number of files: 1
- file 0 => global file 1
Number of expressions: 1
- expression 0 operands: lhs = Counter(2), rhs = Counter(3)
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 3
- Code(Counter(0)) at (prev + 34, 1) to (start + 0, 19)
- Branch { true: Counter(2), false: Counter(1) } at (prev + 5, 11) to (start + 0, 16)
true = c2
false = c1
- Branch { true: Expression(0, Sub), false: Counter(3) } at (prev + 0, 20) to (start + 0, 25)
true = (c2 - c3)
- Branch { true: Counter(1), false: Counter(3) } at (prev + 5, 11) to (start + 0, 16)
true = c1
false = c3
- Branch { true: Expression(0, Sub), false: Counter(2) } at (prev + 0, 20) to (start + 0, 25)
true = (c1 - c2)
false = c2
Highest counter ID seen: c3
Function name: no_mir_spans::while_op_or

43
tests/coverage/branch/while.cov-map
View File

@ -35,14 +35,14 @@ Number of file 0 mappings: 6
Highest counter ID seen: c2
Function name: while::while_op_and
Raw bytes (56): 0x[01, 01, 04, 05, 09, 03, 0d, 03, 0d, 11, 0d, 08, 01, 1e, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 0a, 0d, 00, 0b, 00, 10, 0a, 00, 14, 00, 19, 20, 09, 11, 00, 14, 00, 19, 09, 00, 1a, 03, 06, 0f, 04, 01, 00, 02]
Raw bytes (56): 0x[01, 01, 04, 05, 09, 03, 0d, 03, 0d, 0d, 11, 08, 01, 1e, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 0a, 0d, 00, 0b, 00, 10, 0a, 00, 14, 00, 19, 20, 09, 11, 00, 14, 00, 19, 09, 00, 1a, 03, 06, 0f, 04, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(4), rhs = Counter(3)
- expression 3 operands: lhs = Counter(3), rhs = Counter(4)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 30, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 3, 9) to (start + 1, 18)
@ -58,39 +58,34 @@ Number of file 0 mappings: 8
false = c4
- Code(Counter(2)) at (prev + 0, 26) to (start + 3, 6)
- Code(Expression(3, Add)) at (prev + 4, 1) to (start + 0, 2)
= (c4 + c3)
= (c3 + c4)
Highest counter ID seen: c4
Function name: while::while_op_or
Raw bytes (66): 0x[01, 01, 09, 05, 1b, 09, 0d, 03, 09, 03, 09, 22, 0d, 03, 09, 09, 0d, 22, 0d, 03, 09, 08, 01, 29, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 09, 22, 00, 0b, 00, 10, 22, 00, 14, 00, 19, 20, 0d, 1e, 00, 14, 00, 19, 1b, 00, 1a, 03, 06, 1e, 04, 01, 00, 02]
Raw bytes (58): 0x[01, 01, 05, 07, 0d, 05, 09, 05, 0d, 05, 0d, 09, 0d, 08, 01, 29, 01, 01, 10, 05, 03, 09, 01, 12, 03, 02, 0b, 00, 10, 20, 09, 0f, 00, 0b, 00, 10, 0f, 00, 14, 00, 19, 20, 0d, 05, 00, 14, 00, 19, 13, 00, 1a, 03, 06, 05, 04, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 9
- expression 0 operands: lhs = Counter(1), rhs = Expression(6, Add)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(2)
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(8, Sub), rhs = Counter(3)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(2)
- expression 6 operands: lhs = Counter(2), rhs = Counter(3)
- expression 7 operands: lhs = Expression(8, Sub), rhs = Counter(3)
- expression 8 operands: lhs = Expression(0, Add), rhs = Counter(2)
Number of expressions: 5
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(3)
- expression 3 operands: lhs = Counter(1), rhs = Counter(3)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 41, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 3, 9) to (start + 1, 18)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 16)
= (c1 + (c2 + c3))
- Branch { true: Counter(2), false: Expression(8, Sub) } at (prev + 0, 11) to (start + 0, 16)
= ((c1 + c2) + c3)
- Branch { true: Counter(2), false: Expression(3, Add) } at (prev + 0, 11) to (start + 0, 16)
true = c2
false = ((c1 + (c2 + c3)) - c2)
- Code(Expression(8, Sub)) at (prev + 0, 20) to (start + 0, 25)
= ((c1 + (c2 + c3)) - c2)
- Branch { true: Counter(3), false: Expression(7, Sub) } at (prev + 0, 20) to (start + 0, 25)
false = (c1 + c3)
- Code(Expression(3, Add)) at (prev + 0, 20) to (start + 0, 25)
= (c1 + c3)
- Branch { true: Counter(3), false: Counter(1) } at (prev + 0, 20) to (start + 0, 25)
true = c3
false = (((c1 + (c2 + c3)) - c2) - c3)
- Code(Expression(6, Add)) at (prev + 0, 26) to (start + 3, 6)
false = c1
- Code(Expression(4, Add)) at (prev + 0, 26) to (start + 3, 6)
= (c2 + c3)
- Code(Expression(7, Sub)) at (prev + 4, 1) to (start + 0, 2)
= (((c1 + (c2 + c3)) - c2) - c3)
- Code(Counter(1)) at (prev + 4, 1) to (start + 0, 2)
Highest counter ID seen: c3

8
tests/coverage/closure_macro.cov-map
View File

@ -25,13 +25,13 @@ Number of file 0 mappings: 6
Highest counter ID seen: c1
Function name: closure_macro::main::{closure#0}
Raw bytes (35): 0x[01, 01, 03, 01, 05, 05, 0b, 09, 0d, 05, 01, 10, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 0d, 00, 17, 00, 1e, 07, 02, 09, 00, 0a]
Raw bytes (35): 0x[01, 01, 03, 01, 05, 0b, 0d, 05, 09, 05, 01, 10, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 0d, 00, 17, 00, 1e, 07, 02, 09, 00, 0a]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(2, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 16, 28) to (start + 3, 33)
- Code(Counter(1)) at (prev + 4, 17) to (start + 1, 39)
@ -39,6 +39,6 @@ Number of file 0 mappings: 5
= (c0 - c1)
- Code(Counter(3)) at (prev + 0, 23) to (start + 0, 30)
- Code(Expression(1, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c1 + (c2 + c3))
= ((c1 + c2) + c3)
Highest counter ID seen: c3

8
tests/coverage/closure_macro_async.cov-map
View File

@ -34,13 +34,13 @@ Number of file 0 mappings: 6
Highest counter ID seen: c1
Function name: closure_macro_async::test::{closure#0}::{closure#0}
Raw bytes (35): 0x[01, 01, 03, 01, 05, 05, 0b, 09, 0d, 05, 01, 15, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 0d, 00, 17, 00, 1e, 07, 02, 09, 00, 0a]
Raw bytes (35): 0x[01, 01, 03, 01, 05, 0b, 0d, 05, 09, 05, 01, 15, 1c, 03, 21, 05, 04, 11, 01, 27, 02, 03, 11, 00, 16, 0d, 00, 17, 00, 1e, 07, 02, 09, 00, 0a]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(2, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 21, 28) to (start + 3, 33)
- Code(Counter(1)) at (prev + 4, 17) to (start + 1, 39)
@ -48,6 +48,6 @@ Number of file 0 mappings: 5
= (c0 - c1)
- Code(Counter(3)) at (prev + 0, 23) to (start + 0, 30)
- Code(Expression(1, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c1 + (c2 + c3))
= ((c1 + c2) + c3)
Highest counter ID seen: c3

73
tests/coverage/condition/conditions.cov-map
View File

@ -1,29 +1,27 @@
Function name: conditions::assign_3_and_or
Raw bytes (69): 0x[01, 01, 07, 07, 11, 09, 0d, 01, 05, 05, 09, 16, 1a, 05, 09, 01, 05, 09, 01, 1c, 01, 00, 2f, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 1a, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 16, 00, 12, 00, 13, 13, 00, 17, 00, 18, 20, 0d, 11, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Raw bytes (65): 0x[01, 01, 05, 07, 11, 09, 0d, 01, 05, 05, 09, 01, 09, 09, 01, 1c, 01, 00, 2f, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 0a, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 0e, 00, 12, 00, 13, 12, 00, 17, 00, 18, 20, 0d, 11, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 7
Number of expressions: 5
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(4)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Expression(6, Sub)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 28, 1) to (start + 0, 47)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= ((c2 + c3) + c4)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(6, Sub) } at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(2, Sub) } at (prev + 0, 13) to (start + 0, 14)
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
- Branch { true: Counter(2), false: Expression(5, Sub) } at (prev + 0, 18) to (start + 0, 19)
- Branch { true: Counter(2), false: Expression(3, Sub) } at (prev + 0, 18) to (start + 0, 19)
true = c2
false = (c1 - c2)
- Code(Expression(4, Add)) at (prev + 0, 23) to (start + 0, 24)
= ((c1 - c2) + (c0 - c1))
- Code(Expression(4, Sub)) at (prev + 0, 23) to (start + 0, 24)
= (c0 - c2)
- Branch { true: Counter(3), false: Counter(4) } at (prev + 0, 23) to (start + 0, 24)
true = c3
false = c4
@ -32,54 +30,54 @@ Number of file 0 mappings: 9
Highest counter ID seen: c4
Function name: conditions::assign_3_or_and
Raw bytes (73): 0x[01, 01, 09, 05, 07, 0b, 11, 09, 0d, 01, 05, 01, 05, 22, 11, 01, 05, 22, 11, 01, 05, 09, 01, 17, 01, 00, 2f, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 22, 00, 0d, 00, 0e, 22, 00, 12, 00, 13, 20, 1e, 11, 00, 12, 00, 13, 1e, 00, 17, 00, 18, 20, 09, 0d, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Raw bytes (73): 0x[01, 01, 09, 07, 11, 0b, 0d, 05, 09, 01, 05, 01, 05, 01, 23, 05, 11, 01, 23, 05, 11, 09, 01, 17, 01, 00, 2f, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 12, 00, 0d, 00, 0e, 12, 00, 12, 00, 13, 20, 1e, 11, 00, 12, 00, 13, 1e, 00, 17, 00, 18, 20, 09, 0d, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 9
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(4)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Counter(0), rhs = Counter(1)
- expression 5 operands: lhs = Expression(8, Sub), rhs = Counter(4)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 7 operands: lhs = Expression(8, Sub), rhs = Counter(4)
- expression 8 operands: lhs = Counter(0), rhs = Counter(1)
- expression 5 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 6 operands: lhs = Counter(1), rhs = Counter(4)
- expression 7 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 8 operands: lhs = Counter(1), rhs = Counter(4)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 47)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= (c1 + ((c2 + c3) + c4))
= (((c1 + c2) + c3) + c4)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(8, Sub) } at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(4, Sub) } at (prev + 0, 13) to (start + 0, 14)
true = c1
false = (c0 - c1)
- Code(Expression(8, Sub)) at (prev + 0, 18) to (start + 0, 19)
- Code(Expression(4, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c0 - c1)
- Branch { true: Expression(7, Sub), false: Counter(4) } at (prev + 0, 18) to (start + 0, 19)
true = ((c0 - c1) - c4)
true = (c0 - (c1 + c4))
false = c4
- Code(Expression(7, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c0 - c1) - c4)
= (c0 - (c1 + c4))
- Branch { true: Counter(2), false: Counter(3) } at (prev + 0, 23) to (start + 0, 24)
true = c2
false = c3
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
= (c1 + ((c2 + c3) + c4))
= (((c1 + c2) + c3) + c4)
Highest counter ID seen: c4
Function name: conditions::assign_and
Raw bytes (51): 0x[01, 01, 04, 07, 0e, 09, 0d, 01, 05, 01, 05, 07, 01, 0d, 01, 00, 21, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 0e, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 0d, 00, 12, 00, 13, 03, 01, 05, 01, 02]
Raw bytes (51): 0x[01, 01, 04, 07, 05, 0b, 0d, 01, 09, 01, 05, 07, 01, 0d, 01, 00, 21, 02, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 0e, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 0d, 00, 12, 00, 13, 02, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
- expression 0 operands: lhs = Expression(1, Add), rhs = Expression(3, Sub)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 13, 1) to (start + 0, 33)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 10)
= (((c0 + c2) + c3) - c1)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(3, Sub) } at (prev + 0, 13) to (start + 0, 14)
true = c1
@ -88,8 +86,8 @@ Number of file 0 mappings: 7
- Branch { true: Counter(2), false: Counter(3) } at (prev + 0, 18) to (start + 0, 19)
true = c2
false = c3
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 1, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: conditions::assign_or
@ -128,13 +126,14 @@ Number of file 0 mappings: 1
Highest counter ID seen: c0
Function name: conditions::func_call
Raw bytes (39): 0x[01, 01, 03, 01, 05, 0b, 02, 09, 0d, 05, 01, 25, 01, 01, 0a, 20, 05, 02, 01, 09, 00, 0a, 05, 00, 0e, 00, 0f, 20, 09, 0d, 00, 0e, 00, 0f, 07, 01, 01, 00, 02]
Raw bytes (41): 0x[01, 01, 04, 01, 05, 0b, 05, 0f, 0d, 01, 09, 05, 01, 25, 01, 01, 0a, 20, 05, 02, 01, 09, 00, 0a, 05, 00, 0e, 00, 0f, 20, 09, 0d, 00, 0e, 00, 0f, 06, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 37, 1) to (start + 1, 10)
- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 1, 9) to (start + 0, 10)
@ -144,8 +143,8 @@ Number of file 0 mappings: 5
- Branch { true: Counter(2), false: Counter(3) } at (prev + 0, 14) to (start + 0, 15)
true = c2
false = c3
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(1, Sub)) at (prev + 1, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: conditions::simple_assign

508
tests/coverage/conditions.cov-map
View File

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

18
tests/coverage/continue.cov-map
View File

@ -1,5 +1,5 @@
Function name: continue::main
Raw bytes (210): 0x[01, 01, 1c, 07, 09, 01, 05, 03, 0d, 1f, 15, 0d, 11, 1b, 19, 1f, 15, 0d, 11, 33, 21, 19, 1d, 2f, 25, 33, 21, 19, 1d, 47, 2d, 25, 29, 43, 31, 47, 2d, 25, 29, 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]
Raw bytes (210): 0x[01, 01, 1c, 07, 09, 01, 05, 03, 0d, 1f, 15, 0d, 11, 1b, 19, 1f, 15, 0d, 11, 33, 21, 19, 1d, 2f, 25, 33, 21, 19, 1d, 47, 2d, 25, 29, 43, 31, 47, 2d, 25, 29, 5b, 39, 31, 35, 57, 3d, 5b, 39, 31, 35, 35, 39, 3d, 41, 6b, 45, 3d, 41, 45, 49, 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: 28
@ -21,16 +21,16 @@ Number of expressions: 28
- expression 15 operands: lhs = Expression(16, Add), rhs = Counter(12)
- expression 16 operands: lhs = Expression(17, Add), rhs = Counter(11)
- expression 17 operands: lhs = Counter(9), rhs = Counter(10)
- expression 18 operands: lhs = Counter(12), rhs = Expression(23, Add)
- expression 19 operands: lhs = Counter(13), rhs = Counter(14)
- expression 18 operands: lhs = Expression(22, Add), rhs = Counter(14)
- expression 19 operands: lhs = Counter(12), rhs = Counter(13)
- 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 21 operands: lhs = Expression(22, Add), rhs = Counter(14)
- expression 22 operands: lhs = Counter(12), rhs = Counter(13)
- 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 = Counter(18), rhs = Counter(17)
- expression 27 operands: lhs = Counter(17), rhs = Counter(18)
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)
@ -60,9 +60,9 @@ Number of file 0 mappings: 30
- Code(Counter(10)) at (prev + 1, 13) to (start + 0, 21)
- Code(Counter(11)) at (prev + 1, 10) to (start + 1, 14)
- Code(Expression(21, Add)) at (prev + 3, 14) to (start + 0, 19)
= (c12 + (c13 + c14))
= ((c12 + c13) + c14)
- Code(Expression(20, Sub)) at (prev + 1, 15) to (start + 0, 22)
= ((c12 + (c13 + c14)) - c15)
= (((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(23, Add)) at (prev + 4, 9) to (start + 0, 14)
@ -75,6 +75,6 @@ Number of file 0 mappings: 30
- Code(Counter(18)) at (prev + 4, 17) to (start + 0, 22)
- 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)
= (c17 + c18)
Highest counter ID seen: c18

18
tests/coverage/coroutine.cov-map
View File

@ -13,18 +13,18 @@ Number of file 0 mappings: 4
Highest counter ID seen: c1
Function name: coroutine::main
Raw bytes (65): 0x[01, 01, 08, 07, 0d, 05, 09, 11, 15, 1e, 19, 11, 15, 15, 19, 1e, 19, 11, 15, 09, 01, 13, 01, 02, 16, 01, 08, 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]
Raw bytes (65): 0x[01, 01, 08, 07, 0d, 05, 09, 11, 15, 11, 1f, 15, 19, 15, 19, 11, 1f, 15, 19, 09, 01, 13, 01, 02, 16, 01, 08, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 03, 01, 0e, 00, 35, 11, 02, 0b, 00, 2e, 0a, 01, 22, 00, 27, 1a, 00, 2c, 00, 2e, 1f, 01, 0e, 00, 35, 1a, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- 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 3 operands: lhs = Counter(4), rhs = Expression(7, Add)
- expression 4 operands: lhs = Counter(5), rhs = Counter(6)
- 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)
- expression 6 operands: lhs = Counter(4), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(5), rhs = Counter(6)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 19, 1) to (start + 2, 22)
- Code(Counter(0)) at (prev + 8, 11) to (start + 0, 46)
@ -32,14 +32,14 @@ Number of file 0 mappings: 9
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 53)
= ((c1 + c2) + c3)
- Code(Counter(4)) at (prev + 2, 11) to (start + 0, 46)
- Code(Expression(7, Sub)) at (prev + 1, 34) to (start + 0, 39)
- Code(Expression(2, Sub)) at (prev + 1, 34) to (start + 0, 39)
= (c4 - c5)
- Code(Expression(6, Sub)) at (prev + 0, 44) to (start + 0, 46)
= ((c4 - c5) - c6)
- Code(Expression(5, Add)) at (prev + 1, 14) to (start + 0, 53)
= (c4 - (c5 + c6))
- Code(Expression(7, Add)) at (prev + 1, 14) to (start + 0, 53)
= (c5 + c6)
- Code(Expression(6, Sub)) at (prev + 2, 1) to (start + 0, 2)
= ((c4 - c5) - c6)
= (c4 - (c5 + c6))
Highest counter ID seen: c4
Function name: coroutine::main::{closure#0}

8
tests/coverage/inline-dead.cov-map
View File

@ -32,16 +32,16 @@ Number of file 0 mappings: 2
Highest counter ID seen: c0
Function name: inline_dead::main::{closure#0}
Raw bytes (23): 0x[01, 01, 02, 00, 06, 01, 00, 03, 01, 07, 17, 01, 16, 00, 01, 17, 00, 18, 03, 01, 05, 00, 06]
Raw bytes (23): 0x[01, 01, 02, 07, 00, 01, 00, 03, 01, 07, 17, 01, 16, 00, 01, 17, 00, 18, 02, 01, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Zero, rhs = Expression(1, Sub)
- expression 0 operands: lhs = Expression(1, Add), rhs = Zero
- expression 1 operands: lhs = Counter(0), rhs = Zero
Number of file 0 mappings: 3
- Code(Counter(0)) at (prev + 7, 23) to (start + 1, 22)
- Code(Zero) at (prev + 1, 23) to (start + 0, 24)
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 6)
= (Zero + (c0 - Zero))
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 6)
= ((c0 + Zero) - Zero)
Highest counter ID seen: c0

17
tests/coverage/inline.cov-map
View File

@ -41,14 +41,15 @@ Number of file 0 mappings: 1
Highest counter ID seen: c0
Function name: inline::permutate::<char>
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]
Raw bytes (54): 0x[01, 01, 05, 01, 05, 01, 0b, 05, 0d, 13, 0d, 05, 09, 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, 0f, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 5
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
- expression 2 operands: lhs = Counter(1), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(3)
- expression 4 operands: lhs = Counter(1), rhs = Counter(2)
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)
@ -56,11 +57,11 @@ Number of file 0 mappings: 8
= (c0 - c1)
- 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)
= (c0 - (c1 + c3))
- Code(Counter(4)) at (prev + 0, 23) to (start + 4, 10)
- Code(Counter(3)) at (prev + 5, 12) to (start + 2, 6)
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c1 + (c2 + c3))
- Code(Expression(3, Add)) at (prev + 3, 1) to (start + 0, 2)
= ((c1 + c2) + c3)
Highest counter ID seen: c4
Function name: inline::permutations::<char>

192
tests/coverage/issue-84561.cov-map
View File

@ -59,69 +59,69 @@ Number of file 0 mappings: 1
Highest counter ID seen: c0
Function name: issue_84561::test3
Raw bytes (414): 0x[01, 01, 3b, 05, 09, 0d, 11, 15, 19, 1e, 1d, 15, 19, 1a, 21, 1e, 1d, 15, 19, 25, 2d, 21, 25, 29, 35, 32, 29, 21, 25, 31, 39, 3d, 41, 42, 45, 3d, 41, 66, 49, 45, 4d, 63, 51, 66, 49, 45, 4d, 5e, 55, 63, 51, 66, 49, 45, 4d, 9e, 01, 55, 51, 59, 9e, 01, 55, 51, 59, 9b, 01, 5d, 9e, 01, 55, 51, 59, 9b, 01, 61, 9e, 01, 55, 51, 59, 96, 01, 65, 9b, 01, 61, 9e, 01, 55, 51, 59, 75, e2, 01, e6, 01, 79, 69, 6d, 69, 6d, 69, 6d, e6, 01, 00, 69, 6d, e6, 01, 79, 69, 6d, df, 01, 7d, 75, e2, 01, e6, 01, 79, 69, 6d, da, 01, 81, 01, df, 01, 7d, 75, e2, 01, e6, 01, 79, 69, 6d, 81, 01, 85, 01, 33, 01, 08, 01, 03, 1c, 05, 04, 09, 01, 1c, 02, 02, 05, 04, 1f, 0d, 05, 05, 00, 1f, 06, 01, 05, 00, 1f, 15, 01, 09, 01, 1c, 1e, 02, 05, 00, 1f, 1a, 01, 05, 00, 0f, 16, 00, 20, 00, 30, 21, 01, 05, 03, 0f, 25, 03, 20, 00, 30, 2d, 00, 33, 00, 41, 22, 00, 4b, 00, 5a, 32, 01, 05, 00, 0f, 29, 05, 09, 03, 10, 35, 05, 0d, 00, 1b, 2a, 02, 0d, 00, 1c, 2e, 04, 09, 05, 06, 31, 06, 05, 03, 06, 36, 04, 05, 03, 06, 3d, 04, 09, 04, 06, 42, 05, 08, 00, 0f, 45, 01, 09, 03, 0a, 3e, 05, 09, 03, 0a, 63, 05, 08, 00, 0f, 51, 01, 09, 00, 13, 59, 03, 0d, 00, 1d, 5e, 03, 09, 00, 13, 5a, 03, 0d, 00, 1d, 9b, 01, 03, 05, 00, 0f, 9b, 01, 01, 0c, 00, 13, 5d, 01, 0d, 00, 13, 7a, 02, 0d, 00, 13, 96, 01, 04, 05, 02, 13, 65, 03, 0d, 00, 13, 92, 01, 02, 0d, 00, 13, df, 01, 03, 05, 00, 0f, 69, 01, 0c, 00, 13, 6d, 01, 0d, 03, 0e, 75, 04, 0d, 00, 13, e6, 01, 02, 0d, 00, 17, e6, 01, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, b6, 01, 02, 15, 00, 1b, e2, 01, 04, 0d, 00, 13, 7d, 03, 09, 00, 19, da, 01, 02, 05, 00, 0f, d6, 01, 03, 09, 00, 22, 81, 01, 02, 05, 00, 0f, ea, 01, 03, 09, 00, 2c, 85, 01, 02, 01, 00, 02]
Raw bytes (409): 0x[01, 01, 3b, 05, 09, 0d, 11, 15, 19, 15, 1f, 19, 1d, 15, 1b, 1f, 21, 19, 1d, 25, 29, 21, 25, 2d, 31, 21, 33, 25, 2d, 35, 39, 3d, 41, 3d, 43, 41, 45, 5f, 4d, 45, 49, 5f, 67, 45, 49, 4d, 51, 5f, 63, 45, 49, 67, 59, 4d, 51, 97, 01, 55, 51, 59, 97, 01, 55, 51, 59, 97, 01, 83, 01, 51, 59, 55, 5d, 97, 01, 9f, 01, 51, 59, 55, 61, 97, 01, 9b, 01, 51, 59, 9f, 01, 65, 55, 61, db, 01, e7, 01, 69, 71, 6d, 75, 69, 6d, 69, 6d, 69, bb, 01, 6d, 00, 69, e7, 01, 6d, 75, db, 01, e3, 01, 69, 71, e7, 01, 79, 6d, 75, db, 01, df, 01, 69, 71, e3, 01, 7d, e7, 01, 79, 6d, 75, 7d, 81, 01, 33, 01, 08, 01, 03, 1c, 05, 04, 09, 01, 1c, 02, 02, 05, 04, 1f, 0d, 05, 05, 00, 1f, 06, 01, 05, 00, 1f, 15, 01, 09, 01, 1c, 0a, 02, 05, 00, 1f, 0e, 01, 05, 00, 0f, 16, 00, 20, 00, 30, 21, 01, 05, 03, 0f, 25, 03, 20, 00, 30, 29, 00, 33, 00, 41, 22, 00, 4b, 00, 5a, 26, 01, 05, 00, 0f, 2d, 05, 09, 03, 10, 31, 05, 0d, 00, 1b, 2a, 02, 0d, 00, 1c, 2e, 04, 09, 05, 06, 35, 06, 05, 03, 06, 36, 04, 05, 03, 06, 3d, 04, 09, 04, 06, 3a, 05, 08, 00, 0f, 45, 01, 09, 03, 0a, 3e, 05, 09, 03, 0a, 46, 05, 08, 00, 0f, 51, 01, 09, 00, 13, 55, 03, 0d, 00, 1d, 4e, 03, 09, 00, 13, 5a, 03, 0d, 00, 1d, 72, 03, 05, 00, 0f, 72, 01, 0c, 00, 13, 5d, 01, 0d, 00, 13, 7a, 02, 0d, 00, 13, 86, 01, 04, 05, 02, 13, 65, 03, 0d, 00, 13, 92, 01, 02, 0d, 00, 13, a2, 01, 03, 05, 00, 0f, 69, 01, 0c, 00, 13, 6d, 01, 0d, 03, 0e, 71, 04, 0d, 00, 13, b2, 01, 02, 0d, 00, 17, b2, 01, 01, 14, 00, 1b, 00, 01, 15, 00, 1b, b6, 01, 02, 15, 00, 1b, be, 01, 04, 0d, 00, 13, 79, 03, 09, 00, 19, c6, 01, 02, 05, 00, 0f, d6, 01, 03, 09, 00, 22, 7d, 02, 05, 00, 0f, ea, 01, 03, 09, 00, 2c, 81, 01, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 59
- expression 0 operands: lhs = Counter(1), rhs = Counter(2)
- expression 1 operands: lhs = Counter(3), rhs = Counter(4)
- expression 2 operands: lhs = Counter(5), rhs = Counter(6)
- expression 3 operands: lhs = Expression(7, Sub), rhs = Counter(7)
- expression 4 operands: lhs = Counter(5), rhs = Counter(6)
- expression 5 operands: lhs = Expression(6, Sub), rhs = Counter(8)
- expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(7)
- expression 7 operands: lhs = Counter(5), rhs = Counter(6)
- expression 8 operands: lhs = Counter(9), rhs = Counter(11)
- expression 3 operands: lhs = Counter(5), rhs = Expression(7, Add)
- expression 4 operands: lhs = Counter(6), rhs = Counter(7)
- expression 5 operands: lhs = Counter(5), rhs = Expression(6, Add)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(8)
- expression 7 operands: lhs = Counter(6), rhs = Counter(7)
- expression 8 operands: lhs = Counter(9), rhs = Counter(10)
- expression 9 operands: lhs = Counter(8), rhs = Counter(9)
- expression 10 operands: lhs = Counter(10), rhs = Counter(13)
- expression 11 operands: lhs = Expression(12, Sub), rhs = Counter(10)
- expression 12 operands: lhs = Counter(8), rhs = Counter(9)
- expression 13 operands: lhs = Counter(12), rhs = Counter(14)
- expression 10 operands: lhs = Counter(11), rhs = Counter(12)
- expression 11 operands: lhs = Counter(8), rhs = Expression(12, Add)
- expression 12 operands: lhs = Counter(9), rhs = Counter(11)
- expression 13 operands: lhs = Counter(13), rhs = Counter(14)
- expression 14 operands: lhs = Counter(15), rhs = Counter(16)
- expression 15 operands: lhs = Expression(16, Sub), rhs = Counter(17)
- expression 16 operands: lhs = Counter(15), rhs = Counter(16)
- expression 17 operands: lhs = Expression(25, Sub), rhs = Counter(18)
- expression 18 operands: lhs = Counter(17), rhs = Counter(19)
- expression 19 operands: lhs = Expression(24, Add), rhs = Counter(20)
- expression 20 operands: lhs = Expression(25, Sub), rhs = Counter(18)
- expression 21 operands: lhs = Counter(17), rhs = Counter(19)
- expression 22 operands: lhs = Expression(23, Sub), rhs = Counter(21)
- expression 23 operands: lhs = Expression(24, Add), rhs = Counter(20)
- expression 24 operands: lhs = Expression(25, Sub), rhs = Counter(18)
- expression 25 operands: lhs = Counter(17), rhs = Counter(19)
- expression 26 operands: lhs = Expression(39, Sub), rhs = Counter(21)
- expression 15 operands: lhs = Counter(15), rhs = Expression(16, Add)
- expression 16 operands: lhs = Counter(16), rhs = Counter(17)
- expression 17 operands: lhs = Expression(23, Add), rhs = Counter(19)
- expression 18 operands: lhs = Counter(17), rhs = Counter(18)
- expression 19 operands: lhs = Expression(23, Add), rhs = Expression(25, Add)
- expression 20 operands: lhs = Counter(17), rhs = Counter(18)
- expression 21 operands: lhs = Counter(19), rhs = Counter(20)
- expression 22 operands: lhs = Expression(23, Add), rhs = Expression(24, Add)
- expression 23 operands: lhs = Counter(17), rhs = Counter(18)
- expression 24 operands: lhs = Expression(25, Add), rhs = Counter(22)
- expression 25 operands: lhs = Counter(19), rhs = Counter(20)
- expression 26 operands: lhs = Expression(37, Add), rhs = Counter(21)
- expression 27 operands: lhs = Counter(20), rhs = Counter(22)
- expression 28 operands: lhs = Expression(39, Sub), rhs = Counter(21)
- expression 28 operands: lhs = Expression(37, Add), rhs = Counter(21)
- expression 29 operands: lhs = Counter(20), rhs = Counter(22)
- expression 30 operands: lhs = Expression(38, Add), rhs = Counter(23)
- expression 31 operands: lhs = Expression(39, Sub), rhs = Counter(21)
- expression 32 operands: lhs = Counter(20), rhs = Counter(22)
- expression 33 operands: lhs = Expression(38, Add), rhs = Counter(24)
- expression 34 operands: lhs = Expression(39, Sub), rhs = Counter(21)
- expression 35 operands: lhs = Counter(20), rhs = Counter(22)
- expression 36 operands: lhs = Expression(37, Sub), rhs = Counter(25)
- expression 37 operands: lhs = Expression(38, Add), rhs = Counter(24)
- expression 38 operands: lhs = Expression(39, Sub), rhs = Counter(21)
- expression 39 operands: lhs = Counter(20), rhs = Counter(22)
- expression 40 operands: lhs = Counter(29), rhs = Expression(56, Sub)
- expression 41 operands: lhs = Expression(57, Sub), rhs = Counter(30)
- expression 42 operands: lhs = Counter(26), rhs = Counter(27)
- expression 30 operands: lhs = Expression(37, Add), rhs = Expression(32, Add)
- expression 31 operands: lhs = Counter(20), rhs = Counter(22)
- expression 32 operands: lhs = Counter(21), rhs = Counter(23)
- expression 33 operands: lhs = Expression(37, Add), rhs = Expression(39, Add)
- expression 34 operands: lhs = Counter(20), rhs = Counter(22)
- expression 35 operands: lhs = Counter(21), rhs = Counter(24)
- expression 36 operands: lhs = Expression(37, Add), rhs = Expression(38, Add)
- expression 37 operands: lhs = Counter(20), rhs = Counter(22)
- expression 38 operands: lhs = Expression(39, Add), rhs = Counter(25)
- expression 39 operands: lhs = Counter(21), rhs = Counter(24)
- expression 40 operands: lhs = Expression(54, Add), rhs = Expression(57, Add)
- expression 41 operands: lhs = Counter(26), rhs = Counter(28)
- expression 42 operands: lhs = Counter(27), rhs = Counter(29)
- expression 43 operands: lhs = Counter(26), rhs = Counter(27)
- expression 44 operands: lhs = Counter(26), rhs = Counter(27)
- expression 45 operands: lhs = Expression(57, Sub), rhs = Zero
- expression 46 operands: lhs = Counter(26), rhs = Counter(27)
- expression 47 operands: lhs = Expression(57, Sub), rhs = Counter(30)
- expression 48 operands: lhs = Counter(26), rhs = Counter(27)
- expression 49 operands: lhs = Expression(55, Add), rhs = Counter(31)
- expression 50 operands: lhs = Counter(29), rhs = Expression(56, Sub)
- expression 51 operands: lhs = Expression(57, Sub), rhs = Counter(30)
- expression 52 operands: lhs = Counter(26), rhs = Counter(27)
- expression 53 operands: lhs = Expression(54, Sub), rhs = Counter(32)
- expression 54 operands: lhs = Expression(55, Add), rhs = Counter(31)
- expression 55 operands: lhs = Counter(29), rhs = Expression(56, Sub)
- expression 56 operands: lhs = Expression(57, Sub), rhs = Counter(30)
- expression 57 operands: lhs = Counter(26), rhs = Counter(27)
- expression 58 operands: lhs = Counter(32), rhs = Counter(33)
- expression 45 operands: lhs = Counter(26), rhs = Expression(46, Add)
- expression 46 operands: lhs = Counter(27), rhs = Zero
- expression 47 operands: lhs = Counter(26), rhs = Expression(57, Add)
- expression 48 operands: lhs = Counter(27), rhs = Counter(29)
- expression 49 operands: lhs = Expression(54, Add), rhs = Expression(56, Add)
- expression 50 operands: lhs = Counter(26), rhs = Counter(28)
- expression 51 operands: lhs = Expression(57, Add), rhs = Counter(30)
- expression 52 operands: lhs = Counter(27), rhs = Counter(29)
- expression 53 operands: lhs = Expression(54, Add), rhs = Expression(55, Add)
- expression 54 operands: lhs = Counter(26), rhs = Counter(28)
- expression 55 operands: lhs = Expression(56, Add), rhs = Counter(31)
- expression 56 operands: lhs = Expression(57, Add), rhs = Counter(30)
- expression 57 operands: lhs = Counter(27), rhs = Counter(29)
- expression 58 operands: lhs = Counter(31), rhs = Counter(32)
Number of file 0 mappings: 51
- Code(Counter(0)) at (prev + 8, 1) to (start + 3, 28)
- Code(Counter(1)) at (prev + 4, 9) to (start + 1, 28)
@ -131,76 +131,76 @@ Number of file 0 mappings: 51
- Code(Expression(1, Sub)) at (prev + 1, 5) to (start + 0, 31)
= (c3 - c4)
- Code(Counter(5)) at (prev + 1, 9) to (start + 1, 28)
- Code(Expression(7, Sub)) at (prev + 2, 5) to (start + 0, 31)
- Code(Expression(2, Sub)) at (prev + 2, 5) to (start + 0, 31)
= (c5 - c6)
- Code(Expression(6, Sub)) at (prev + 1, 5) to (start + 0, 15)
= ((c5 - c6) - c7)
- Code(Expression(3, Sub)) at (prev + 1, 5) to (start + 0, 15)
= (c5 - (c6 + c7))
- Code(Expression(5, Sub)) at (prev + 0, 32) to (start + 0, 48)
= (((c5 - c6) - c7) - c8)
= (c5 - ((c6 + c7) + c8))
- Code(Counter(8)) at (prev + 1, 5) to (start + 3, 15)
- Code(Counter(9)) at (prev + 3, 32) to (start + 0, 48)
- Code(Counter(11)) at (prev + 0, 51) to (start + 0, 65)
- Code(Counter(10)) at (prev + 0, 51) to (start + 0, 65)
- Code(Expression(8, Sub)) at (prev + 0, 75) to (start + 0, 90)
= (c9 - c11)
- Code(Expression(12, Sub)) at (prev + 1, 5) to (start + 0, 15)
= (c9 - c10)
- Code(Expression(9, Sub)) at (prev + 1, 5) to (start + 0, 15)
= (c8 - c9)
- Code(Counter(10)) at (prev + 5, 9) to (start + 3, 16)
- Code(Counter(13)) at (prev + 5, 13) to (start + 0, 27)
- Code(Counter(11)) at (prev + 5, 9) to (start + 3, 16)
- Code(Counter(12)) at (prev + 5, 13) to (start + 0, 27)
- Code(Expression(10, Sub)) at (prev + 2, 13) to (start + 0, 28)
= (c10 - c13)
= (c11 - c12)
- Code(Expression(11, Sub)) at (prev + 4, 9) to (start + 5, 6)
= ((c8 - c9) - c10)
- Code(Counter(12)) at (prev + 6, 5) to (start + 3, 6)
= (c8 - (c9 + c11))
- Code(Counter(13)) at (prev + 6, 5) to (start + 3, 6)
- Code(Expression(13, Sub)) at (prev + 4, 5) to (start + 3, 6)
= (c12 - c14)
= (c13 - c14)
- Code(Counter(15)) at (prev + 4, 9) to (start + 4, 6)
- Code(Expression(16, Sub)) at (prev + 5, 8) to (start + 0, 15)
- Code(Expression(14, Sub)) at (prev + 5, 8) to (start + 0, 15)
= (c15 - c16)
- Code(Counter(17)) at (prev + 1, 9) to (start + 3, 10)
- Code(Expression(15, Sub)) at (prev + 5, 9) to (start + 3, 10)
= ((c15 - c16) - c17)
- Code(Expression(24, Add)) at (prev + 5, 8) to (start + 0, 15)
= ((c17 - c19) + c18)
= (c15 - (c16 + c17))
- Code(Expression(17, Sub)) at (prev + 5, 8) to (start + 0, 15)
= ((c17 + c18) - c19)
- Code(Counter(20)) at (prev + 1, 9) to (start + 0, 19)
- Code(Counter(22)) at (prev + 3, 13) to (start + 0, 29)
- Code(Expression(23, Sub)) at (prev + 3, 9) to (start + 0, 19)
= (((c17 - c19) + c18) - c20)
- Code(Counter(21)) at (prev + 3, 13) to (start + 0, 29)
- Code(Expression(19, Sub)) at (prev + 3, 9) to (start + 0, 19)
= ((c17 + c18) - (c19 + c20))
- Code(Expression(22, Sub)) at (prev + 3, 13) to (start + 0, 29)
= ((((c17 - c19) + c18) - c20) - c21)
- Code(Expression(38, Add)) at (prev + 3, 5) to (start + 0, 15)
= ((c20 - c22) + c21)
- Code(Expression(38, Add)) at (prev + 1, 12) to (start + 0, 19)
= ((c20 - c22) + c21)
= ((c17 + c18) - ((c19 + c20) + c22))
- Code(Expression(28, Sub)) at (prev + 3, 5) to (start + 0, 15)
= ((c20 + c22) - c21)
- Code(Expression(28, Sub)) at (prev + 1, 12) to (start + 0, 19)
= ((c20 + c22) - c21)
- Code(Counter(23)) at (prev + 1, 13) to (start + 0, 19)
- Code(Expression(30, Sub)) at (prev + 2, 13) to (start + 0, 19)
= (((c20 - c22) + c21) - c23)
- Code(Expression(37, Sub)) at (prev + 4, 5) to (start + 2, 19)
= (((c20 - c22) + c21) - c24)
= ((c20 + c22) - (c21 + c23))
- Code(Expression(33, Sub)) at (prev + 4, 5) to (start + 2, 19)
= ((c20 + c22) - (c21 + c24))
- Code(Counter(25)) at (prev + 3, 13) to (start + 0, 19)
- Code(Expression(36, Sub)) at (prev + 2, 13) to (start + 0, 19)
= ((((c20 - c22) + c21) - c24) - c25)
- Code(Expression(55, Add)) at (prev + 3, 5) to (start + 0, 15)
= (c29 + ((c26 - c27) - c30))
= ((c20 + c22) - ((c21 + c24) + c25))
- Code(Expression(40, Sub)) at (prev + 3, 5) to (start + 0, 15)
= ((c26 + c28) - (c27 + c29))
- Code(Counter(26)) at (prev + 1, 12) to (start + 0, 19)
- Code(Counter(27)) at (prev + 1, 13) to (start + 3, 14)
- Code(Counter(29)) at (prev + 4, 13) to (start + 0, 19)
- Code(Expression(57, Sub)) at (prev + 2, 13) to (start + 0, 23)
- Code(Counter(28)) at (prev + 4, 13) to (start + 0, 19)
- Code(Expression(44, Sub)) at (prev + 2, 13) to (start + 0, 23)
= (c26 - c27)
- Code(Expression(57, Sub)) at (prev + 1, 20) to (start + 0, 27)
- Code(Expression(44, Sub)) at (prev + 1, 20) to (start + 0, 27)
= (c26 - c27)
- Code(Zero) at (prev + 1, 21) to (start + 0, 27)
- Code(Expression(45, Sub)) at (prev + 2, 21) to (start + 0, 27)
= ((c26 - c27) - Zero)
- Code(Expression(56, Sub)) at (prev + 4, 13) to (start + 0, 19)
= ((c26 - c27) - c30)
- Code(Counter(31)) at (prev + 3, 9) to (start + 0, 25)
- Code(Expression(54, Sub)) at (prev + 2, 5) to (start + 0, 15)
= ((c29 + ((c26 - c27) - c30)) - c31)
= (c26 - (c27 + Zero))
- Code(Expression(47, Sub)) at (prev + 4, 13) to (start + 0, 19)
= (c26 - (c27 + c29))
- Code(Counter(30)) at (prev + 3, 9) to (start + 0, 25)
- Code(Expression(49, Sub)) at (prev + 2, 5) to (start + 0, 15)
= ((c26 + c28) - ((c27 + c29) + c30))
- Code(Expression(53, Sub)) at (prev + 3, 9) to (start + 0, 34)
= (((c29 + ((c26 - c27) - c30)) - c31) - c32)
- Code(Counter(32)) at (prev + 2, 5) to (start + 0, 15)
= ((c26 + c28) - (((c27 + c29) + c30) + c31))
- Code(Counter(31)) at (prev + 2, 5) to (start + 0, 15)
- Code(Expression(58, Sub)) at (prev + 3, 9) to (start + 0, 44)
= (c32 - c33)
- Code(Counter(33)) at (prev + 2, 1) to (start + 0, 2)
Highest counter ID seen: c33
= (c31 - c32)
- Code(Counter(32)) at (prev + 2, 1) to (start + 0, 2)
Highest counter ID seen: c32

40
tests/coverage/lazy_boolean.cov-map
View File

@ -1,15 +1,15 @@
Function name: lazy_boolean::main
Raw bytes (158): 0x[01, 01, 07, 01, 05, 01, 09, 01, 0d, 01, 19, 01, 1d, 01, 21, 01, 25, 1c, 01, 04, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 05, 00, 06, 01, 02, 09, 00, 11, 01, 02, 0d, 00, 12, 06, 02, 0d, 00, 12, 01, 03, 09, 00, 11, 01, 02, 0d, 00, 12, 0a, 02, 0d, 00, 12, 01, 02, 09, 00, 11, 01, 00, 14, 00, 19, 11, 00, 1d, 00, 22, 01, 01, 09, 00, 11, 01, 00, 14, 00, 19, 15, 00, 1d, 00, 22, 01, 03, 09, 01, 10, 0e, 02, 05, 03, 06, 19, 03, 05, 00, 06, 01, 03, 09, 00, 10, 1d, 01, 05, 03, 06, 12, 05, 05, 03, 06, 01, 05, 08, 00, 10, 16, 00, 11, 02, 06, 21, 02, 05, 00, 06, 01, 02, 08, 00, 0f, 25, 00, 10, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
Raw bytes (158): 0x[01, 01, 07, 01, 05, 01, 25, 01, 21, 01, 11, 01, 15, 01, 19, 01, 1d, 1c, 01, 04, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 05, 00, 06, 01, 02, 09, 00, 11, 01, 02, 0d, 00, 12, 06, 02, 0d, 00, 12, 01, 03, 09, 00, 11, 01, 02, 0d, 00, 12, 0a, 02, 0d, 00, 12, 01, 02, 09, 00, 11, 01, 00, 14, 00, 19, 09, 00, 1d, 00, 22, 01, 01, 09, 00, 11, 01, 00, 14, 00, 19, 0d, 00, 1d, 00, 22, 01, 03, 09, 01, 10, 0e, 02, 05, 03, 06, 11, 03, 05, 00, 06, 01, 03, 09, 00, 10, 15, 01, 05, 03, 06, 12, 05, 05, 03, 06, 01, 05, 08, 00, 10, 16, 00, 11, 02, 06, 19, 02, 05, 00, 06, 01, 02, 08, 00, 0f, 1d, 00, 10, 02, 06, 1a, 02, 0c, 02, 06, 01, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 7
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Counter(2)
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
- expression 3 operands: lhs = Counter(0), rhs = Counter(6)
- expression 4 operands: lhs = Counter(0), rhs = Counter(7)
- expression 5 operands: lhs = Counter(0), rhs = Counter(8)
- expression 6 operands: lhs = Counter(0), rhs = Counter(9)
- expression 1 operands: lhs = Counter(0), rhs = Counter(9)
- expression 2 operands: lhs = Counter(0), rhs = Counter(8)
- expression 3 operands: lhs = Counter(0), rhs = Counter(4)
- expression 4 operands: lhs = Counter(0), rhs = Counter(5)
- expression 5 operands: lhs = Counter(0), rhs = Counter(6)
- expression 6 operands: lhs = Counter(0), rhs = Counter(7)
Number of file 0 mappings: 28
- Code(Counter(0)) at (prev + 4, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 4, 6)
@ -18,33 +18,33 @@ Number of file 0 mappings: 28
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 17)
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 18)
- Code(Expression(1, Sub)) at (prev + 2, 13) to (start + 0, 18)
= (c0 - c2)
= (c0 - c9)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 17)
- Code(Counter(0)) at (prev + 2, 13) to (start + 0, 18)
- Code(Expression(2, Sub)) at (prev + 2, 13) to (start + 0, 18)
= (c0 - c3)
= (c0 - c8)
- Code(Counter(0)) at (prev + 2, 9) to (start + 0, 17)
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 25)
- Code(Counter(4)) at (prev + 0, 29) to (start + 0, 34)
- Code(Counter(2)) at (prev + 0, 29) to (start + 0, 34)
- Code(Counter(0)) at (prev + 1, 9) to (start + 0, 17)
- Code(Counter(0)) at (prev + 0, 20) to (start + 0, 25)
- Code(Counter(5)) at (prev + 0, 29) to (start + 0, 34)
- Code(Counter(3)) at (prev + 0, 29) to (start + 0, 34)
- Code(Counter(0)) at (prev + 3, 9) to (start + 1, 16)
- Code(Expression(3, Sub)) at (prev + 2, 5) to (start + 3, 6)
= (c0 - c6)
- Code(Counter(6)) at (prev + 3, 5) to (start + 0, 6)
= (c0 - c4)
- Code(Counter(4)) at (prev + 3, 5) to (start + 0, 6)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 16)
- Code(Counter(7)) at (prev + 1, 5) to (start + 3, 6)
- Code(Counter(5)) at (prev + 1, 5) to (start + 3, 6)
- Code(Expression(4, Sub)) at (prev + 5, 5) to (start + 3, 6)
= (c0 - c7)
= (c0 - c5)
- Code(Counter(0)) at (prev + 5, 8) to (start + 0, 16)
- Code(Expression(5, Sub)) at (prev + 0, 17) to (start + 2, 6)
= (c0 - c8)
- Code(Counter(8)) at (prev + 2, 5) to (start + 0, 6)
= (c0 - c6)
- Code(Counter(6)) at (prev + 2, 5) to (start + 0, 6)
- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 15)
- Code(Counter(9)) at (prev + 0, 16) to (start + 2, 6)
- Code(Counter(7)) at (prev + 0, 16) to (start + 2, 6)
- Code(Expression(6, Sub)) at (prev + 2, 12) to (start + 2, 6)
= (c0 - c9)
= (c0 - c7)
- Code(Counter(0)) at (prev + 3, 1) to (start + 0, 2)
Highest counter ID seen: c9
Highest counter ID seen: c7

223
tests/coverage/loops_branches.cov-map
View File

@ -1,50 +1,42 @@
Function name: <loops_branches::DebugTest as core::fmt::Debug>::fmt
Raw bytes (228): 0x[01, 01, 2a, 05, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, a3, 01, a7, 01, 0d, 00, 11, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 9a, 01, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 96, 01, 00, 9a, 01, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 9a, 01, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 96, 01, 11, 9a, 01, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 8f, 01, 19, 25, 92, 01, 96, 01, 11, 9a, 01, 00, 9f, 01, 19, a3, 01, a7, 01, 0d, 00, 11, 00, 14, 01, 09, 05, 01, 10, 05, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 02, 01, 0d, 00, 0e, 05, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, 9a, 01, 03, 0d, 00, 0e, 9f, 01, 00, 12, 00, 17, 9a, 01, 01, 10, 00, 14, 96, 01, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 46, 01, 11, 00, 12, 96, 01, 01, 11, 00, 22, 92, 01, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 19, 03, 09, 00, 0f, 8b, 01, 01, 05, 00, 06]
Raw bytes (174): 0x[01, 01, 22, 05, 00, 2f, 7b, 67, 00, 77, 19, 01, 15, 05, 21, 2f, 05, 67, 00, 77, 19, 01, 15, 2f, 7b, 67, 00, 77, 19, 01, 15, 05, 21, 67, 7b, 77, 19, 01, 15, 05, 21, 67, 5b, 77, 19, 01, 15, 7b, 00, 05, 21, 67, 7b, 77, 19, 01, 15, 05, 21, 77, 7b, 01, 15, 05, 21, 83, 01, 05, 87, 01, 15, 01, 11, 14, 01, 09, 05, 01, 10, 05, 02, 10, 00, 15, 00, 01, 17, 00, 1b, 00, 00, 1c, 00, 1e, 02, 01, 0d, 00, 0e, 05, 01, 0d, 00, 1e, 11, 00, 1e, 00, 1f, 00, 01, 10, 01, 0a, 2a, 03, 0d, 00, 0e, 1a, 00, 12, 00, 17, 2a, 01, 10, 00, 14, 62, 01, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 4e, 01, 11, 00, 12, 62, 01, 11, 00, 22, 72, 00, 22, 00, 23, 00, 01, 14, 01, 0e, 21, 03, 09, 00, 0f, 7e, 01, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 42
Number of expressions: 34
- expression 0 operands: lhs = Counter(1), rhs = Zero
- expression 1 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 2 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 3 operands: lhs = Counter(3), rhs = Zero
- expression 4 operands: lhs = Counter(4), rhs = Zero
- expression 5 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 6 operands: lhs = Counter(3), rhs = Zero
- expression 7 operands: lhs = Counter(4), rhs = Zero
- expression 8 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 9 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 10 operands: lhs = Counter(3), rhs = Zero
- expression 11 operands: lhs = Counter(4), rhs = Zero
- expression 12 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 13 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 14 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 15 operands: lhs = Counter(3), rhs = Zero
- expression 16 operands: lhs = Counter(4), rhs = Zero
- expression 17 operands: lhs = Expression(37, Sub), rhs = Zero
- expression 18 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 19 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 20 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 21 operands: lhs = Counter(3), rhs = Zero
- expression 22 operands: lhs = Counter(4), rhs = Zero
- expression 23 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 24 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 25 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 26 operands: lhs = Counter(3), rhs = Zero
- expression 27 operands: lhs = Counter(4), rhs = Zero
- expression 28 operands: lhs = Expression(37, Sub), rhs = Counter(4)
- expression 29 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 30 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 31 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 32 operands: lhs = Counter(3), rhs = Zero
- expression 33 operands: lhs = Counter(4), rhs = Zero
- expression 34 operands: lhs = Expression(35, Add), rhs = Counter(6)
- expression 35 operands: lhs = Counter(9), rhs = Expression(36, Sub)
- expression 36 operands: lhs = Expression(37, Sub), rhs = Counter(4)
- expression 37 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 38 operands: lhs = Expression(39, Add), rhs = Counter(6)
- expression 39 operands: lhs = Expression(40, Add), rhs = Expression(41, Add)
- expression 40 operands: lhs = Counter(3), rhs = Zero
- expression 41 operands: lhs = Counter(4), rhs = Zero
- expression 1 operands: lhs = Expression(11, Add), rhs = Expression(30, Add)
- expression 2 operands: lhs = Expression(25, Add), rhs = Zero
- expression 3 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 4 operands: lhs = Counter(0), rhs = Counter(5)
- expression 5 operands: lhs = Counter(1), rhs = Counter(8)
- expression 6 operands: lhs = Expression(11, Add), rhs = Counter(1)
- expression 7 operands: lhs = Expression(25, Add), rhs = Zero
- expression 8 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 9 operands: lhs = Counter(0), rhs = Counter(5)
- expression 10 operands: lhs = Expression(11, Add), rhs = Expression(30, Add)
- expression 11 operands: lhs = Expression(25, Add), rhs = Zero
- expression 12 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 13 operands: lhs = Counter(0), rhs = Counter(5)
- expression 14 operands: lhs = Counter(1), rhs = Counter(8)
- expression 15 operands: lhs = Expression(25, Add), rhs = Expression(30, Add)
- expression 16 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 17 operands: lhs = Counter(0), rhs = Counter(5)
- expression 18 operands: lhs = Counter(1), rhs = Counter(8)
- expression 19 operands: lhs = Expression(25, Add), rhs = Expression(22, Add)
- expression 20 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 21 operands: lhs = Counter(0), rhs = Counter(5)
- expression 22 operands: lhs = Expression(30, Add), rhs = Zero
- expression 23 operands: lhs = Counter(1), rhs = Counter(8)
- expression 24 operands: lhs = Expression(25, Add), rhs = Expression(30, Add)
- expression 25 operands: lhs = Expression(29, Add), rhs = Counter(6)
- expression 26 operands: lhs = Counter(0), rhs = Counter(5)
- expression 27 operands: lhs = Counter(1), rhs = Counter(8)
- expression 28 operands: lhs = Expression(29, Add), rhs = Expression(30, Add)
- expression 29 operands: lhs = Counter(0), rhs = Counter(5)
- expression 30 operands: lhs = Counter(1), rhs = Counter(8)
- expression 31 operands: lhs = Expression(32, Add), rhs = Counter(1)
- expression 32 operands: lhs = Expression(33, Add), rhs = Counter(5)
- expression 33 operands: lhs = Counter(0), rhs = Counter(4)
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)
@ -53,78 +45,59 @@ Number of file 0 mappings: 20
- Code(Expression(0, Sub)) at (prev + 1, 13) to (start + 0, 14)
= (c1 - Zero)
- Code(Counter(1)) at (prev + 1, 13) to (start + 0, 30)
- Code(Counter(9)) at (prev + 0, 30) to (start + 0, 31)
- Code(Counter(4)) at (prev + 0, 30) to (start + 0, 31)
- Code(Zero) at (prev + 1, 16) to (start + 1, 10)
- Code(Expression(38, Sub)) at (prev + 3, 13) to (start + 0, 14)
= (((c3 + Zero) + (c4 + Zero)) - c6)
- Code(Expression(39, Add)) at (prev + 0, 18) to (start + 0, 23)
= ((c3 + Zero) + (c4 + Zero))
- Code(Expression(38, Sub)) at (prev + 1, 16) to (start + 0, 20)
= (((c3 + Zero) + (c4 + Zero)) - c6)
- Code(Expression(37, Sub)) at (prev + 1, 20) to (start + 0, 25)
= ((((c3 + Zero) + (c4 + Zero)) - c6) - Zero)
- Code(Expression(10, Sub)) at (prev + 3, 13) to (start + 0, 14)
= ((((c0 + c5) + c6) + Zero) - (c1 + c8))
- Code(Expression(6, Sub)) at (prev + 0, 18) to (start + 0, 23)
= ((((c0 + c5) + c6) + Zero) - c1)
- Code(Expression(10, Sub)) at (prev + 1, 16) to (start + 0, 20)
= ((((c0 + c5) + c6) + Zero) - (c1 + c8))
- Code(Expression(24, Sub)) at (prev + 1, 20) to (start + 0, 25)
= (((c0 + c5) + c6) - (c1 + c8))
- Code(Zero) at (prev + 1, 27) to (start + 0, 31)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
- Code(Expression(17, Sub)) at (prev + 1, 17) to (start + 0, 18)
= (((((c3 + Zero) + (c4 + Zero)) - c6) - Zero) - Zero)
- Code(Expression(37, Sub)) at (prev + 1, 17) to (start + 0, 34)
= ((((c3 + Zero) + (c4 + Zero)) - c6) - Zero)
- Code(Expression(36, Sub)) at (prev + 0, 34) to (start + 0, 35)
= (((((c3 + Zero) + (c4 + Zero)) - c6) - Zero) - c4)
- Code(Expression(19, Sub)) at (prev + 1, 17) to (start + 0, 18)
= (((c0 + c5) + c6) - ((c1 + c8) + Zero))
- Code(Expression(24, Sub)) at (prev + 1, 17) to (start + 0, 34)
= (((c0 + c5) + c6) - (c1 + c8))
- Code(Expression(28, Sub)) at (prev + 0, 34) to (start + 0, 35)
= ((c0 + c5) - (c1 + c8))
- Code(Zero) at (prev + 1, 20) to (start + 1, 14)
- Code(Counter(6)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(34, Add)) at (prev + 1, 5) to (start + 0, 6)
= ((c9 + (((((c3 + Zero) + (c4 + Zero)) - c6) - Zero) - c4)) + c6)
Highest counter ID seen: c9
- Code(Counter(8)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(31, Sub)) at (prev + 1, 5) to (start + 0, 6)
= (((c0 + c4) + c5) - c1)
Highest counter ID seen: c8
Function name: <loops_branches::DisplayTest as core::fmt::Display>::fmt
Raw bytes (230): 0x[01, 01, 2b, 01, 00, 02, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, a7, 01, ab, 01, 00, 0d, 00, 15, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 9e, 01, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 9a, 01, 00, 9e, 01, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 9e, 01, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 9a, 01, 15, 9e, 01, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 93, 01, 25, 96, 01, 19, 9a, 01, 15, 9e, 01, 00, a3, 01, 19, a7, 01, ab, 01, 00, 0d, 00, 15, 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, 06, 01, 0d, 00, 0e, 02, 01, 0d, 00, 1e, 25, 00, 1e, 00, 1f, 9e, 01, 02, 0d, 00, 0e, a3, 01, 00, 12, 00, 17, 9e, 01, 01, 10, 00, 15, 00, 00, 16, 01, 0e, 9a, 01, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 4a, 01, 11, 00, 12, 9a, 01, 01, 11, 00, 22, 96, 01, 00, 22, 00, 23, 19, 03, 09, 00, 0f, 8f, 01, 01, 05, 00, 06]
Raw bytes (152): 0x[01, 01, 18, 01, 00, 01, 00, 23, 15, 27, 11, 00, 0d, 27, 11, 00, 0d, 23, 15, 27, 11, 00, 0d, 4b, 15, 4f, 11, 00, 0d, 4b, 43, 4f, 11, 00, 0d, 15, 00, 4b, 15, 4f, 11, 00, 0d, 5f, 15, 00, 11, 5f, 21, 00, 11, 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, 06, 01, 0d, 00, 0e, 02, 01, 0d, 00, 1e, 21, 00, 1e, 00, 1f, 1e, 02, 0d, 00, 0e, 23, 00, 12, 00, 17, 1e, 01, 10, 00, 15, 00, 00, 16, 01, 0e, 46, 02, 14, 00, 19, 00, 01, 1b, 00, 1f, 00, 00, 20, 00, 22, 36, 01, 11, 00, 12, 46, 01, 11, 00, 22, 52, 00, 22, 00, 23, 15, 03, 09, 00, 0f, 5b, 01, 05, 00, 06]
Number of files: 1
- file 0 => global file 1
Number of expressions: 43
Number of expressions: 24
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Expression(0, Sub), rhs = Zero
- expression 2 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 3 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 1 operands: lhs = Counter(0), rhs = Zero
- expression 2 operands: lhs = Expression(8, Add), rhs = Counter(5)
- expression 3 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 4 operands: lhs = Zero, rhs = Counter(3)
- expression 5 operands: lhs = Zero, rhs = Counter(5)
- expression 6 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 7 operands: lhs = Zero, rhs = Counter(3)
- expression 8 operands: lhs = Zero, rhs = Counter(5)
- expression 9 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 10 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 11 operands: lhs = Zero, rhs = Counter(3)
- expression 12 operands: lhs = Zero, rhs = Counter(5)
- expression 13 operands: lhs = Expression(39, Sub), rhs = Zero
- expression 14 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 15 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 16 operands: lhs = Zero, rhs = Counter(3)
- expression 17 operands: lhs = Zero, rhs = Counter(5)
- expression 18 operands: lhs = Expression(38, Sub), rhs = Zero
- expression 19 operands: lhs = Expression(39, Sub), rhs = Zero
- expression 20 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 21 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 22 operands: lhs = Zero, rhs = Counter(3)
- expression 23 operands: lhs = Zero, rhs = Counter(5)
- expression 24 operands: lhs = Expression(39, Sub), rhs = Zero
- expression 25 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 26 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 27 operands: lhs = Zero, rhs = Counter(3)
- expression 28 operands: lhs = Zero, rhs = Counter(5)
- expression 29 operands: lhs = Expression(38, Sub), rhs = Counter(5)
- expression 30 operands: lhs = Expression(39, Sub), rhs = Zero
- expression 31 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 32 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 33 operands: lhs = Zero, rhs = Counter(3)
- expression 34 operands: lhs = Zero, rhs = Counter(5)
- expression 35 operands: lhs = Expression(36, Add), rhs = Counter(9)
- expression 36 operands: lhs = Expression(37, Sub), rhs = Counter(6)
- expression 37 operands: lhs = Expression(38, Sub), rhs = Counter(5)
- expression 38 operands: lhs = Expression(39, Sub), rhs = Zero
- expression 39 operands: lhs = Expression(40, Add), rhs = Counter(6)
- expression 40 operands: lhs = Expression(41, Add), rhs = Expression(42, Add)
- expression 41 operands: lhs = Zero, rhs = Counter(3)
- expression 42 operands: lhs = Zero, rhs = Counter(5)
- expression 5 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 6 operands: lhs = Zero, rhs = Counter(3)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(5)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 9 operands: lhs = Zero, rhs = Counter(3)
- expression 10 operands: lhs = Expression(18, Add), rhs = Counter(5)
- expression 11 operands: lhs = Expression(19, Add), rhs = Counter(4)
- expression 12 operands: lhs = Zero, rhs = Counter(3)
- expression 13 operands: lhs = Expression(18, Add), rhs = Expression(16, Add)
- expression 14 operands: lhs = Expression(19, Add), rhs = Counter(4)
- expression 15 operands: lhs = Zero, rhs = Counter(3)
- expression 16 operands: lhs = Counter(5), rhs = Zero
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(5)
- expression 18 operands: lhs = Expression(19, Add), rhs = Counter(4)
- expression 19 operands: lhs = Zero, rhs = Counter(3)
- expression 20 operands: lhs = Expression(23, Add), rhs = Counter(5)
- expression 21 operands: lhs = Zero, rhs = Counter(4)
- expression 22 operands: lhs = Expression(23, Add), rhs = Counter(8)
- expression 23 operands: lhs = Zero, rhs = Counter(4)
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)
@ -133,31 +106,31 @@ Number of file 0 mappings: 20
- Code(Zero) at (prev + 1, 23) to (start + 0, 27)
- Code(Zero) at (prev + 0, 28) to (start + 0, 30)
- Code(Expression(1, Sub)) at (prev + 1, 13) to (start + 0, 14)
= ((c0 - Zero) - Zero)
= (c0 - Zero)
- Code(Expression(0, Sub)) at (prev + 1, 13) to (start + 0, 30)
= (c0 - Zero)
- Code(Counter(9)) at (prev + 0, 30) to (start + 0, 31)
- Code(Expression(39, Sub)) at (prev + 2, 13) to (start + 0, 14)
= (((Zero + c3) + (Zero + c5)) - c6)
- Code(Expression(40, Add)) at (prev + 0, 18) to (start + 0, 23)
= ((Zero + c3) + (Zero + c5))
- Code(Expression(39, Sub)) at (prev + 1, 16) to (start + 0, 21)
= (((Zero + c3) + (Zero + c5)) - c6)
- Code(Counter(8)) at (prev + 0, 30) to (start + 0, 31)
- Code(Expression(7, Sub)) at (prev + 2, 13) to (start + 0, 14)
= (((Zero + c3) + c4) - c5)
- Code(Expression(8, Add)) at (prev + 0, 18) to (start + 0, 23)
= ((Zero + c3) + c4)
- Code(Expression(7, Sub)) at (prev + 1, 16) to (start + 0, 21)
= (((Zero + c3) + c4) - c5)
- Code(Zero) at (prev + 0, 22) to (start + 1, 14)
- Code(Expression(38, Sub)) at (prev + 2, 20) to (start + 0, 25)
= ((((Zero + c3) + (Zero + c5)) - c6) - Zero)
- Code(Expression(17, Sub)) at (prev + 2, 20) to (start + 0, 25)
= (((Zero + c3) + c4) - c5)
- Code(Zero) at (prev + 1, 27) to (start + 0, 31)
- Code(Zero) at (prev + 0, 32) to (start + 0, 34)
- Code(Expression(18, Sub)) at (prev + 1, 17) to (start + 0, 18)
= (((((Zero + c3) + (Zero + c5)) - c6) - Zero) - Zero)
- Code(Expression(38, Sub)) at (prev + 1, 17) to (start + 0, 34)
= ((((Zero + c3) + (Zero + c5)) - c6) - Zero)
- Code(Expression(37, Sub)) at (prev + 0, 34) to (start + 0, 35)
= (((((Zero + c3) + (Zero + c5)) - c6) - Zero) - c5)
- Code(Counter(6)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(35, Add)) at (prev + 1, 5) to (start + 0, 6)
= (((((((Zero + c3) + (Zero + c5)) - c6) - Zero) - c5) + c6) + c9)
Highest counter ID seen: c9
- Code(Expression(13, Sub)) at (prev + 1, 17) to (start + 0, 18)
= (((Zero + c3) + c4) - (c5 + Zero))
- Code(Expression(17, Sub)) at (prev + 1, 17) to (start + 0, 34)
= (((Zero + c3) + c4) - c5)
- Code(Expression(20, Sub)) at (prev + 0, 34) to (start + 0, 35)
= ((Zero + c4) - c5)
- Code(Counter(5)) at (prev + 3, 9) to (start + 0, 15)
- Code(Expression(22, Add)) at (prev + 1, 5) to (start + 0, 6)
= ((Zero + c4) + c8)
Highest counter ID seen: c8
Function name: loops_branches::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 37, 01, 05, 02]

156
tests/coverage/mcdc/condition-limit.cov-map
View File

@ -1,52 +1,54 @@
Function name: condition_limit::accept_7_conditions
Raw bytes (232): 0x[01, 01, 2c, 01, 05, 05, 1d, 05, 1d, 7a, 19, 05, 1d, 7a, 19, 05, 1d, 76, 15, 7a, 19, 05, 1d, 76, 15, 7a, 19, 05, 1d, 72, 11, 76, 15, 7a, 19, 05, 1d, 72, 11, 76, 15, 7a, 19, 05, 1d, 6e, 0d, 72, 11, 76, 15, 7a, 19, 05, 1d, 6e, 0d, 72, 11, 76, 15, 7a, 19, 05, 1d, 9f, 01, 02, a3, 01, 1d, a7, 01, 19, ab, 01, 15, af, 01, 11, 09, 0d, 21, 9b, 01, 9f, 01, 02, a3, 01, 1d, a7, 01, 19, ab, 01, 15, af, 01, 11, 09, 0d, 12, 01, 07, 01, 02, 09, 28, 08, 07, 02, 08, 00, 27, 30, 05, 02, 01, 07, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 7a, 1d, 07, 06, 00, 00, 0d, 00, 0e, 7a, 00, 12, 00, 13, 30, 76, 19, 06, 05, 00, 00, 12, 00, 13, 76, 00, 17, 00, 18, 30, 72, 15, 05, 04, 00, 00, 17, 00, 18, 72, 00, 1c, 00, 1d, 30, 6e, 11, 04, 03, 00, 00, 1c, 00, 1d, 6e, 00, 21, 00, 22, 30, 6a, 0d, 03, 02, 00, 00, 21, 00, 22, 6a, 00, 26, 00, 27, 30, 21, 09, 02, 00, 00, 00, 26, 00, 27, 21, 00, 28, 02, 06, 9b, 01, 02, 05, 00, 06, 97, 01, 01, 01, 00, 02]
Raw bytes (237): 0x[01, 01, 2e, 01, 05, 05, 09, 05, 09, 05, 7b, 09, 0d, 05, 7b, 09, 0d, 05, 77, 7b, 11, 09, 0d, 05, 77, 7b, 11, 09, 0d, 05, 73, 77, 15, 7b, 11, 09, 0d, 05, 73, 77, 15, 7b, 11, 09, 0d, 05, 6f, 73, 19, 77, 15, 7b, 11, 09, 0d, 05, 6f, 73, 19, 77, 15, 7b, 11, 09, 0d, 83, 01, 05, a7, 01, 21, ab, 01, 19, af, 01, 15, b3, 01, 11, b7, 01, 0d, 01, 09, 9f, 01, 05, a3, 01, 21, a7, 01, 1d, ab, 01, 19, af, 01, 15, b3, 01, 11, b7, 01, 0d, 01, 09, 12, 01, 07, 01, 02, 09, 28, 08, 07, 02, 08, 00, 27, 30, 05, 02, 01, 07, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 0a, 09, 07, 06, 00, 00, 0d, 00, 0e, 0a, 00, 12, 00, 13, 30, 16, 0d, 06, 05, 00, 00, 12, 00, 13, 16, 00, 17, 00, 18, 30, 2a, 11, 05, 04, 00, 00, 17, 00, 18, 2a, 00, 1c, 00, 1d, 30, 46, 15, 04, 03, 00, 00, 1c, 00, 1d, 46, 00, 21, 00, 22, 30, 6a, 19, 03, 02, 00, 00, 21, 00, 22, 6a, 00, 26, 00, 27, 30, 1d, 21, 02, 00, 00, 00, 26, 00, 27, 1d, 00, 28, 02, 06, 7e, 02, 05, 00, 06, 9a, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 44
Number of expressions: 46
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(7)
- expression 2 operands: lhs = Counter(1), rhs = Counter(7)
- expression 3 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 4 operands: lhs = Counter(1), rhs = Counter(7)
- expression 5 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 6 operands: lhs = Counter(1), rhs = Counter(7)
- expression 7 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 8 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 9 operands: lhs = Counter(1), rhs = Counter(7)
- expression 10 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 11 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 12 operands: lhs = Counter(1), rhs = Counter(7)
- expression 13 operands: lhs = Expression(28, Sub), rhs = Counter(4)
- expression 14 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 15 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 16 operands: lhs = Counter(1), rhs = Counter(7)
- expression 17 operands: lhs = Expression(28, Sub), rhs = Counter(4)
- expression 18 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 19 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 20 operands: lhs = Counter(1), rhs = Counter(7)
- expression 21 operands: lhs = Expression(27, Sub), rhs = Counter(3)
- expression 22 operands: lhs = Expression(28, Sub), rhs = Counter(4)
- expression 23 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 24 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 25 operands: lhs = Counter(1), rhs = Counter(7)
- expression 26 operands: lhs = Expression(27, Sub), rhs = Counter(3)
- expression 27 operands: lhs = Expression(28, Sub), rhs = Counter(4)
- expression 28 operands: lhs = Expression(29, Sub), rhs = Counter(5)
- expression 29 operands: lhs = Expression(30, Sub), rhs = Counter(6)
- expression 30 operands: lhs = Counter(1), rhs = Counter(7)
- expression 31 operands: lhs = Expression(39, Add), rhs = Expression(0, Sub)
- expression 32 operands: lhs = Expression(40, Add), rhs = Counter(7)
- expression 33 operands: lhs = Expression(41, Add), rhs = Counter(6)
- expression 34 operands: lhs = Expression(42, Add), rhs = Counter(5)
- expression 35 operands: lhs = Expression(43, Add), rhs = Counter(4)
- expression 36 operands: lhs = Counter(2), rhs = Counter(3)
- expression 37 operands: lhs = Counter(8), rhs = Expression(38, Add)
- expression 38 operands: lhs = Expression(39, Add), rhs = Expression(0, Sub)
- expression 39 operands: lhs = Expression(40, Add), rhs = Counter(7)
- expression 40 operands: lhs = Expression(41, Add), rhs = Counter(6)
- expression 41 operands: lhs = Expression(42, Add), rhs = Counter(5)
- expression 42 operands: lhs = Expression(43, Add), rhs = Counter(4)
- expression 43 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Expression(30, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 5 operands: lhs = Counter(1), rhs = Expression(30, Add)
- expression 6 operands: lhs = Counter(2), rhs = Counter(3)
- expression 7 operands: lhs = Counter(1), rhs = Expression(29, Add)
- expression 8 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 9 operands: lhs = Counter(2), rhs = Counter(3)
- expression 10 operands: lhs = Counter(1), rhs = Expression(29, Add)
- expression 11 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
- expression 13 operands: lhs = Counter(1), rhs = Expression(28, Add)
- expression 14 operands: lhs = Expression(29, Add), rhs = Counter(5)
- expression 15 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 16 operands: lhs = Counter(2), rhs = Counter(3)
- expression 17 operands: lhs = Counter(1), rhs = Expression(28, Add)
- expression 18 operands: lhs = Expression(29, Add), rhs = Counter(5)
- expression 19 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 20 operands: lhs = Counter(2), rhs = Counter(3)
- expression 21 operands: lhs = Counter(1), rhs = Expression(27, Add)
- expression 22 operands: lhs = Expression(28, Add), rhs = Counter(6)
- expression 23 operands: lhs = Expression(29, Add), rhs = Counter(5)
- expression 24 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 25 operands: lhs = Counter(2), rhs = Counter(3)
- expression 26 operands: lhs = Counter(1), rhs = Expression(27, Add)
- expression 27 operands: lhs = Expression(28, Add), rhs = Counter(6)
- expression 28 operands: lhs = Expression(29, Add), rhs = Counter(5)
- expression 29 operands: lhs = Expression(30, Add), rhs = Counter(4)
- expression 30 operands: lhs = Counter(2), rhs = Counter(3)
- expression 31 operands: lhs = Expression(32, Add), rhs = Counter(1)
- expression 32 operands: lhs = Expression(41, Add), rhs = Counter(8)
- expression 33 operands: lhs = Expression(42, Add), rhs = Counter(6)
- expression 34 operands: lhs = Expression(43, Add), rhs = Counter(5)
- expression 35 operands: lhs = Expression(44, Add), rhs = Counter(4)
- expression 36 operands: lhs = Expression(45, Add), rhs = Counter(3)
- expression 37 operands: lhs = Counter(0), rhs = Counter(2)
- expression 38 operands: lhs = Expression(39, Add), rhs = Counter(1)
- expression 39 operands: lhs = Expression(40, Add), rhs = Counter(8)
- expression 40 operands: lhs = Expression(41, Add), rhs = Counter(7)
- expression 41 operands: lhs = Expression(42, Add), rhs = Counter(6)
- expression 42 operands: lhs = Expression(43, Add), rhs = Counter(5)
- expression 43 operands: lhs = Expression(44, Add), rhs = Counter(4)
- expression 44 operands: lhs = Expression(45, Add), rhs = Counter(3)
- expression 45 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 18
- Code(Counter(0)) at (prev + 7, 1) to (start + 2, 9)
- MCDCDecision { bitmap_idx: 8, conditions_num: 7 } at (prev + 2, 8) to (start + 0, 39)
@ -54,38 +56,38 @@ Number of file 0 mappings: 18
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Expression(30, Sub), false: Counter(7), condition_id: 7, true_next_id: 6, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = (c1 - c7)
false = c7
- Code(Expression(30, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c1 - c7)
- MCDCBranch { true: Expression(29, Sub), false: Counter(6), condition_id: 6, true_next_id: 5, false_next_id: 0 } at (prev + 0, 18) to (start + 0, 19)
true = ((c1 - c7) - c6)
false = c6
- Code(Expression(29, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c1 - c7) - c6)
- MCDCBranch { true: Expression(28, Sub), false: Counter(5), condition_id: 5, true_next_id: 4, false_next_id: 0 } at (prev + 0, 23) to (start + 0, 24)
true = (((c1 - c7) - c6) - c5)
false = c5
- Code(Expression(28, Sub)) at (prev + 0, 28) to (start + 0, 29)
= (((c1 - c7) - c6) - c5)
- MCDCBranch { true: Expression(27, Sub), false: Counter(4), condition_id: 4, true_next_id: 3, false_next_id: 0 } at (prev + 0, 28) to (start + 0, 29)
true = ((((c1 - c7) - c6) - c5) - c4)
false = c4
- Code(Expression(27, Sub)) at (prev + 0, 33) to (start + 0, 34)
= ((((c1 - c7) - c6) - c5) - c4)
- MCDCBranch { true: Expression(26, Sub), false: Counter(3), condition_id: 3, true_next_id: 2, false_next_id: 0 } at (prev + 0, 33) to (start + 0, 34)
true = (((((c1 - c7) - c6) - c5) - c4) - c3)
false = c3
- Code(Expression(26, Sub)) at (prev + 0, 38) to (start + 0, 39)
= (((((c1 - c7) - c6) - c5) - c4) - c3)
- MCDCBranch { true: Counter(8), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 38) to (start + 0, 39)
true = c8
- MCDCBranch { true: Expression(2, Sub), false: Counter(2), condition_id: 7, true_next_id: 6, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = (c1 - c2)
false = c2
- Code(Counter(8)) at (prev + 0, 40) to (start + 2, 6)
- Code(Expression(38, Add)) at (prev + 2, 5) to (start + 0, 6)
= ((((((c2 + c3) + c4) + c5) + c6) + c7) + (c0 - c1))
- Code(Expression(37, Add)) at (prev + 1, 1) to (start + 0, 2)
= (c8 + ((((((c2 + c3) + c4) + c5) + c6) + c7) + (c0 - c1)))
- Code(Expression(2, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c1 - c2)
- MCDCBranch { true: Expression(5, Sub), false: Counter(3), condition_id: 6, true_next_id: 5, false_next_id: 0 } at (prev + 0, 18) to (start + 0, 19)
true = (c1 - (c2 + c3))
false = c3
- Code(Expression(5, Sub)) at (prev + 0, 23) to (start + 0, 24)
= (c1 - (c2 + c3))
- MCDCBranch { true: Expression(10, Sub), false: Counter(4), condition_id: 5, true_next_id: 4, false_next_id: 0 } at (prev + 0, 23) to (start + 0, 24)
true = (c1 - ((c2 + c3) + c4))
false = c4
- Code(Expression(10, Sub)) at (prev + 0, 28) to (start + 0, 29)
= (c1 - ((c2 + c3) + c4))
- MCDCBranch { true: Expression(17, Sub), false: Counter(5), condition_id: 4, true_next_id: 3, false_next_id: 0 } at (prev + 0, 28) to (start + 0, 29)
true = (c1 - (((c2 + c3) + c4) + c5))
false = c5
- Code(Expression(17, Sub)) at (prev + 0, 33) to (start + 0, 34)
= (c1 - (((c2 + c3) + c4) + c5))
- MCDCBranch { true: Expression(26, Sub), false: Counter(6), condition_id: 3, true_next_id: 2, false_next_id: 0 } at (prev + 0, 33) to (start + 0, 34)
true = (c1 - ((((c2 + c3) + c4) + c5) + c6))
false = c6
- Code(Expression(26, Sub)) at (prev + 0, 38) to (start + 0, 39)
= (c1 - ((((c2 + c3) + c4) + c5) + c6))
- MCDCBranch { true: Counter(7), false: Counter(8), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 38) to (start + 0, 39)
true = c7
false = c8
- Code(Counter(7)) at (prev + 0, 40) to (start + 2, 6)
- Code(Expression(31, Sub)) at (prev + 2, 5) to (start + 0, 6)
= (((((((c0 + c2) + c3) + c4) + c5) + c6) + c8) - c1)
- Code(Expression(38, Sub)) at (prev + 1, 1) to (start + 0, 2)
= ((((((((c0 + c2) + c3) + c4) + c5) + c6) + c7) + c8) - c1)
Highest counter ID seen: c8

262
tests/coverage/mcdc/if.cov-map
View File

@ -1,12 +1,14 @@
Function name: if::mcdc_check_a
Raw bytes (64): 0x[01, 01, 04, 01, 05, 09, 02, 0d, 0f, 09, 02, 08, 01, 0f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0f, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
Raw bytes (68): 0x[01, 01, 06, 01, 05, 0b, 05, 01, 0d, 13, 05, 17, 0d, 01, 09, 08, 01, 0f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 0d, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 06, 02, 0c, 02, 06, 0e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 6
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(3), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(1)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
@ -14,25 +16,27 @@ Number of file 0 mappings: 8
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c3
false = c2
- Code(Counter(3)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c2
false = c3
- Code(Counter(2)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c3) - c1)
- Code(Expression(3, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: if::mcdc_check_b
Raw bytes (64): 0x[01, 01, 04, 01, 05, 09, 02, 0d, 0f, 09, 02, 08, 01, 17, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0f, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
Raw bytes (68): 0x[01, 01, 06, 01, 05, 0b, 05, 01, 0d, 13, 05, 17, 0d, 01, 09, 08, 01, 17, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 0d, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 06, 02, 0c, 02, 06, 0e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 6
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(3), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(1)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 23, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
@ -40,25 +44,27 @@ Number of file 0 mappings: 8
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c3
false = c2
- Code(Counter(3)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c2
false = c3
- Code(Counter(2)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c3) - c1)
- Code(Expression(3, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: if::mcdc_check_both
Raw bytes (64): 0x[01, 01, 04, 01, 05, 09, 02, 0d, 0f, 09, 02, 08, 01, 1f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0f, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
Raw bytes (68): 0x[01, 01, 06, 01, 05, 0b, 05, 01, 0d, 13, 05, 17, 0d, 01, 09, 08, 01, 1f, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 0d, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 06, 02, 0c, 02, 06, 0e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 6
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(3), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(1)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 31, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
@ -66,25 +72,27 @@ Number of file 0 mappings: 8
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c3
false = c2
- Code(Counter(3)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c2
false = c3
- Code(Counter(2)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c3) - c1)
- Code(Expression(3, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: if::mcdc_check_neither
Raw bytes (64): 0x[01, 01, 04, 01, 05, 09, 02, 0d, 0f, 09, 02, 08, 01, 07, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 0e, 0d, 00, 0f, 02, 06, 0f, 02, 0c, 02, 06, 0b, 03, 01, 00, 02]
Raw bytes (68): 0x[01, 01, 06, 01, 05, 0b, 05, 01, 0d, 13, 05, 17, 0d, 01, 09, 08, 01, 07, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0d, 00, 0e, 30, 09, 0d, 02, 00, 00, 00, 0d, 00, 0e, 09, 00, 0f, 02, 06, 06, 02, 0c, 02, 06, 0e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
Number of expressions: 6
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(3), rhs = Expression(3, Add)
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(1)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
@ -92,29 +100,32 @@ Number of file 0 mappings: 8
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c3
false = c2
- Code(Counter(3)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(3, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(2, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c2
false = c3
- Code(Counter(2)) at (prev + 0, 15) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c3) - c1)
- Code(Expression(3, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: if::mcdc_check_not_tree_decision
Raw bytes (87): 0x[01, 01, 08, 01, 05, 02, 09, 05, 09, 0d, 1e, 02, 09, 11, 1b, 0d, 1e, 02, 09, 0a, 01, 31, 01, 03, 0a, 28, 05, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 03, 00, 09, 00, 0a, 02, 00, 0e, 00, 0f, 30, 09, 1e, 03, 02, 00, 00, 0e, 00, 0f, 0b, 00, 14, 00, 15, 30, 11, 0d, 02, 00, 00, 00, 14, 00, 15, 11, 00, 16, 02, 06, 1b, 02, 0c, 02, 06, 17, 03, 01, 00, 02]
Raw bytes (93): 0x[01, 01, 0b, 01, 05, 01, 2b, 05, 09, 05, 09, 17, 2b, 01, 11, 05, 09, 23, 2b, 27, 11, 01, 0d, 05, 09, 0a, 01, 31, 01, 03, 0a, 28, 05, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 03, 00, 09, 00, 0a, 02, 00, 0e, 00, 0f, 30, 09, 06, 03, 02, 00, 00, 0e, 00, 0f, 2b, 00, 14, 00, 15, 30, 0d, 11, 02, 00, 00, 00, 14, 00, 15, 0d, 00, 16, 02, 06, 12, 02, 0c, 02, 06, 1e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
Number of expressions: 11
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Expression(10, Add)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(3), rhs = Expression(7, Sub)
- expression 4 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 5 operands: lhs = Counter(4), rhs = Expression(6, Add)
- expression 6 operands: lhs = Counter(3), rhs = Expression(7, Sub)
- expression 7 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Add), rhs = Expression(10, Add)
- expression 5 operands: lhs = Counter(0), rhs = Counter(4)
- expression 6 operands: lhs = Counter(1), rhs = Counter(2)
- expression 7 operands: lhs = Expression(8, Add), rhs = Expression(10, Add)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 9 operands: lhs = Counter(0), rhs = Counter(3)
- expression 10 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 49, 1) to (start + 3, 10)
- MCDCDecision { bitmap_idx: 5, conditions_num: 3 } at (prev + 3, 8) to (start + 0, 21)
@ -123,34 +134,36 @@ Number of file 0 mappings: 10
false = (c0 - c1)
- Code(Expression(0, Sub)) at (prev + 0, 14) to (start + 0, 15)
= (c0 - c1)
- MCDCBranch { true: Counter(2), false: Expression(7, Sub), condition_id: 3, true_next_id: 2, false_next_id: 0 } at (prev + 0, 14) to (start + 0, 15)
- MCDCBranch { true: Counter(2), false: Expression(1, Sub), condition_id: 3, true_next_id: 2, false_next_id: 0 } at (prev + 0, 14) to (start + 0, 15)
true = c2
false = ((c0 - c1) - c2)
- Code(Expression(2, Add)) at (prev + 0, 20) to (start + 0, 21)
false = (c0 - (c1 + c2))
- Code(Expression(10, Add)) at (prev + 0, 20) to (start + 0, 21)
= (c1 + c2)
- MCDCBranch { true: Counter(4), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 20) to (start + 0, 21)
true = c4
false = c3
- Code(Counter(4)) at (prev + 0, 22) to (start + 2, 6)
- Code(Expression(6, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c3 + ((c0 - c1) - c2))
- Code(Expression(5, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c4 + (c3 + ((c0 - c1) - c2)))
- MCDCBranch { true: Counter(3), false: Counter(4), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 20) to (start + 0, 21)
true = c3
false = c4
- Code(Counter(3)) at (prev + 0, 22) to (start + 2, 6)
- Code(Expression(4, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c4) - (c1 + c2))
- Code(Expression(7, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c3) + c4) - (c1 + c2))
Highest counter ID seen: c4
Function name: if::mcdc_check_tree_decision
Raw bytes (87): 0x[01, 01, 08, 01, 05, 05, 0d, 05, 0d, 0d, 11, 09, 02, 1b, 1f, 0d, 11, 09, 02, 0a, 01, 27, 01, 03, 09, 28, 04, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0e, 00, 0f, 30, 0d, 0a, 02, 00, 03, 00, 0e, 00, 0f, 0a, 00, 13, 00, 14, 30, 11, 09, 03, 00, 00, 00, 13, 00, 14, 1b, 00, 16, 02, 06, 1f, 02, 0c, 02, 06, 17, 03, 01, 00, 02]
Raw bytes (91): 0x[01, 01, 0a, 01, 05, 05, 09, 05, 09, 09, 0d, 17, 05, 01, 11, 1f, 05, 23, 11, 27, 0d, 01, 09, 0a, 01, 27, 01, 03, 09, 28, 04, 03, 03, 08, 00, 15, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 05, 00, 0e, 00, 0f, 30, 09, 0a, 02, 00, 03, 00, 0e, 00, 0f, 0a, 00, 13, 00, 14, 30, 0d, 11, 03, 00, 00, 00, 13, 00, 14, 0f, 00, 16, 02, 06, 12, 02, 0c, 02, 06, 1a, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
Number of expressions: 10
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Counter(3)
- expression 3 operands: lhs = Counter(3), rhs = Counter(4)
- expression 4 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 5 operands: lhs = Expression(6, Add), rhs = Expression(7, Add)
- expression 6 operands: lhs = Counter(3), rhs = Counter(4)
- expression 7 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(1)
- expression 5 operands: lhs = Counter(0), rhs = Counter(4)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(1)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(4)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(3)
- expression 9 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 39, 1) to (start + 3, 9)
- MCDCDecision { bitmap_idx: 4, conditions_num: 3 } at (prev + 3, 8) to (start + 0, 21)
@ -158,40 +171,43 @@ Number of file 0 mappings: 10
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 14) to (start + 0, 15)
- MCDCBranch { true: Counter(3), false: Expression(2, Sub), condition_id: 2, true_next_id: 0, false_next_id: 3 } at (prev + 0, 14) to (start + 0, 15)
true = c3
false = (c1 - c3)
- MCDCBranch { true: Counter(2), false: Expression(2, Sub), condition_id: 2, true_next_id: 0, false_next_id: 3 } at (prev + 0, 14) to (start + 0, 15)
true = c2
false = (c1 - c2)
- Code(Expression(2, Sub)) at (prev + 0, 19) to (start + 0, 20)
= (c1 - c3)
- MCDCBranch { true: Counter(4), false: Counter(2), condition_id: 3, true_next_id: 0, false_next_id: 0 } at (prev + 0, 19) to (start + 0, 20)
true = c4
false = c2
- Code(Expression(6, Add)) at (prev + 0, 22) to (start + 2, 6)
= (c3 + c4)
- Code(Expression(7, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(5, Add)) at (prev + 3, 1) to (start + 0, 2)
= ((c3 + c4) + (c2 + (c0 - c1)))
= (c1 - c2)
- MCDCBranch { true: Counter(3), false: Counter(4), condition_id: 3, true_next_id: 0, false_next_id: 0 } at (prev + 0, 19) to (start + 0, 20)
true = c3
false = c4
- Code(Expression(3, Add)) at (prev + 0, 22) to (start + 2, 6)
= (c2 + c3)
- Code(Expression(4, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c4) - c1)
- Code(Expression(6, Sub)) at (prev + 3, 1) to (start + 0, 2)
= ((((c0 + c2) + c3) + c4) - c1)
Highest counter ID seen: c4
Function name: if::mcdc_nested_if
Raw bytes (124): 0x[01, 01, 0d, 01, 05, 02, 09, 05, 09, 1b, 15, 05, 09, 1b, 15, 05, 09, 11, 15, 02, 09, 2b, 32, 0d, 2f, 11, 15, 02, 09, 0e, 01, 3b, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 00, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 30, 09, 32, 02, 00, 00, 00, 0d, 00, 0e, 1b, 01, 09, 01, 0d, 28, 06, 02, 01, 0c, 00, 12, 30, 16, 15, 01, 02, 00, 00, 0c, 00, 0d, 16, 00, 11, 00, 12, 30, 0d, 11, 02, 00, 00, 00, 11, 00, 12, 0d, 00, 13, 02, 0a, 2f, 02, 09, 00, 0a, 32, 01, 0c, 02, 06, 27, 03, 01, 00, 02]
Raw bytes (130): 0x[01, 01, 10, 01, 05, 01, 3f, 05, 09, 05, 09, 3f, 0d, 05, 09, 3f, 0d, 05, 09, 0d, 15, 01, 3f, 05, 09, 33, 3f, 37, 15, 3b, 11, 01, 0d, 05, 09, 0e, 01, 3b, 01, 01, 09, 28, 03, 02, 01, 08, 00, 0e, 30, 05, 02, 01, 00, 02, 00, 08, 00, 09, 02, 00, 0d, 00, 0e, 30, 09, 26, 02, 00, 00, 00, 0d, 00, 0e, 3f, 01, 09, 01, 0d, 28, 06, 02, 01, 0c, 00, 12, 30, 1a, 0d, 01, 02, 00, 00, 0c, 00, 0d, 1a, 00, 11, 00, 12, 30, 11, 15, 02, 00, 00, 00, 11, 00, 12, 11, 00, 13, 02, 0a, 23, 02, 09, 00, 0a, 26, 01, 0c, 02, 06, 2e, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 13
Number of expressions: 16
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Expression(15, Add)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Expression(6, Add), rhs = Counter(5)
- expression 4 operands: lhs = Counter(1), rhs = Counter(2)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(5)
- expression 6 operands: lhs = Counter(1), rhs = Counter(2)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5)
- expression 8 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 9 operands: lhs = Expression(10, Add), rhs = Expression(12, Sub)
- expression 10 operands: lhs = Counter(3), rhs = Expression(11, Add)
- expression 11 operands: lhs = Counter(4), rhs = Counter(5)
- expression 12 operands: lhs = Expression(0, Sub), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(15, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Expression(15, Add), rhs = Counter(3)
- expression 7 operands: lhs = Counter(1), rhs = Counter(2)
- expression 8 operands: lhs = Counter(3), rhs = Counter(5)
- expression 9 operands: lhs = Counter(0), rhs = Expression(15, Add)
- expression 10 operands: lhs = Counter(1), rhs = Counter(2)
- expression 11 operands: lhs = Expression(12, Add), rhs = Expression(15, Add)
- expression 12 operands: lhs = Expression(13, Add), rhs = Counter(5)
- expression 13 operands: lhs = Expression(14, Add), rhs = Counter(4)
- expression 14 operands: lhs = Counter(0), rhs = Counter(3)
- expression 15 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 14
- Code(Counter(0)) at (prev + 59, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 14)
@ -200,26 +216,26 @@ Number of file 0 mappings: 14
false = (c0 - c1)
- Code(Expression(0, Sub)) at (prev + 0, 13) to (start + 0, 14)
= (c0 - c1)
- MCDCBranch { true: Counter(2), false: Expression(12, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(2), false: Expression(9, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c2
false = ((c0 - c1) - c2)
- Code(Expression(6, Add)) at (prev + 1, 9) to (start + 1, 13)
false = (c0 - (c1 + c2))
- Code(Expression(15, Add)) at (prev + 1, 9) to (start + 1, 13)
= (c1 + c2)
- MCDCDecision { bitmap_idx: 6, conditions_num: 2 } at (prev + 1, 12) to (start + 0, 18)
- MCDCBranch { true: Expression(5, Sub), false: Counter(5), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 12) to (start + 0, 13)
true = ((c1 + c2) - c5)
- MCDCBranch { true: Expression(6, Sub), false: Counter(3), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 12) to (start + 0, 13)
true = ((c1 + c2) - c3)
false = c3
- Code(Expression(6, Sub)) at (prev + 0, 17) to (start + 0, 18)
= ((c1 + c2) - c3)
- MCDCBranch { true: Counter(4), false: Counter(5), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 17) to (start + 0, 18)
true = c4
false = c5
- Code(Expression(5, Sub)) at (prev + 0, 17) to (start + 0, 18)
= ((c1 + c2) - c5)
- MCDCBranch { true: Counter(3), false: Counter(4), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 17) to (start + 0, 18)
true = c3
false = c4
- Code(Counter(3)) at (prev + 0, 19) to (start + 2, 10)
- Code(Expression(11, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c4 + c5)
- Code(Expression(12, Sub)) at (prev + 1, 12) to (start + 2, 6)
= ((c0 - c1) - c2)
- Code(Expression(9, Add)) at (prev + 3, 1) to (start + 0, 2)
= ((c3 + (c4 + c5)) + ((c0 - c1) - c2))
- Code(Counter(4)) at (prev + 0, 19) to (start + 2, 10)
- Code(Expression(8, Add)) at (prev + 2, 9) to (start + 0, 10)
= (c3 + c5)
- Code(Expression(9, Sub)) at (prev + 1, 12) to (start + 2, 6)
= (c0 - (c1 + c2))
- Code(Expression(11, Sub)) at (prev + 3, 1) to (start + 0, 2)
= ((((c0 + c3) + c4) + c5) - (c1 + c2))
Highest counter ID seen: c5

13
tests/coverage/mcdc/inlined_expressions.cov-map
View File

@ -1,11 +1,12 @@
Function name: inlined_expressions::inlined_instance
Raw bytes (52): 0x[01, 01, 03, 01, 05, 0b, 02, 09, 0d, 06, 01, 08, 01, 01, 06, 28, 03, 02, 01, 05, 00, 0b, 30, 05, 02, 01, 02, 00, 00, 05, 00, 06, 05, 00, 0a, 00, 0b, 30, 09, 0d, 02, 00, 00, 00, 0a, 00, 0b, 07, 01, 01, 00, 02]
Raw bytes (54): 0x[01, 01, 04, 01, 05, 0b, 05, 0f, 0d, 01, 09, 06, 01, 08, 01, 01, 06, 28, 03, 02, 01, 05, 00, 0b, 30, 05, 02, 01, 02, 00, 00, 05, 00, 06, 05, 00, 0a, 00, 0b, 30, 09, 0d, 02, 00, 00, 00, 0a, 00, 0b, 06, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 8, 1) to (start + 1, 6)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 5) to (start + 0, 11)
@ -16,7 +17,7 @@ Number of file 0 mappings: 6
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 10) to (start + 0, 11)
true = c2
false = c3
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(1, Sub)) at (prev + 1, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3

268
tests/coverage/mcdc/nested_if.cov-map
View File

@ -1,205 +1,213 @@
Function name: nested_if::doubly_nested_if_in_condition
Raw bytes (168): 0x[01, 01, 0e, 01, 05, 05, 11, 05, 11, 26, 19, 05, 11, 19, 1d, 19, 1d, 1d, 22, 26, 19, 05, 11, 11, 15, 09, 02, 0d, 37, 09, 02, 14, 01, 0f, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 4e, 05, 00, 10, 00, 11, 28, 06, 02, 00, 10, 00, 36, 30, 11, 26, 01, 00, 02, 00, 10, 00, 11, 30, 15, 21, 02, 00, 00, 00, 15, 00, 36, 26, 00, 18, 00, 19, 28, 03, 02, 00, 18, 00, 1e, 30, 19, 22, 01, 02, 00, 00, 18, 00, 19, 19, 00, 1d, 00, 1e, 30, 1a, 1d, 02, 00, 00, 00, 1d, 00, 1e, 1a, 00, 21, 00, 25, 1f, 00, 2f, 00, 34, 2b, 00, 39, 00, 3e, 21, 00, 48, 00, 4c, 0d, 00, 4f, 02, 06, 37, 02, 0c, 02, 06, 33, 03, 01, 00, 02]
Raw bytes (172): 0x[01, 01, 10, 01, 05, 05, 09, 05, 09, 05, 27, 09, 19, 19, 1d, 19, 1d, 23, 27, 05, 1d, 09, 19, 09, 0d, 33, 05, 01, 15, 3b, 05, 3f, 15, 01, 11, 14, 01, 0f, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 4e, 05, 00, 10, 00, 11, 28, 06, 02, 00, 10, 00, 36, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 30, 0d, 21, 02, 00, 00, 00, 15, 00, 36, 0a, 00, 18, 00, 19, 28, 03, 02, 00, 18, 00, 1e, 30, 19, 0e, 01, 02, 00, 00, 18, 00, 19, 19, 00, 1d, 00, 1e, 30, 1a, 1d, 02, 00, 00, 00, 1d, 00, 1e, 1a, 00, 21, 00, 25, 1e, 00, 2f, 00, 34, 2b, 00, 39, 00, 3e, 21, 00, 48, 00, 4c, 11, 00, 4f, 02, 06, 2e, 02, 0c, 02, 06, 36, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 14
Number of expressions: 16
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(4)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Expression(9, Sub), rhs = Counter(6)
- expression 4 operands: lhs = Counter(1), rhs = Counter(4)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Expression(9, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(6)
- expression 5 operands: lhs = Counter(6), rhs = Counter(7)
- expression 6 operands: lhs = Counter(6), rhs = Counter(7)
- expression 7 operands: lhs = Counter(7), rhs = Expression(8, Sub)
- expression 8 operands: lhs = Expression(9, Sub), rhs = Counter(6)
- expression 9 operands: lhs = Counter(1), rhs = Counter(4)
- expression 10 operands: lhs = Counter(4), rhs = Counter(5)
- expression 11 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 12 operands: lhs = Counter(3), rhs = Expression(13, Add)
- expression 13 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 7 operands: lhs = Expression(8, Add), rhs = Expression(9, Add)
- expression 8 operands: lhs = Counter(1), rhs = Counter(7)
- expression 9 operands: lhs = Counter(2), rhs = Counter(6)
- expression 10 operands: lhs = Counter(2), rhs = Counter(3)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(1)
- expression 12 operands: lhs = Counter(0), rhs = Counter(5)
- expression 13 operands: lhs = Expression(14, Add), rhs = Counter(1)
- expression 14 operands: lhs = Expression(15, Add), rhs = Counter(5)
- expression 15 operands: lhs = Counter(0), rhs = Counter(4)
Number of file 0 mappings: 20
- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 9, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 78)
- MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
true = c1
false = (c0 - c1)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 78)
true = c3
false = c2
- MCDCBranch { true: Counter(4), false: Counter(5), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 78)
true = c4
false = c5
- Code(Counter(1)) at (prev + 0, 16) to (start + 0, 17)
- MCDCDecision { bitmap_idx: 6, conditions_num: 2 } at (prev + 0, 16) to (start + 0, 54)
- MCDCBranch { true: Counter(4), false: Expression(9, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c4
false = (c1 - c4)
- MCDCBranch { true: Counter(5), false: Counter(8), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 54)
true = c5
- MCDCBranch { true: Counter(2), false: Expression(2, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c2
false = (c1 - c2)
- MCDCBranch { true: Counter(3), false: Counter(8), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 54)
true = c3
false = c8
- Code(Expression(9, Sub)) at (prev + 0, 24) to (start + 0, 25)
= (c1 - c4)
- Code(Expression(2, Sub)) at (prev + 0, 24) to (start + 0, 25)
= (c1 - c2)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 24) to (start + 0, 30)
- MCDCBranch { true: Counter(6), false: Expression(8, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 24) to (start + 0, 25)
- MCDCBranch { true: Counter(6), false: Expression(3, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 24) to (start + 0, 25)
true = c6
false = ((c1 - c4) - c6)
false = (c1 - (c2 + c6))
- Code(Counter(6)) at (prev + 0, 29) to (start + 0, 30)
- MCDCBranch { true: Expression(6, Sub), false: Counter(7), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 29) to (start + 0, 30)
true = (c6 - c7)
false = c7
- Code(Expression(6, Sub)) at (prev + 0, 33) to (start + 0, 37)
= (c6 - c7)
- Code(Expression(7, Add)) at (prev + 0, 47) to (start + 0, 52)
= (c7 + ((c1 - c4) - c6))
- Code(Expression(7, Sub)) at (prev + 0, 47) to (start + 0, 52)
= ((c1 + c7) - (c2 + c6))
- Code(Expression(10, Add)) at (prev + 0, 57) to (start + 0, 62)
= (c4 + c5)
= (c2 + c3)
- Code(Counter(8)) at (prev + 0, 72) to (start + 0, 76)
- Code(Counter(3)) at (prev + 0, 79) to (start + 2, 6)
- Code(Expression(13, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(12, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- Code(Counter(4)) at (prev + 0, 79) to (start + 2, 6)
- Code(Expression(11, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c5) - c1)
- Code(Expression(13, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c4) + c5) - c1)
Highest counter ID seen: c8
Function name: nested_if::nested_if_in_condition
Raw bytes (120): 0x[01, 01, 0b, 01, 05, 05, 11, 05, 11, 1e, 15, 05, 11, 11, 15, 1e, 15, 05, 11, 09, 02, 0d, 2b, 09, 02, 0e, 01, 07, 01, 01, 09, 28, 06, 02, 01, 08, 00, 2e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 2e, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 11, 1e, 01, 00, 02, 00, 10, 00, 11, 1e, 00, 15, 00, 16, 30, 15, 1a, 02, 00, 00, 00, 15, 00, 16, 17, 00, 19, 00, 1d, 1a, 00, 27, 00, 2c, 0d, 00, 2f, 02, 06, 2b, 02, 0c, 02, 06, 27, 03, 01, 00, 02]
Raw bytes (124): 0x[01, 01, 0d, 01, 05, 05, 09, 05, 09, 05, 1f, 09, 0d, 09, 0d, 05, 1f, 09, 0d, 27, 05, 01, 15, 2f, 05, 33, 15, 01, 11, 0e, 01, 07, 01, 01, 09, 28, 06, 02, 01, 08, 00, 2e, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 11, 15, 02, 00, 00, 00, 0d, 00, 2e, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 1a, 02, 00, 00, 00, 15, 00, 16, 1f, 00, 19, 00, 1d, 1a, 00, 27, 00, 2c, 11, 00, 2f, 02, 06, 22, 02, 0c, 02, 06, 2a, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 11
Number of expressions: 13
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(4)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Expression(7, Sub), rhs = Counter(5)
- expression 4 operands: lhs = Counter(1), rhs = Counter(4)
- expression 5 operands: lhs = Counter(4), rhs = Counter(5)
- expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(5)
- expression 7 operands: lhs = Counter(1), rhs = Counter(4)
- expression 8 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 9 operands: lhs = Counter(3), rhs = Expression(10, Add)
- expression 10 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 5 operands: lhs = Counter(2), rhs = Counter(3)
- expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(1)
- expression 9 operands: lhs = Counter(0), rhs = Counter(5)
- expression 10 operands: lhs = Expression(11, Add), rhs = Counter(1)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(5)
- expression 12 operands: lhs = Counter(0), rhs = Counter(4)
Number of file 0 mappings: 14
- Code(Counter(0)) at (prev + 7, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 6, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 46)
- MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
true = c1
false = (c0 - c1)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 46)
true = c3
false = c2
- MCDCBranch { true: Counter(4), false: Counter(5), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 46)
true = c4
false = c5
- Code(Counter(1)) at (prev + 0, 16) to (start + 0, 17)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 16) to (start + 0, 22)
- MCDCBranch { true: Counter(4), false: Expression(7, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c4
false = (c1 - c4)
- Code(Expression(7, Sub)) at (prev + 0, 21) to (start + 0, 22)
= (c1 - c4)
- MCDCBranch { true: Counter(5), false: Expression(6, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 22)
true = c5
false = ((c1 - c4) - c5)
- Code(Expression(5, Add)) at (prev + 0, 25) to (start + 0, 29)
= (c4 + c5)
- MCDCBranch { true: Counter(2), false: Expression(2, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c2
false = (c1 - c2)
- Code(Expression(2, Sub)) at (prev + 0, 21) to (start + 0, 22)
= (c1 - c2)
- MCDCBranch { true: Counter(3), false: Expression(6, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 22)
true = c3
false = (c1 - (c2 + c3))
- Code(Expression(7, Add)) at (prev + 0, 25) to (start + 0, 29)
= (c2 + c3)
- Code(Expression(6, Sub)) at (prev + 0, 39) to (start + 0, 44)
= ((c1 - c4) - c5)
- Code(Counter(3)) at (prev + 0, 47) to (start + 2, 6)
- Code(Expression(10, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(9, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
= (c1 - (c2 + c3))
- Code(Counter(4)) at (prev + 0, 47) to (start + 2, 6)
- Code(Expression(8, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c5) - c1)
- Code(Expression(10, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c4) + c5) - c1)
Highest counter ID seen: c5
Function name: nested_if::nested_in_then_block_in_condition
Raw bytes (176): 0x[01, 01, 12, 01, 05, 05, 11, 05, 11, 3a, 15, 05, 11, 11, 15, 33, 19, 11, 15, 19, 1d, 19, 1d, 1d, 2e, 33, 19, 11, 15, 3a, 15, 05, 11, 09, 02, 0d, 47, 09, 02, 14, 01, 22, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4b, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 4b, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 11, 3a, 01, 00, 02, 00, 10, 00, 11, 3a, 00, 15, 00, 16, 30, 15, 36, 02, 00, 00, 00, 15, 00, 16, 33, 00, 1c, 00, 1d, 28, 06, 02, 00, 1c, 00, 22, 30, 19, 2e, 01, 02, 00, 00, 1c, 00, 1d, 19, 00, 21, 00, 22, 30, 26, 1d, 02, 00, 00, 00, 21, 00, 22, 26, 00, 25, 00, 29, 2b, 00, 33, 00, 38, 36, 00, 44, 00, 49, 0d, 00, 4c, 02, 06, 47, 02, 0c, 02, 06, 43, 03, 01, 00, 02]
Raw bytes (180): 0x[01, 01, 14, 01, 05, 05, 09, 05, 09, 05, 3b, 09, 0d, 09, 0d, 3b, 11, 09, 0d, 11, 15, 11, 15, 2f, 11, 3b, 15, 09, 0d, 05, 3b, 09, 0d, 43, 05, 01, 1d, 4b, 05, 4f, 1d, 01, 19, 14, 01, 22, 01, 01, 09, 28, 09, 02, 01, 08, 00, 4b, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 19, 1d, 02, 00, 00, 00, 0d, 00, 4b, 05, 00, 10, 00, 11, 28, 03, 02, 00, 10, 00, 16, 30, 09, 0a, 01, 00, 02, 00, 10, 00, 11, 0a, 00, 15, 00, 16, 30, 0d, 36, 02, 00, 00, 00, 15, 00, 16, 3b, 00, 1c, 00, 1d, 28, 06, 02, 00, 1c, 00, 22, 30, 11, 1a, 01, 02, 00, 00, 1c, 00, 1d, 11, 00, 21, 00, 22, 30, 26, 15, 02, 00, 00, 00, 21, 00, 22, 26, 00, 25, 00, 29, 2a, 00, 33, 00, 38, 36, 00, 44, 00, 49, 19, 00, 4c, 02, 06, 3e, 02, 0c, 02, 06, 46, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 18
Number of expressions: 20
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(4)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Expression(14, Sub), rhs = Counter(5)
- expression 4 operands: lhs = Counter(1), rhs = Counter(4)
- expression 5 operands: lhs = Counter(4), rhs = Counter(5)
- expression 6 operands: lhs = Expression(12, Add), rhs = Counter(6)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5)
- expression 8 operands: lhs = Counter(6), rhs = Counter(7)
- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
- expression 10 operands: lhs = Counter(7), rhs = Expression(11, Sub)
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(6)
- expression 12 operands: lhs = Counter(4), rhs = Counter(5)
- expression 13 operands: lhs = Expression(14, Sub), rhs = Counter(5)
- expression 14 operands: lhs = Counter(1), rhs = Counter(4)
- expression 15 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 16 operands: lhs = Counter(3), rhs = Expression(17, Add)
- expression 17 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Expression(14, Add)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 5 operands: lhs = Counter(2), rhs = Counter(3)
- expression 6 operands: lhs = Expression(14, Add), rhs = Counter(4)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 8 operands: lhs = Counter(4), rhs = Counter(5)
- expression 9 operands: lhs = Counter(4), rhs = Counter(5)
- expression 10 operands: lhs = Expression(11, Add), rhs = Counter(4)
- expression 11 operands: lhs = Expression(14, Add), rhs = Counter(5)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
- expression 13 operands: lhs = Counter(1), rhs = Expression(14, Add)
- expression 14 operands: lhs = Counter(2), rhs = Counter(3)
- expression 15 operands: lhs = Expression(16, Add), rhs = Counter(1)
- expression 16 operands: lhs = Counter(0), rhs = Counter(7)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(1)
- expression 18 operands: lhs = Expression(19, Add), rhs = Counter(7)
- expression 19 operands: lhs = Counter(0), rhs = Counter(6)
Number of file 0 mappings: 20
- Code(Counter(0)) at (prev + 34, 1) to (start + 1, 9)
- MCDCDecision { bitmap_idx: 9, conditions_num: 2 } at (prev + 1, 8) to (start + 0, 75)
- MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
true = c1
false = (c0 - c1)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 75)
true = c3
false = c2
- MCDCBranch { true: Counter(6), false: Counter(7), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 75)
true = c6
false = c7
- Code(Counter(1)) at (prev + 0, 16) to (start + 0, 17)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 16) to (start + 0, 22)
- MCDCBranch { true: Counter(4), false: Expression(14, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c4
false = (c1 - c4)
- Code(Expression(14, Sub)) at (prev + 0, 21) to (start + 0, 22)
= (c1 - c4)
- MCDCBranch { true: Counter(5), false: Expression(13, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 22)
true = c5
false = ((c1 - c4) - c5)
- Code(Expression(12, Add)) at (prev + 0, 28) to (start + 0, 29)
= (c4 + c5)
- MCDCBranch { true: Counter(2), false: Expression(2, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 16) to (start + 0, 17)
true = c2
false = (c1 - c2)
- Code(Expression(2, Sub)) at (prev + 0, 21) to (start + 0, 22)
= (c1 - c2)
- MCDCBranch { true: Counter(3), false: Expression(13, Sub), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 21) to (start + 0, 22)
true = c3
false = (c1 - (c2 + c3))
- Code(Expression(14, Add)) at (prev + 0, 28) to (start + 0, 29)
= (c2 + c3)
- MCDCDecision { bitmap_idx: 6, conditions_num: 2 } at (prev + 0, 28) to (start + 0, 34)
- MCDCBranch { true: Counter(6), false: Expression(11, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 28) to (start + 0, 29)
true = c6
false = ((c4 + c5) - c6)
- Code(Counter(6)) at (prev + 0, 33) to (start + 0, 34)
- MCDCBranch { true: Expression(9, Sub), false: Counter(7), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 33) to (start + 0, 34)
true = (c6 - c7)
false = c7
- MCDCBranch { true: Counter(4), false: Expression(6, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 28) to (start + 0, 29)
true = c4
false = ((c2 + c3) - c4)
- Code(Counter(4)) at (prev + 0, 33) to (start + 0, 34)
- MCDCBranch { true: Expression(9, Sub), false: Counter(5), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 33) to (start + 0, 34)
true = (c4 - c5)
false = c5
- Code(Expression(9, Sub)) at (prev + 0, 37) to (start + 0, 41)
= (c6 - c7)
- Code(Expression(10, Add)) at (prev + 0, 51) to (start + 0, 56)
= (c7 + ((c4 + c5) - c6))
= (c4 - c5)
- Code(Expression(10, Sub)) at (prev + 0, 51) to (start + 0, 56)
= (((c2 + c3) + c5) - c4)
- Code(Expression(13, Sub)) at (prev + 0, 68) to (start + 0, 73)
= ((c1 - c4) - c5)
- Code(Counter(3)) at (prev + 0, 76) to (start + 2, 6)
- Code(Expression(17, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(16, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
= (c1 - (c2 + c3))
- Code(Counter(6)) at (prev + 0, 76) to (start + 2, 6)
- Code(Expression(15, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c7) - c1)
- Code(Expression(17, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c6) + c7) - c1)
Highest counter ID seen: c7
Function name: nested_if::nested_single_condition_decision
Raw bytes (85): 0x[01, 01, 06, 01, 05, 05, 11, 05, 11, 09, 02, 0d, 17, 09, 02, 0b, 01, 17, 01, 04, 09, 28, 03, 02, 04, 08, 00, 29, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 09, 02, 00, 00, 00, 0d, 00, 29, 05, 00, 10, 00, 11, 20, 11, 0a, 00, 10, 00, 11, 11, 00, 14, 00, 19, 0a, 00, 23, 00, 27, 0d, 00, 2a, 02, 06, 17, 02, 0c, 02, 06, 13, 03, 01, 00, 02]
Raw bytes (89): 0x[01, 01, 08, 01, 05, 05, 09, 05, 09, 13, 05, 01, 11, 1b, 05, 1f, 11, 01, 0d, 0b, 01, 17, 01, 04, 09, 28, 03, 02, 04, 08, 00, 29, 30, 05, 02, 01, 02, 00, 00, 08, 00, 09, 30, 0d, 11, 02, 00, 00, 00, 0d, 00, 29, 05, 00, 10, 00, 11, 20, 09, 0a, 00, 10, 00, 11, 09, 00, 14, 00, 19, 0a, 00, 23, 00, 27, 0d, 00, 2a, 02, 06, 0e, 02, 0c, 02, 06, 16, 03, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 6
Number of expressions: 8
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(4)
- expression 2 operands: lhs = Counter(1), rhs = Counter(4)
- expression 3 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 4 operands: lhs = Counter(3), rhs = Expression(5, Add)
- expression 5 operands: lhs = Counter(2), rhs = Expression(0, Sub)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(1)
- expression 4 operands: lhs = Counter(0), rhs = Counter(4)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(1)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4)
- expression 7 operands: lhs = Counter(0), rhs = Counter(3)
Number of file 0 mappings: 11
- Code(Counter(0)) at (prev + 23, 1) to (start + 4, 9)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 4, 8) to (start + 0, 41)
- MCDCBranch { true: Counter(1), false: Expression(0, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 8) to (start + 0, 9)
true = c1
false = (c0 - c1)
- MCDCBranch { true: Counter(3), false: Counter(2), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 41)
- MCDCBranch { true: Counter(3), false: Counter(4), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 41)
true = c3
false = c2
false = c4
- Code(Counter(1)) at (prev + 0, 16) to (start + 0, 17)
- Branch { true: Counter(4), false: Expression(2, Sub) } at (prev + 0, 16) to (start + 0, 17)
true = c4
false = (c1 - c4)
- Code(Counter(4)) at (prev + 0, 20) to (start + 0, 25)
- Branch { true: Counter(2), false: Expression(2, Sub) } at (prev + 0, 16) to (start + 0, 17)
true = c2
false = (c1 - c2)
- Code(Counter(2)) at (prev + 0, 20) to (start + 0, 25)
- Code(Expression(2, Sub)) at (prev + 0, 35) to (start + 0, 39)
= (c1 - c4)
= (c1 - c2)
- Code(Counter(3)) at (prev + 0, 42) to (start + 2, 6)
- Code(Expression(5, Add)) at (prev + 2, 12) to (start + 2, 6)
= (c2 + (c0 - c1))
- Code(Expression(4, Add)) at (prev + 3, 1) to (start + 0, 2)
= (c3 + (c2 + (c0 - c1)))
- Code(Expression(3, Sub)) at (prev + 2, 12) to (start + 2, 6)
= ((c0 + c4) - c1)
- Code(Expression(5, Sub)) at (prev + 3, 1) to (start + 0, 2)
= (((c0 + c3) + c4) - c1)
Highest counter ID seen: c4

143
tests/coverage/mcdc/non_control_flow.cov-map
View File

@ -1,67 +1,65 @@
Function name: non_control_flow::assign_3
Raw bytes (89): 0x[01, 01, 09, 05, 07, 0b, 11, 09, 0d, 01, 05, 01, 05, 22, 11, 01, 05, 22, 11, 01, 05, 0a, 01, 16, 01, 00, 28, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 04, 03, 00, 0d, 00, 18, 30, 05, 22, 01, 00, 02, 00, 0d, 00, 0e, 22, 00, 12, 00, 13, 30, 1e, 11, 02, 03, 00, 00, 12, 00, 13, 1e, 00, 17, 00, 18, 30, 09, 0d, 03, 00, 00, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Raw bytes (89): 0x[01, 01, 09, 07, 11, 0b, 0d, 05, 09, 01, 05, 01, 05, 01, 23, 05, 11, 01, 23, 05, 11, 0a, 01, 16, 01, 00, 28, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 04, 03, 00, 0d, 00, 18, 30, 05, 12, 01, 00, 02, 00, 0d, 00, 0e, 12, 00, 12, 00, 13, 30, 1e, 11, 02, 03, 00, 00, 12, 00, 13, 1e, 00, 17, 00, 18, 30, 09, 0d, 03, 00, 00, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 9
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(4)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Counter(0), rhs = Counter(1)
- expression 5 operands: lhs = Expression(8, Sub), rhs = Counter(4)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 7 operands: lhs = Expression(8, Sub), rhs = Counter(4)
- expression 8 operands: lhs = Counter(0), rhs = Counter(1)
- expression 5 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 6 operands: lhs = Counter(1), rhs = Counter(4)
- expression 7 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 8 operands: lhs = Counter(1), rhs = Counter(4)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 22, 1) to (start + 0, 40)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= (c1 + ((c2 + c3) + c4))
= (((c1 + c2) + c3) + c4)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- MCDCDecision { bitmap_idx: 4, conditions_num: 3 } at (prev + 0, 13) to (start + 0, 24)
- MCDCBranch { true: Counter(1), false: Expression(8, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(1), false: Expression(4, Sub), condition_id: 1, true_next_id: 0, false_next_id: 2 } at (prev + 0, 13) to (start + 0, 14)
true = c1
false = (c0 - c1)
- Code(Expression(8, Sub)) at (prev + 0, 18) to (start + 0, 19)
- Code(Expression(4, Sub)) at (prev + 0, 18) to (start + 0, 19)
= (c0 - c1)
- MCDCBranch { true: Expression(7, Sub), false: Counter(4), condition_id: 2, true_next_id: 3, false_next_id: 0 } at (prev + 0, 18) to (start + 0, 19)
true = ((c0 - c1) - c4)
true = (c0 - (c1 + c4))
false = c4
- Code(Expression(7, Sub)) at (prev + 0, 23) to (start + 0, 24)
= ((c0 - c1) - c4)
= (c0 - (c1 + c4))
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 3, true_next_id: 0, false_next_id: 0 } at (prev + 0, 23) to (start + 0, 24)
true = c2
false = c3
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
= (c1 + ((c2 + c3) + c4))
= (((c1 + c2) + c3) + c4)
Highest counter ID seen: c4
Function name: non_control_flow::assign_3_bis
Raw bytes (85): 0x[01, 01, 07, 07, 11, 09, 0d, 01, 05, 05, 09, 16, 1a, 05, 09, 01, 05, 0a, 01, 1b, 01, 00, 2c, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 05, 03, 00, 0d, 00, 18, 30, 05, 1a, 01, 03, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 16, 03, 00, 02, 00, 12, 00, 13, 13, 00, 17, 00, 18, 30, 0d, 11, 02, 00, 00, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Raw bytes (81): 0x[01, 01, 05, 07, 11, 09, 0d, 01, 05, 05, 09, 01, 09, 0a, 01, 1b, 01, 00, 2c, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 05, 03, 00, 0d, 00, 18, 30, 05, 0a, 01, 03, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 0e, 03, 00, 02, 00, 12, 00, 13, 12, 00, 17, 00, 18, 30, 0d, 11, 02, 00, 00, 00, 17, 00, 18, 03, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 7
Number of expressions: 5
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(4)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Expression(6, Sub)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 44)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= ((c2 + c3) + c4)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- MCDCDecision { bitmap_idx: 5, conditions_num: 3 } at (prev + 0, 13) to (start + 0, 24)
- MCDCBranch { true: Counter(1), false: Expression(6, Sub), condition_id: 1, true_next_id: 3, false_next_id: 2 } at (prev + 0, 13) to (start + 0, 14)
- MCDCBranch { true: Counter(1), false: Expression(2, Sub), condition_id: 1, true_next_id: 3, false_next_id: 2 } at (prev + 0, 13) to (start + 0, 14)
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
- MCDCBranch { true: Counter(2), false: Expression(5, Sub), condition_id: 3, true_next_id: 0, false_next_id: 2 } at (prev + 0, 18) to (start + 0, 19)
- MCDCBranch { true: Counter(2), false: Expression(3, Sub), condition_id: 3, true_next_id: 0, false_next_id: 2 } at (prev + 0, 18) to (start + 0, 19)
true = c2
false = (c1 - c2)
- Code(Expression(4, Add)) at (prev + 0, 23) to (start + 0, 24)
= ((c1 - c2) + (c0 - c1))
- Code(Expression(4, Sub)) at (prev + 0, 23) to (start + 0, 24)
= (c0 - c2)
- MCDCBranch { true: Counter(3), false: Counter(4), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 23) to (start + 0, 24)
true = c3
false = c4
@ -70,18 +68,18 @@ Number of file 0 mappings: 10
Highest counter ID seen: c4
Function name: non_control_flow::assign_and
Raw bytes (64): 0x[01, 01, 04, 07, 0e, 09, 0d, 01, 05, 01, 05, 08, 01, 0c, 01, 00, 21, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 0e, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 0d, 02, 00, 00, 00, 12, 00, 13, 03, 01, 05, 01, 02]
Raw bytes (64): 0x[01, 01, 04, 07, 05, 0b, 0d, 01, 09, 01, 05, 08, 01, 0c, 01, 00, 21, 02, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 03, 02, 00, 0d, 00, 13, 30, 05, 0e, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 30, 09, 0d, 02, 00, 00, 00, 12, 00, 13, 02, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
- expression 0 operands: lhs = Expression(1, Add), rhs = Expression(3, Sub)
- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 8
- Code(Counter(0)) at (prev + 12, 1) to (start + 0, 33)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 10)
= (((c0 + c2) + c3) - c1)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 0, 13) to (start + 0, 19)
- MCDCBranch { true: Counter(1), false: Expression(3, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
@ -91,8 +89,8 @@ Number of file 0 mappings: 8
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 18) to (start + 0, 19)
true = c2
false = c3
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 1, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: non_control_flow::assign_or
@ -132,13 +130,14 @@ Number of file 0 mappings: 1
Highest counter ID seen: c0
Function name: non_control_flow::func_call
Raw bytes (52): 0x[01, 01, 03, 01, 05, 0b, 02, 09, 0d, 06, 01, 29, 01, 01, 0a, 28, 03, 02, 01, 09, 00, 0f, 30, 05, 02, 01, 02, 00, 00, 09, 00, 0a, 05, 00, 0e, 00, 0f, 30, 09, 0d, 02, 00, 00, 00, 0e, 00, 0f, 07, 01, 01, 00, 02]
Raw bytes (54): 0x[01, 01, 04, 01, 05, 0b, 05, 0f, 0d, 01, 09, 06, 01, 29, 01, 01, 0a, 28, 03, 02, 01, 09, 00, 0f, 30, 05, 02, 01, 02, 00, 00, 09, 00, 0a, 05, 00, 0e, 00, 0f, 30, 09, 0d, 02, 00, 00, 00, 0e, 00, 0f, 06, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 3
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Expression(0, Sub)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(1)
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 41, 1) to (start + 1, 10)
- MCDCDecision { bitmap_idx: 3, conditions_num: 2 } at (prev + 1, 9) to (start + 0, 15)
@ -149,63 +148,63 @@ Number of file 0 mappings: 6
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 2, true_next_id: 0, false_next_id: 0 } at (prev + 0, 14) to (start + 0, 15)
true = c2
false = c3
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c2 + c3) + (c0 - c1))
- Code(Expression(1, Sub)) at (prev + 1, 1) to (start + 0, 2)
= (((c0 + c2) + c3) - c1)
Highest counter ID seen: c3
Function name: non_control_flow::right_comb_tree
Raw bytes (139): 0x[01, 01, 13, 07, 1a, 0b, 19, 0f, 15, 13, 11, 09, 0d, 01, 05, 01, 05, 05, 19, 05, 19, 4a, 15, 05, 19, 4a, 15, 05, 19, 46, 11, 4a, 15, 05, 19, 46, 11, 4a, 15, 05, 19, 0e, 01, 20, 01, 00, 41, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 06, 05, 00, 0d, 00, 2a, 30, 05, 1a, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 13, 00, 14, 30, 4a, 19, 02, 03, 00, 00, 13, 00, 14, 4a, 00, 19, 00, 1a, 30, 46, 15, 03, 04, 00, 00, 19, 00, 1a, 46, 00, 1f, 00, 20, 30, 42, 11, 04, 05, 00, 00, 1f, 00, 20, 42, 00, 24, 00, 27, 30, 09, 0d, 05, 00, 00, 00, 24, 00, 27, 03, 01, 05, 01, 02]
Raw bytes (139): 0x[01, 01, 13, 07, 05, 0b, 19, 0f, 15, 13, 11, 17, 0d, 01, 09, 01, 05, 05, 09, 05, 09, 05, 4b, 09, 0d, 05, 4b, 09, 0d, 05, 47, 4b, 11, 09, 0d, 05, 47, 4b, 11, 09, 0d, 0e, 01, 20, 01, 00, 41, 02, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 28, 06, 05, 00, 0d, 00, 2a, 30, 05, 1a, 01, 02, 00, 00, 0d, 00, 0e, 05, 00, 13, 00, 14, 30, 22, 09, 02, 03, 00, 00, 13, 00, 14, 22, 00, 19, 00, 1a, 30, 2e, 0d, 03, 04, 00, 00, 19, 00, 1a, 2e, 00, 1f, 00, 20, 30, 42, 11, 04, 05, 00, 00, 1f, 00, 20, 42, 00, 24, 00, 27, 30, 15, 19, 05, 00, 00, 00, 24, 00, 27, 02, 01, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 19
- expression 0 operands: lhs = Expression(1, Add), rhs = Expression(6, Sub)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(1)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(6)
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(5)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(4)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(1)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
- expression 7 operands: lhs = Counter(1), rhs = Counter(6)
- expression 8 operands: lhs = Counter(1), rhs = Counter(6)
- expression 9 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 10 operands: lhs = Counter(1), rhs = Counter(6)
- expression 11 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 12 operands: lhs = Counter(1), rhs = Counter(6)
- expression 13 operands: lhs = Expression(17, Sub), rhs = Counter(4)
- expression 14 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 15 operands: lhs = Counter(1), rhs = Counter(6)
- expression 16 operands: lhs = Expression(17, Sub), rhs = Counter(4)
- expression 17 operands: lhs = Expression(18, Sub), rhs = Counter(5)
- expression 18 operands: lhs = Counter(1), rhs = Counter(6)
- expression 7 operands: lhs = Counter(1), rhs = Counter(2)
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
- expression 9 operands: lhs = Counter(1), rhs = Expression(18, Add)
- expression 10 operands: lhs = Counter(2), rhs = Counter(3)
- expression 11 operands: lhs = Counter(1), rhs = Expression(18, Add)
- expression 12 operands: lhs = Counter(2), rhs = Counter(3)
- expression 13 operands: lhs = Counter(1), rhs = Expression(17, Add)
- expression 14 operands: lhs = Expression(18, Add), rhs = Counter(4)
- expression 15 operands: lhs = Counter(2), rhs = Counter(3)
- expression 16 operands: lhs = Counter(1), rhs = Expression(17, Add)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(4)
- expression 18 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 14
- Code(Counter(0)) at (prev + 32, 1) to (start + 0, 65)
- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
= (((((c2 + c3) + c4) + c5) + c6) + (c0 - c1))
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 10)
= ((((((c0 + c2) + c3) + c4) + c5) + c6) - c1)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- MCDCDecision { bitmap_idx: 6, conditions_num: 5 } at (prev + 0, 13) to (start + 0, 42)
- MCDCBranch { true: Counter(1), false: Expression(6, Sub), condition_id: 1, true_next_id: 2, false_next_id: 0 } at (prev + 0, 13) to (start + 0, 14)
true = c1
false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 19) to (start + 0, 20)
- MCDCBranch { true: Expression(18, Sub), false: Counter(6), condition_id: 2, true_next_id: 3, false_next_id: 0 } at (prev + 0, 19) to (start + 0, 20)
true = (c1 - c6)
false = c6
- Code(Expression(18, Sub)) at (prev + 0, 25) to (start + 0, 26)
= (c1 - c6)
- MCDCBranch { true: Expression(17, Sub), false: Counter(5), condition_id: 3, true_next_id: 4, false_next_id: 0 } at (prev + 0, 25) to (start + 0, 26)
true = ((c1 - c6) - c5)
false = c5
- Code(Expression(17, Sub)) at (prev + 0, 31) to (start + 0, 32)
= ((c1 - c6) - c5)
- MCDCBranch { true: Expression(8, Sub), false: Counter(2), condition_id: 2, true_next_id: 3, false_next_id: 0 } at (prev + 0, 19) to (start + 0, 20)
true = (c1 - c2)
false = c2
- Code(Expression(8, Sub)) at (prev + 0, 25) to (start + 0, 26)
= (c1 - c2)
- MCDCBranch { true: Expression(11, Sub), false: Counter(3), condition_id: 3, true_next_id: 4, false_next_id: 0 } at (prev + 0, 25) to (start + 0, 26)
true = (c1 - (c2 + c3))
false = c3
- Code(Expression(11, Sub)) at (prev + 0, 31) to (start + 0, 32)
= (c1 - (c2 + c3))
- MCDCBranch { true: Expression(16, Sub), false: Counter(4), condition_id: 4, true_next_id: 5, false_next_id: 0 } at (prev + 0, 31) to (start + 0, 32)
true = (((c1 - c6) - c5) - c4)
true = (c1 - ((c2 + c3) + c4))
false = c4
- Code(Expression(16, Sub)) at (prev + 0, 36) to (start + 0, 39)
= (((c1 - c6) - c5) - c4)
- MCDCBranch { true: Counter(2), false: Counter(3), condition_id: 5, true_next_id: 0, false_next_id: 0 } at (prev + 0, 36) to (start + 0, 39)
true = c2
false = c3
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
= (((((c2 + c3) + c4) + c5) + c6) + (c0 - c1))
= (c1 - ((c2 + c3) + c4))
- MCDCBranch { true: Counter(5), false: Counter(6), condition_id: 5, true_next_id: 0, false_next_id: 0 } at (prev + 0, 36) to (start + 0, 39)
true = c5
false = c6
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 1, 2)
= ((((((c0 + c2) + c3) + c4) + c5) + c6) - c1)
Highest counter ID seen: c6

76
tests/coverage/nested_loops.cov-map
View File

@ -1,52 +1,46 @@
Function name: nested_loops::main
Raw bytes (115): 0x[01, 01, 17, 01, 57, 05, 09, 03, 0d, 4e, 53, 03, 0d, 15, 19, 4b, 09, 4e, 53, 03, 0d, 15, 19, 46, 05, 4b, 09, 4e, 53, 03, 0d, 15, 19, 42, 19, 46, 05, 4b, 09, 4e, 53, 03, 0d, 15, 19, 05, 09, 11, 0d, 0d, 01, 01, 01, 02, 1b, 03, 04, 13, 00, 20, 4e, 01, 0d, 01, 18, 4b, 02, 12, 00, 17, 46, 01, 10, 00, 16, 05, 01, 11, 00, 16, 42, 01, 0e, 03, 16, 3e, 04, 11, 01, 1b, 11, 02, 15, 00, 21, 15, 01, 18, 02, 12, 19, 03, 0d, 00, 0e, 57, 02, 09, 00, 17, 5b, 02, 01, 00, 02]
Raw bytes (103): 0x[01, 01, 11, 27, 09, 01, 05, 03, 0d, 13, 0d, 17, 15, 03, 11, 1f, 0d, 23, 15, 27, 11, 01, 05, 2f, 0d, 3b, 15, 01, 11, 3b, 0d, 01, 11, 05, 09, 0d, 19, 0d, 01, 01, 01, 02, 1b, 03, 04, 13, 00, 20, 0a, 01, 0d, 01, 18, 0e, 02, 12, 00, 17, 1a, 01, 10, 00, 16, 05, 01, 11, 00, 16, 2a, 01, 0e, 03, 16, 36, 04, 11, 01, 1b, 19, 02, 15, 00, 21, 11, 01, 18, 02, 12, 15, 03, 0d, 00, 0e, 3f, 02, 09, 00, 17, 43, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 23
- expression 0 operands: lhs = Counter(0), rhs = Expression(21, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
Number of expressions: 17
- expression 0 operands: lhs = Expression(9, Add), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Expression(19, Sub), rhs = Expression(20, Add)
- expression 4 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(5), rhs = Counter(6)
- expression 6 operands: lhs = Expression(18, Add), rhs = Counter(2)
- expression 7 operands: lhs = Expression(19, Sub), rhs = Expression(20, Add)
- expression 8 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 9 operands: lhs = Counter(5), rhs = Counter(6)
- expression 10 operands: lhs = Expression(17, Sub), rhs = Counter(1)
- expression 11 operands: lhs = Expression(18, Add), rhs = Counter(2)
- expression 12 operands: lhs = Expression(19, Sub), rhs = Expression(20, Add)
- expression 13 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 14 operands: lhs = Counter(5), rhs = Counter(6)
- expression 15 operands: lhs = Expression(16, Sub), rhs = Counter(6)
- expression 16 operands: lhs = Expression(17, Sub), rhs = Counter(1)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(2)
- expression 18 operands: lhs = Expression(19, Sub), rhs = Expression(20, Add)
- expression 19 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 20 operands: lhs = Counter(5), rhs = Counter(6)
- expression 21 operands: lhs = Counter(1), rhs = Counter(2)
- expression 22 operands: lhs = Counter(4), rhs = Counter(3)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(3)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(5)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(3)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(5)
- expression 8 operands: lhs = Expression(9, Add), rhs = Counter(4)
- expression 9 operands: lhs = Counter(0), rhs = Counter(1)
- expression 10 operands: lhs = Expression(11, Add), rhs = Counter(3)
- expression 11 operands: lhs = Expression(14, Add), rhs = Counter(5)
- expression 12 operands: lhs = Counter(0), rhs = Counter(4)
- expression 13 operands: lhs = Expression(14, Add), rhs = Counter(3)
- expression 14 operands: lhs = Counter(0), rhs = Counter(4)
- expression 15 operands: lhs = Counter(1), rhs = Counter(2)
- expression 16 operands: lhs = Counter(3), rhs = Counter(6)
Number of file 0 mappings: 13
- Code(Counter(0)) at (prev + 1, 1) to (start + 2, 27)
- Code(Expression(0, Add)) at (prev + 4, 19) to (start + 0, 32)
= (c0 + (c1 + c2))
- Code(Expression(19, Sub)) at (prev + 1, 13) to (start + 1, 24)
= ((c0 + (c1 + c2)) - c3)
- Code(Expression(18, Add)) at (prev + 2, 18) to (start + 0, 23)
= (((c0 + (c1 + c2)) - c3) + (c5 + c6))
- Code(Expression(17, Sub)) at (prev + 1, 16) to (start + 0, 22)
= ((((c0 + (c1 + c2)) - c3) + (c5 + c6)) - c2)
= ((c0 + c1) + c2)
- Code(Expression(2, Sub)) at (prev + 1, 13) to (start + 1, 24)
= (((c0 + c1) + c2) - c3)
- Code(Expression(3, Sub)) at (prev + 2, 18) to (start + 0, 23)
= (((((c0 + c1) + c2) + c4) + c5) - c3)
- Code(Expression(6, Sub)) at (prev + 1, 16) to (start + 0, 22)
= ((((c0 + c1) + c4) + c5) - c3)
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 22)
- Code(Expression(16, Sub)) at (prev + 1, 14) to (start + 3, 22)
= (((((c0 + (c1 + c2)) - c3) + (c5 + c6)) - c2) - c1)
- Code(Expression(15, Sub)) at (prev + 4, 17) to (start + 1, 27)
= ((((((c0 + (c1 + c2)) - c3) + (c5 + c6)) - c2) - c1) - c6)
- Code(Counter(4)) at (prev + 2, 21) to (start + 0, 33)
- Code(Counter(5)) at (prev + 1, 24) to (start + 2, 18)
- Code(Counter(6)) at (prev + 3, 13) to (start + 0, 14)
- Code(Expression(21, Add)) at (prev + 2, 9) to (start + 0, 23)
- Code(Expression(10, Sub)) at (prev + 1, 14) to (start + 3, 22)
= (((c0 + c4) + c5) - c3)
- Code(Expression(13, Sub)) at (prev + 4, 17) to (start + 1, 27)
= ((c0 + c4) - c3)
- Code(Counter(6)) at (prev + 2, 21) to (start + 0, 33)
- Code(Counter(4)) at (prev + 1, 24) to (start + 2, 18)
- Code(Counter(5)) at (prev + 3, 13) to (start + 0, 14)
- Code(Expression(15, Add)) at (prev + 2, 9) to (start + 0, 23)
= (c1 + c2)
- Code(Expression(22, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c4 + c3)
- Code(Expression(16, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c3 + c6)
Highest counter ID seen: c6

31
tests/coverage/overflow.cov-map
View File

@ -1,29 +1,30 @@
Function name: overflow::main
Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 10, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 09, 00, 0a, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Raw bytes (67): 0x[01, 01, 09, 07, 0d, 0b, 09, 01, 05, 03, 11, 17, 11, 1b, 0d, 01, 09, 23, 0d, 05, 09, 09, 01, 10, 01, 01, 1b, 03, 02, 0b, 00, 18, 0e, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 09, 00, 0a, 1f, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
- expression 0 operands: lhs = Counter(0), rhs = Expression(6, Add)
- expression 1 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
Number of expressions: 9
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Counter(1)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(3)
- expression 6 operands: lhs = Counter(0), rhs = Counter(2)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 16, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
= (c0 + (c1 + (c2 + c3)))
- Code(Expression(5, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((c0 + (c1 + (c2 + c3))) - c4)
= (((c0 + c1) + c2) + c3)
- Code(Expression(3, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((((c0 + c1) + c2) + c3) - c4)
- Code(Counter(1)) at (prev + 0, 27) to (start + 3, 10)
- Code(Expression(4, Sub)) at (prev + 3, 19) to (start + 0, 32)
= (((c0 + (c1 + (c2 + c3))) - c4) - c1)
= (((c0 + c2) + c3) - c4)
- Code(Counter(2)) at (prev + 0, 33) to (start + 3, 10)
- Code(Counter(3)) at (prev + 3, 9) to (start + 0, 10)
- Code(Expression(6, Add)) at (prev + 1, 9) to (start + 0, 23)
= (c1 + (c2 + c3))
- Code(Expression(7, Add)) at (prev + 1, 9) to (start + 0, 23)
= ((c1 + c2) + c3)
- Code(Counter(4)) at (prev + 2, 5) to (start + 1, 2)
Highest counter ID seen: c4

31
tests/coverage/panic_unwind.cov-map
View File

@ -1,29 +1,30 @@
Function name: panic_unwind::main
Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 0d, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 02, 0a, 12, 02, 13, 00, 20, 09, 00, 21, 02, 0a, 0d, 02, 09, 00, 0a, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Raw bytes (67): 0x[01, 01, 09, 07, 0d, 0b, 09, 01, 05, 03, 11, 17, 11, 1b, 0d, 01, 09, 23, 0d, 05, 09, 09, 01, 0d, 01, 01, 1b, 03, 02, 0b, 00, 18, 0e, 01, 0c, 00, 1a, 05, 00, 1b, 02, 0a, 12, 02, 13, 00, 20, 09, 00, 21, 02, 0a, 0d, 02, 09, 00, 0a, 1f, 01, 09, 00, 17, 11, 02, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 8
- expression 0 operands: lhs = Counter(0), rhs = Expression(6, Add)
- expression 1 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
Number of expressions: 9
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Counter(1)
- expression 5 operands: lhs = Expression(0, Add), rhs = Counter(4)
- expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
- expression 7 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(3)
- expression 6 operands: lhs = Counter(0), rhs = Counter(2)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 13, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
= (c0 + (c1 + (c2 + c3)))
- Code(Expression(5, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((c0 + (c1 + (c2 + c3))) - c4)
= (((c0 + c1) + c2) + c3)
- Code(Expression(3, Sub)) at (prev + 1, 12) to (start + 0, 26)
= ((((c0 + c1) + c2) + c3) - c4)
- Code(Counter(1)) at (prev + 0, 27) to (start + 2, 10)
- Code(Expression(4, Sub)) at (prev + 2, 19) to (start + 0, 32)
= (((c0 + (c1 + (c2 + c3))) - c4) - c1)
= (((c0 + c2) + c3) - c4)
- Code(Counter(2)) at (prev + 0, 33) to (start + 2, 10)
- Code(Counter(3)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(6, Add)) at (prev + 1, 9) to (start + 0, 23)
= (c1 + (c2 + c3))
- Code(Expression(7, Add)) at (prev + 1, 9) to (start + 0, 23)
= ((c1 + c2) + c3)
- Code(Counter(4)) at (prev + 2, 5) to (start + 1, 2)
Highest counter ID seen: c4

20
tests/coverage/simple_match.cov-map
View File

@ -1,29 +1,29 @@
Function name: simple_match::main
Raw bytes (72): 0x[01, 01, 09, 01, 05, 01, 23, 09, 0d, 1f, 11, 01, 23, 09, 0d, 1f, 11, 01, 23, 09, 0d, 0a, 01, 04, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 05, 00, 06, 1f, 05, 09, 00, 0d, 1a, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 1a, 02, 11, 02, 12, 09, 04, 0d, 07, 0e, 0d, 0a, 0d, 00, 0f, 11, 03, 01, 00, 02]
Raw bytes (72): 0x[01, 01, 09, 01, 05, 23, 0d, 01, 09, 1f, 11, 23, 0d, 01, 09, 1f, 11, 23, 0d, 01, 09, 0a, 01, 04, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 05, 00, 06, 1f, 05, 09, 00, 0d, 1a, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 1a, 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: 9
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 1 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
- expression 3 operands: lhs = Expression(7, Add), rhs = Counter(4)
- expression 4 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 5 operands: lhs = Counter(2), rhs = Counter(3)
- expression 4 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(4)
- expression 7 operands: lhs = Counter(0), rhs = Expression(8, Add)
- expression 8 operands: lhs = Counter(2), rhs = Counter(3)
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(3)
- expression 8 operands: lhs = Counter(0), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 4, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 2, 6)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 6)
= (c0 - c1)
- Code(Expression(7, Add)) at (prev + 5, 9) to (start + 0, 13)
= (c0 + (c2 + c3))
= ((c0 + c2) + c3)
- Code(Expression(6, Sub)) at (prev + 5, 13) to (start + 0, 22)
= ((c0 + (c2 + c3)) - c4)
= (((c0 + c2) + c3) - c4)
- Code(Counter(2)) at (prev + 2, 13) to (start + 0, 14)
- Code(Expression(6, Sub)) at (prev + 2, 17) to (start + 2, 18)
= ((c0 + (c2 + c3)) - c4)
= (((c0 + 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)

242
tests/coverage/try_error_result.cov-map
View File

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

24
tests/coverage/unicode.cov-map
View File

@ -1,14 +1,14 @@
Function name: unicode::main
Raw bytes (61): 0x[01, 01, 06, 01, 05, 16, 0d, 01, 09, 11, 13, 16, 0d, 01, 09, 09, 01, 0e, 01, 00, 0b, 05, 01, 09, 00, 0c, 03, 00, 10, 00, 1b, 05, 00, 1c, 00, 28, 01, 02, 08, 00, 25, 09, 00, 29, 00, 46, 11, 00, 47, 02, 06, 13, 02, 05, 00, 06, 0f, 02, 05, 01, 02]
Raw bytes (61): 0x[01, 01, 06, 01, 05, 0b, 09, 01, 11, 13, 09, 17, 11, 01, 0d, 09, 01, 0e, 01, 00, 0b, 05, 01, 09, 00, 0c, 03, 00, 10, 00, 1b, 05, 00, 1c, 00, 28, 01, 02, 08, 00, 25, 09, 00, 29, 00, 46, 0d, 00, 47, 02, 06, 06, 02, 05, 00, 06, 0e, 02, 05, 01, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 6
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(5, Sub), rhs = Counter(3)
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
- expression 3 operands: lhs = Counter(4), rhs = Expression(4, Add)
- expression 4 operands: lhs = Expression(5, Sub), rhs = Counter(3)
- expression 5 operands: lhs = Counter(0), rhs = Counter(2)
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(2)
- expression 2 operands: lhs = Counter(0), rhs = Counter(4)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
- expression 5 operands: lhs = Counter(0), rhs = Counter(3)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 14, 1) to (start + 0, 11)
- Code(Counter(1)) at (prev + 1, 9) to (start + 0, 12)
@ -17,12 +17,12 @@ Number of file 0 mappings: 9
- Code(Counter(1)) at (prev + 0, 28) to (start + 0, 40)
- Code(Counter(0)) at (prev + 2, 8) to (start + 0, 37)
- Code(Counter(2)) at (prev + 0, 41) to (start + 0, 70)
- Code(Counter(4)) at (prev + 0, 71) to (start + 2, 6)
- Code(Expression(4, Add)) at (prev + 2, 5) to (start + 0, 6)
= ((c0 - c2) + c3)
- Code(Expression(3, Add)) at (prev + 2, 5) to (start + 1, 2)
= (c4 + ((c0 - c2) + c3))
Highest counter ID seen: c4
- Code(Counter(3)) at (prev + 0, 71) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 5) to (start + 0, 6)
= ((c0 + c4) - c2)
- Code(Expression(3, Sub)) at (prev + 2, 5) to (start + 1, 2)
= (((c0 + c3) + c4) - c2)
Highest counter ID seen: c3
Function name: unicode::他 (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 1e, 19, 00, 25]

20
tests/coverage/unused.cov-map
View File

@ -1,18 +1,18 @@
Function name: unused::foo::<f32>
Raw bytes (42): 0x[01, 01, 04, 01, 0f, 05, 09, 03, 0d, 05, 09, 06, 01, 03, 01, 01, 12, 03, 02, 0b, 00, 11, 0a, 01, 09, 00, 0f, 09, 00, 13, 00, 19, 0f, 01, 09, 00, 0f, 0d, 02, 01, 00, 02]
Raw bytes (42): 0x[01, 01, 04, 07, 09, 01, 05, 03, 0d, 05, 09, 06, 01, 03, 01, 01, 12, 03, 02, 0b, 00, 11, 0a, 01, 09, 00, 0f, 09, 00, 13, 00, 19, 0f, 01, 09, 00, 0f, 0d, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Expression(3, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 3, 1) to (start + 1, 18)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 17)
= (c0 + (c1 + c2))
= ((c0 + c1) + c2)
- Code(Expression(2, Sub)) at (prev + 1, 9) to (start + 0, 15)
= ((c0 + (c1 + c2)) - c3)
= (((c0 + c1) + c2) - c3)
- Code(Counter(2)) at (prev + 0, 19) to (start + 0, 25)
- Code(Expression(3, Add)) at (prev + 1, 9) to (start + 0, 15)
= (c1 + c2)
@ -20,20 +20,20 @@ Number of file 0 mappings: 6
Highest counter ID seen: c3
Function name: unused::foo::<u32>
Raw bytes (42): 0x[01, 01, 04, 01, 0f, 05, 09, 03, 0d, 05, 09, 06, 01, 03, 01, 01, 12, 03, 02, 0b, 00, 11, 0a, 01, 09, 00, 0f, 09, 00, 13, 00, 19, 0f, 01, 09, 00, 0f, 0d, 02, 01, 00, 02]
Raw bytes (42): 0x[01, 01, 04, 07, 09, 01, 05, 03, 0d, 05, 09, 06, 01, 03, 01, 01, 12, 03, 02, 0b, 00, 11, 0a, 01, 09, 00, 0f, 09, 00, 13, 00, 19, 0f, 01, 09, 00, 0f, 0d, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 4
- expression 0 operands: lhs = Counter(0), rhs = Expression(3, Add)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(2)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 3, 1) to (start + 1, 18)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 17)
= (c0 + (c1 + c2))
= ((c0 + c1) + c2)
- Code(Expression(2, Sub)) at (prev + 1, 9) to (start + 0, 15)
= ((c0 + (c1 + c2)) - c3)
= (((c0 + c1) + c2) - c3)
- Code(Counter(2)) at (prev + 0, 19) to (start + 0, 25)
- Code(Expression(3, Add)) at (prev + 1, 9) to (start + 0, 15)
= (c1 + c2)

19
tests/coverage/while_early_ret.cov-map
View File

@ -1,27 +1,26 @@
Function name: while_early_ret::main
Raw bytes (61): 0x[01, 01, 06, 01, 05, 03, 09, 0e, 05, 03, 09, 17, 09, 0d, 11, 09, 01, 05, 01, 01, 1b, 03, 03, 09, 02, 0a, 0e, 05, 0d, 02, 0e, 0a, 06, 15, 02, 16, 0d, 04, 15, 00, 1b, 11, 04, 15, 00, 1b, 05, 03, 0a, 03, 0a, 09, 06, 05, 00, 0b, 13, 01, 01, 00, 02]
Raw bytes (59): 0x[01, 01, 05, 01, 05, 03, 09, 01, 09, 13, 11, 09, 0d, 09, 01, 05, 01, 01, 1b, 03, 03, 09, 02, 0a, 06, 05, 0d, 02, 0e, 0a, 06, 15, 02, 16, 0d, 04, 15, 00, 1b, 11, 04, 15, 00, 1b, 05, 03, 0a, 03, 0a, 09, 06, 05, 00, 0b, 0f, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 6
Number of expressions: 5
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Expression(0, Add), rhs = Counter(2)
- expression 2 operands: lhs = Expression(3, Sub), rhs = Counter(1)
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(2)
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(2)
- expression 5 operands: lhs = Counter(3), rhs = Counter(4)
- expression 2 operands: lhs = Counter(0), rhs = Counter(2)
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(4)
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 3, 9) to (start + 2, 10)
= (c0 + c1)
- Code(Expression(3, Sub)) at (prev + 5, 13) to (start + 2, 14)
- Code(Expression(1, Sub)) at (prev + 5, 13) to (start + 2, 14)
= ((c0 + c1) - c2)
- Code(Expression(2, Sub)) at (prev + 6, 21) to (start + 2, 22)
= (((c0 + c1) - c2) - c1)
= (c0 - c2)
- Code(Counter(3)) at (prev + 4, 21) to (start + 0, 27)
- Code(Counter(4)) at (prev + 4, 21) to (start + 0, 27)
- Code(Counter(1)) at (prev + 3, 10) to (start + 3, 10)
- Code(Counter(2)) at (prev + 6, 5) to (start + 0, 11)
- Code(Expression(4, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c3 + c4) + c2)
- Code(Expression(3, Add)) at (prev + 1, 1) to (start + 0, 2)
= ((c2 + c3) + c4)
Highest counter ID seen: c4

24
tests/coverage/yield.cov-map
View File

@ -1,17 +1,17 @@
Function name: yield::main
Raw bytes (106): 0x[01, 01, 0b, 05, 00, 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, 07, 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, 08, 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]
Raw bytes (106): 0x[01, 01, 0b, 05, 00, 0d, 11, 0d, 23, 11, 15, 11, 15, 0d, 23, 11, 15, 0d, 23, 11, 15, 19, 1d, 25, 29, 10, 01, 07, 01, 01, 16, 01, 07, 0b, 00, 2e, 0d, 01, 27, 00, 29, 03, 01, 0e, 00, 34, 0d, 02, 0b, 00, 2e, 06, 01, 22, 00, 27, 1e, 00, 2c, 00, 2e, 23, 01, 0e, 00, 34, 1e, 03, 09, 00, 16, 1e, 08, 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: 11
- expression 0 operands: lhs = Counter(1), rhs = Zero
- 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 2 operands: lhs = Counter(3), rhs = Expression(8, Add)
- expression 3 operands: lhs = Counter(4), rhs = Counter(5)
- 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 5 operands: lhs = Counter(3), rhs = Expression(8, Add)
- expression 6 operands: lhs = Counter(4), rhs = Counter(5)
- expression 7 operands: lhs = Counter(3), rhs = Expression(8, Add)
- expression 8 operands: lhs = Counter(4), rhs = Counter(5)
- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
- expression 10 operands: lhs = Counter(9), rhs = Counter(10)
Number of file 0 mappings: 16
@ -21,16 +21,16 @@ Number of file 0 mappings: 16
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c1 + Zero)
- Code(Counter(3)) at (prev + 2, 11) to (start + 0, 46)
- Code(Expression(8, Sub)) at (prev + 1, 34) to (start + 0, 39)
- Code(Expression(1, Sub)) at (prev + 1, 34) to (start + 0, 39)
= (c3 - c4)
- Code(Expression(7, Sub)) at (prev + 0, 44) to (start + 0, 46)
= ((c3 - c4) - c5)
- Code(Expression(4, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c3 - (c4 + c5))
- Code(Expression(8, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c4 + c5)
- Code(Expression(7, Sub)) at (prev + 3, 9) to (start + 0, 22)
= ((c3 - c4) - c5)
= (c3 - (c4 + c5))
- Code(Expression(7, Sub)) at (prev + 8, 11) to (start + 0, 46)
= ((c3 - c4) - c5)
= (c3 - (c4 + c5))
- Code(Counter(8)) at (prev + 1, 39) to (start + 0, 41)
- Code(Expression(9, Add)) at (prev + 1, 14) to (start + 0, 52)
= (c6 + c7)

14
tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
View File

@ -30,15 +30,12 @@
+ coverage ExpressionId(0) => Expression { lhs: Counter(1), op: Add, rhs: Counter(2) };
+ coverage ExpressionId(1) => Expression { lhs: Expression(0), op: Add, rhs: Counter(3) };
+ coverage ExpressionId(2) => Expression { lhs: Counter(0), op: Subtract, rhs: Expression(1) };
+ coverage ExpressionId(3) => Expression { lhs: Counter(3), op: Add, rhs: Counter(2) };
+ coverage ExpressionId(4) => Expression { lhs: Expression(3), op: Add, rhs: Counter(1) };
+ coverage ExpressionId(5) => Expression { lhs: Expression(4), op: Add, rhs: Expression(2) };
+ coverage Code(Counter(0)) => 14:1 - 15:21;
+ coverage Code(Counter(3)) => 16:17 - 16:33;
+ coverage Code(Counter(1)) => 16:17 - 16:33;
+ coverage Code(Counter(2)) => 17:17 - 17:33;
+ coverage Code(Counter(1)) => 18:17 - 18:33;
+ coverage Code(Counter(3)) => 18:17 - 18:33;
+ coverage Code(Expression(2)) => 19:17 - 19:33;
+ coverage Code(Expression(5)) => 21:1 - 21:2;
+ coverage Code(Counter(0)) => 21:1 - 21:2;
+
bb0: {
+ Coverage::CounterIncrement(0);
@ -55,7 +52,7 @@
}
bb2: {
+ Coverage::CounterIncrement(3);
+ Coverage::CounterIncrement(1);
falseEdge -> [real: bb8, imaginary: bb3];
}
@ -65,7 +62,7 @@
}
bb4: {
+ Coverage::CounterIncrement(1);
+ Coverage::CounterIncrement(3);
falseEdge -> [real: bb6, imaginary: bb5];
}
@ -127,7 +124,6 @@
}
bb13: {
+ Coverage::ExpressionUsed(5);
StorageDead(_1);
return;
}