mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

coverage: Avoid referring to "operands" in counter creation

Browse Source
This commit is contained in:
Zalathar 2024-09-10 20:48:28 +10:00
parent 8be70c7b2c
commit 10cd5e8386
1 changed files with 8 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -288,7 +288,7 @@ fn make_node_counter_and_out_edge_counters(
) { ) {
// First, ensure that this node has a counter of some kind. // First, ensure that this node has a counter of some kind.
// We might also use that counter to compute one of the out-edge counters. // We might also use that counter to compute one of the out-edge counters.
let from_bcb_operand = self.get_or_make_counter_operand(from_bcb); let node_counter = self.get_or_make_node_counter(from_bcb);
let successors = self.basic_coverage_blocks.successors[from_bcb].as_slice(); let successors = self.basic_coverage_blocks.successors[from_bcb].as_slice();
@ -324,7 +324,7 @@ fn make_node_counter_and_out_edge_counters(
.filter(|&to_bcb| to_bcb != expression_to_bcb) .filter(|&to_bcb| to_bcb != expression_to_bcb)
.fold(None, |accum, to_bcb| { .fold(None, |accum, to_bcb| {
let _span = debug_span!("to_bcb", ?accum, ?to_bcb).entered(); let _span = debug_span!("to_bcb", ?accum, ?to_bcb).entered();
let edge_counter = self.get_or_make_edge_counter_operand(from_bcb, to_bcb); let edge_counter = self.get_or_make_edge_counter(from_bcb, to_bcb);
Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) Some(self.coverage_counters.make_sum_expression(accum, edge_counter))
}) })
.expect("there must be at least one other out-edge") .expect("there must be at least one other out-edge")
@ -333,7 +333,7 @@ fn make_node_counter_and_out_edge_counters(
// Now create an expression for the chosen edge, by taking the counter // Now create an expression for the chosen edge, by taking the counter
// for its source node and subtracting the sum of its sibling out-edges. // for its source node and subtracting the sum of its sibling out-edges.
let expression = self.coverage_counters.make_expression( let expression = self.coverage_counters.make_expression(
from_bcb_operand, node_counter,
Op::Subtract, Op::Subtract,
sum_of_all_other_out_edges, sum_of_all_other_out_edges,
); );
@ -347,7 +347,7 @@ fn make_node_counter_and_out_edge_counters(
} }
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self))]
fn get_or_make_counter_operand(&mut self, bcb: BasicCoverageBlock) -> BcbCounter { fn get_or_make_node_counter(&mut self, bcb: BasicCoverageBlock) -> BcbCounter {
// If the BCB already has a counter, return it. // If the BCB already has a counter, return it.
if let Some(counter_kind) = self.coverage_counters.bcb_counters[bcb] { if let Some(counter_kind) = self.coverage_counters.bcb_counters[bcb] {
debug!("{bcb:?} already has a counter: {counter_kind:?}"); debug!("{bcb:?} already has a counter: {counter_kind:?}");
@ -384,7 +384,7 @@ fn get_or_make_counter_operand(&mut self, bcb: BasicCoverageBlock) -> BcbCounter
.copied() .copied()
.fold(None, |accum, from_bcb| { .fold(None, |accum, from_bcb| {
let _span = debug_span!("from_bcb", ?accum, ?from_bcb).entered(); let _span = debug_span!("from_bcb", ?accum, ?from_bcb).entered();
let edge_counter = self.get_or_make_edge_counter_operand(from_bcb, bcb); let edge_counter = self.get_or_make_edge_counter(from_bcb, bcb);
Some(self.coverage_counters.make_sum_expression(accum, edge_counter)) Some(self.coverage_counters.make_sum_expression(accum, edge_counter))
}) })
.expect("there must be at least one in-edge") .expect("there must be at least one in-edge")
@ -395,7 +395,7 @@ fn get_or_make_counter_operand(&mut self, bcb: BasicCoverageBlock) -> BcbCounter
} }
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self))]
fn get_or_make_edge_counter_operand( fn get_or_make_edge_counter(
&mut self, &mut self,
from_bcb: BasicCoverageBlock, from_bcb: BasicCoverageBlock,
to_bcb: BasicCoverageBlock, to_bcb: BasicCoverageBlock,
@ -404,13 +404,13 @@ fn get_or_make_edge_counter_operand(
// a node counter instead, since it will have the same value. // a node counter instead, since it will have the same value.
if !self.basic_coverage_blocks.bcb_has_multiple_in_edges(to_bcb) { if !self.basic_coverage_blocks.bcb_has_multiple_in_edges(to_bcb) {
assert_eq!([from_bcb].as_slice(), self.basic_coverage_blocks.predecessors[to_bcb]); assert_eq!([from_bcb].as_slice(), self.basic_coverage_blocks.predecessors[to_bcb]);
return self.get_or_make_counter_operand(to_bcb); return self.get_or_make_node_counter(to_bcb);
} }
// If the source BCB has only one successor (assumed to be the given target), an edge // If the source BCB has only one successor (assumed to be the given target), an edge
// counter is unnecessary. Just get or make a counter for the source BCB. // counter is unnecessary. Just get or make a counter for the source BCB.
if self.bcb_successors(from_bcb).len() == 1 { if self.bcb_successors(from_bcb).len() == 1 {
return self.get_or_make_counter_operand(from_bcb); return self.get_or_make_node_counter(from_bcb);
} }
// If the edge already has a counter, return it. // If the edge already has a counter, return it.