From 44e4e4515c877093379e368b591b6aae3545f77c Mon Sep 17 00:00:00 2001 From: Zalathar Date: Fri, 29 Nov 2024 12:58:35 +1100 Subject: [PATCH] coverage: Add an extra "transcribe" step after counter creation --- .../src/coverage/counters.rs | 132 ++++- .../src/coverage/counters/tests.rs | 41 ++ tests/coverage/abort.cov-map | 26 +- tests/coverage/assert.cov-map | 31 +- tests/coverage/async.cov-map | 27 +- tests/coverage/branch/guard.cov-map | 6 +- tests/coverage/branch/if.cov-map | 28 +- tests/coverage/branch/lazy-boolean.cov-map | 170 +++--- tests/coverage/branch/match-arms.cov-map | 76 ++- tests/coverage/branch/no-mir-spans.cov-map | 14 +- tests/coverage/branch/while.cov-map | 43 +- tests/coverage/closure_macro.cov-map | 8 +- tests/coverage/closure_macro_async.cov-map | 8 +- tests/coverage/condition/conditions.cov-map | 73 ++- tests/coverage/conditions.cov-map | 508 ++++++++++-------- tests/coverage/continue.cov-map | 18 +- tests/coverage/coroutine.cov-map | 18 +- tests/coverage/inline-dead.cov-map | 8 +- tests/coverage/inline.cov-map | 17 +- tests/coverage/issue-84561.cov-map | 192 +++---- tests/coverage/lazy_boolean.cov-map | 40 +- tests/coverage/loops_branches.cov-map | 223 ++++---- tests/coverage/mcdc/condition-limit.cov-map | 156 +++--- tests/coverage/mcdc/if.cov-map | 262 ++++----- .../coverage/mcdc/inlined_expressions.cov-map | 13 +- tests/coverage/mcdc/nested_if.cov-map | 268 ++++----- tests/coverage/mcdc/non_control_flow.cov-map | 143 +++-- tests/coverage/nested_loops.cov-map | 76 ++- tests/coverage/overflow.cov-map | 31 +- tests/coverage/panic_unwind.cov-map | 31 +- tests/coverage/simple_match.cov-map | 20 +- tests/coverage/try_error_result.cov-map | 242 ++++----- tests/coverage/unicode.cov-map | 24 +- tests/coverage/unused.cov-map | 20 +- tests/coverage/while_early_ret.cov-map | 19 +- tests/coverage/yield.cov-map | 24 +- ...ch_match_arms.main.InstrumentCoverage.diff | 14 +- 37 files changed, 1609 insertions(+), 1441 deletions(-) create mode 100644 compiler/rustc_mir_transform/src/coverage/counters/tests.rs diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs index 3927c18da4c..4e543fc9918 100644 --- a/compiler/rustc_mir_transform/src/coverage/counters.rs +++ b/compiler/rustc_mir_transform/src/coverage/counters.rs @@ -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 }, @@ -44,7 +48,7 @@ struct BcbExpression { } /// Enum representing either a node or an edge in the coverage graph. -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub(super) enum Site { Node { bcb: BasicCoverageBlock }, Edge { from_bcb: BasicCoverageBlock, to_bcb: BasicCoverageBlock }, @@ -84,7 +88,7 @@ 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 { @@ -496,4 +500,126 @@ 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, +} + +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 Some(old_counter) = self.old.counters.node_counters[bcb] else { continue }; + + // Resolve the old 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(old_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>| { + sites + .into_iter() + .filter_map(|id| try { self.ensure_phys_counter(id?) }) + .collect::>() + }; + 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 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: BcbCounter, pos: &mut Vec, neg: &mut Vec) { + match counter { + BcbCounter::Counter { id } => pos.push(self.old.counters.counter_increment_sites[id]), + BcbCounter::Expression { id } => { + let BcbExpression { lhs, op, rhs } = self.old.counters.expressions[id]; + self.push_resolved_sites(lhs, pos, neg); + match op { + Op::Add => self.push_resolved_sites(rhs, pos, neg), + // Swap `neg` and `pos` so that the counter is subtracted. + Op::Subtract => self.push_resolved_sites(rhs, neg, pos), + } + } + } + } +} + +/// Given two lists: +/// - Sorts each list. +/// - Converts each list to `Vec>`. +/// - Scans for values that appear in both lists, and cancels them out by +/// replacing matching pairs of values with `None`. +fn sort_and_cancel(mut pos: Vec, mut neg: Vec) -> (Vec>, Vec>) { + pos.sort(); + neg.sort(); + + // Convert to `Vec>`. If `T` has a niche, this should be zero-cost. + let mut pos = pos.into_iter().map(Some).collect::>(); + let mut neg = neg.into_iter().map(Some).collect::>(); + + // 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) } diff --git a/compiler/rustc_mir_transform/src/coverage/counters/tests.rs b/compiler/rustc_mir_transform/src/coverage/counters/tests.rs new file mode 100644 index 00000000000..794d4358f82 --- /dev/null +++ b/compiler/rustc_mir_transform/src/coverage/counters/tests.rs @@ -0,0 +1,41 @@ +use std::fmt::Debug; + +use super::sort_and_cancel; + +fn flatten(input: Vec>) -> Vec { + input.into_iter().flatten().collect() +} + +fn sort_and_cancel_and_flatten(pos: Vec, neg: Vec) -> (Vec, Vec) { + let (pos_actual, neg_actual) = sort_and_cancel(pos, neg); + (flatten(pos_actual), flatten(neg_actual)) +} + +#[track_caller] +fn check_test_case( + pos: Vec, + neg: Vec, + pos_expected: Vec, + neg_expected: Vec, +) { + 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, Vec, Vec, Vec)] = &[ + (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()); + } +} diff --git a/tests/coverage/abort.cov-map b/tests/coverage/abort.cov-map index c121fa551dc..396edec275d 100644 --- a/tests/coverage/abort.cov-map +++ b/tests/coverage/abort.cov-map @@ -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) diff --git a/tests/coverage/assert.cov-map b/tests/coverage/assert.cov-map index b3cec390119..3bbf7a43e6d 100644 --- a/tests/coverage/assert.cov-map +++ b/tests/coverage/assert.cov-map @@ -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 diff --git a/tests/coverage/async.cov-map b/tests/coverage/async.cov-map index 9a67cefcf98..c51bc6eb621 100644 --- a/tests/coverage/async.cov-map +++ b/tests/coverage/async.cov-map @@ -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 diff --git a/tests/coverage/branch/guard.cov-map b/tests/coverage/branch/guard.cov-map index e87b389c1ac..1ba1c6e1228 100644 --- a/tests/coverage/branch/guard.cov-map +++ b/tests/coverage/branch/guard.cov-map @@ -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, 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, 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 @@ -23,9 +23,9 @@ Number of file 0 mappings: 13 - Code(Counter(4)) at (prev + 3, 14) to (start + 0, 15) - Code(Expression(0, Sub)) at (prev + 0, 20) to (start + 0, 25) = (c6 - c3) -- Branch { true: Counter(4), false: Counter(2) } at (prev + 0, 20) to (start + 0, 30) +- 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) diff --git a/tests/coverage/branch/if.cov-map b/tests/coverage/branch/if.cov-map index 0ad78a720a7..bab982dd44c 100644 --- a/tests/coverage/branch/if.cov-map +++ b/tests/coverage/branch/if.cov-map @@ -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 diff --git a/tests/coverage/branch/lazy-boolean.cov-map b/tests/coverage/branch/lazy-boolean.cov-map index c2b6a5b8df2..decb847f60e 100644 --- a/tests/coverage/branch/lazy-boolean.cov-map +++ b/tests/coverage/branch/lazy-boolean.cov-map @@ -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 diff --git a/tests/coverage/branch/match-arms.cov-map b/tests/coverage/branch/match-arms.cov-map index fd0366ee818..a93df9814ee 100644 --- a/tests/coverage/branch/match-arms.cov-map +++ b/tests/coverage/branch/match-arms.cov-map @@ -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 diff --git a/tests/coverage/branch/no-mir-spans.cov-map b/tests/coverage/branch/no-mir-spans.cov-map index ab12732b1ed..6003efc36ca 100644 --- a/tests/coverage/branch/no-mir-spans.cov-map +++ b/tests/coverage/branch/no-mir-spans.cov-map @@ -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 diff --git a/tests/coverage/branch/while.cov-map b/tests/coverage/branch/while.cov-map index d5840a2c320..305f6bc74d8 100644 --- a/tests/coverage/branch/while.cov-map +++ b/tests/coverage/branch/while.cov-map @@ -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 diff --git a/tests/coverage/closure_macro.cov-map b/tests/coverage/closure_macro.cov-map index 7c9d3292f98..aedb924eca8 100644 --- a/tests/coverage/closure_macro.cov-map +++ b/tests/coverage/closure_macro.cov-map @@ -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 diff --git a/tests/coverage/closure_macro_async.cov-map b/tests/coverage/closure_macro_async.cov-map index e2a52e57015..5b99889514c 100644 --- a/tests/coverage/closure_macro_async.cov-map +++ b/tests/coverage/closure_macro_async.cov-map @@ -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 diff --git a/tests/coverage/condition/conditions.cov-map b/tests/coverage/condition/conditions.cov-map index 208d671919c..72f39b88c6a 100644 --- a/tests/coverage/condition/conditions.cov-map +++ b/tests/coverage/condition/conditions.cov-map @@ -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 diff --git a/tests/coverage/conditions.cov-map b/tests/coverage/conditions.cov-map index 938e4404013..21b2ec9a19e 100644 --- a/tests/coverage/conditions.cov-map +++ b/tests/coverage/conditions.cov-map @@ -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 diff --git a/tests/coverage/continue.cov-map b/tests/coverage/continue.cov-map index 7781d2d2544..55313d7db49 100644 --- a/tests/coverage/continue.cov-map +++ b/tests/coverage/continue.cov-map @@ -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 diff --git a/tests/coverage/coroutine.cov-map b/tests/coverage/coroutine.cov-map index 2fdc3220c19..21f6787e9f2 100644 --- a/tests/coverage/coroutine.cov-map +++ b/tests/coverage/coroutine.cov-map @@ -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} diff --git a/tests/coverage/inline-dead.cov-map b/tests/coverage/inline-dead.cov-map index 5a20de3d4d4..3e2ca2bc992 100644 --- a/tests/coverage/inline-dead.cov-map +++ b/tests/coverage/inline-dead.cov-map @@ -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 diff --git a/tests/coverage/inline.cov-map b/tests/coverage/inline.cov-map index ab3a505e925..1b5b45695dc 100644 --- a/tests/coverage/inline.cov-map +++ b/tests/coverage/inline.cov-map @@ -41,14 +41,15 @@ Number of file 0 mappings: 1 Highest counter ID seen: c0 Function name: inline::permutate:: -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:: diff --git a/tests/coverage/issue-84561.cov-map b/tests/coverage/issue-84561.cov-map index 64870c434b3..a2ab558f960 100644 --- a/tests/coverage/issue-84561.cov-map +++ b/tests/coverage/issue-84561.cov-map @@ -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 diff --git a/tests/coverage/lazy_boolean.cov-map b/tests/coverage/lazy_boolean.cov-map index b0c2d736573..3f7788da1eb 100644 --- a/tests/coverage/lazy_boolean.cov-map +++ b/tests/coverage/lazy_boolean.cov-map @@ -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 diff --git a/tests/coverage/loops_branches.cov-map b/tests/coverage/loops_branches.cov-map index 61a6bda676a..14707701d8a 100644 --- a/tests/coverage/loops_branches.cov-map +++ b/tests/coverage/loops_branches.cov-map @@ -1,50 +1,42 @@ Function name: ::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: ::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] diff --git a/tests/coverage/mcdc/condition-limit.cov-map b/tests/coverage/mcdc/condition-limit.cov-map index e3f5b49d363..19716878600 100644 --- a/tests/coverage/mcdc/condition-limit.cov-map +++ b/tests/coverage/mcdc/condition-limit.cov-map @@ -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 diff --git a/tests/coverage/mcdc/if.cov-map b/tests/coverage/mcdc/if.cov-map index c0e7d08bb02..acb8aac63de 100644 --- a/tests/coverage/mcdc/if.cov-map +++ b/tests/coverage/mcdc/if.cov-map @@ -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 diff --git a/tests/coverage/mcdc/inlined_expressions.cov-map b/tests/coverage/mcdc/inlined_expressions.cov-map index 4f44e0f2b85..92ec60dc23c 100644 --- a/tests/coverage/mcdc/inlined_expressions.cov-map +++ b/tests/coverage/mcdc/inlined_expressions.cov-map @@ -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 diff --git a/tests/coverage/mcdc/nested_if.cov-map b/tests/coverage/mcdc/nested_if.cov-map index 3bed49e7a12..72daecabc77 100644 --- a/tests/coverage/mcdc/nested_if.cov-map +++ b/tests/coverage/mcdc/nested_if.cov-map @@ -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 diff --git a/tests/coverage/mcdc/non_control_flow.cov-map b/tests/coverage/mcdc/non_control_flow.cov-map index 677e31e404e..0edeff9a586 100644 --- a/tests/coverage/mcdc/non_control_flow.cov-map +++ b/tests/coverage/mcdc/non_control_flow.cov-map @@ -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 diff --git a/tests/coverage/nested_loops.cov-map b/tests/coverage/nested_loops.cov-map index 21871ef3206..6ba5887d243 100644 --- a/tests/coverage/nested_loops.cov-map +++ b/tests/coverage/nested_loops.cov-map @@ -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 diff --git a/tests/coverage/overflow.cov-map b/tests/coverage/overflow.cov-map index f6bfb465bf9..01abcc15003 100644 --- a/tests/coverage/overflow.cov-map +++ b/tests/coverage/overflow.cov-map @@ -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 diff --git a/tests/coverage/panic_unwind.cov-map b/tests/coverage/panic_unwind.cov-map index 58a796ff3a2..005c4babbea 100644 --- a/tests/coverage/panic_unwind.cov-map +++ b/tests/coverage/panic_unwind.cov-map @@ -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 diff --git a/tests/coverage/simple_match.cov-map b/tests/coverage/simple_match.cov-map index d8bf9eae4bc..8f973742959 100644 --- a/tests/coverage/simple_match.cov-map +++ b/tests/coverage/simple_match.cov-map @@ -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) diff --git a/tests/coverage/try_error_result.cov-map b/tests/coverage/try_error_result.cov-map index 246a1ba738b..7fbd2cc642e 100644 --- a/tests/coverage/try_error_result.cov-map +++ b/tests/coverage/try_error_result.cov-map @@ -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 diff --git a/tests/coverage/unicode.cov-map b/tests/coverage/unicode.cov-map index 769930110d6..630ab4ce47e 100644 --- a/tests/coverage/unicode.cov-map +++ b/tests/coverage/unicode.cov-map @@ -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] diff --git a/tests/coverage/unused.cov-map b/tests/coverage/unused.cov-map index e865ac3ee62..4eae63f380c 100644 --- a/tests/coverage/unused.cov-map +++ b/tests/coverage/unused.cov-map @@ -1,18 +1,18 @@ Function name: unused::foo:: -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:: -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) diff --git a/tests/coverage/while_early_ret.cov-map b/tests/coverage/while_early_ret.cov-map index 6254dfbcf01..ade770597e2 100644 --- a/tests/coverage/while_early_ret.cov-map +++ b/tests/coverage/while_early_ret.cov-map @@ -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 diff --git a/tests/coverage/yield.cov-map b/tests/coverage/yield.cov-map index 578994a4530..e01ec8f9edb 100644 --- a/tests/coverage/yield.cov-map +++ b/tests/coverage/yield.cov-map @@ -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) diff --git a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff index cbb11d50f79..8dd23e4d6a3 100644 --- a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff +++ b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff @@ -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; }