Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit e02941c

Browse files
ZalatharZalathar
committedJun 25, 2024·
coverage: Treat each match arm as a "branch" for branch coverage
1 parent 05390e7 commit e02941c

File tree

10 files changed

+249
-60
lines changed

10 files changed

+249
-60
lines changed
 

‎compiler/rustc_mir_build/src/build/coverageinfo.rs

+32
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,12 @@ struct NotInfo {
3333
is_flipped: bool,
3434
}
3535

36+
pub(crate) struct MatchArm {
37+
pub(crate) source_info: SourceInfo,
38+
pub(crate) pre_binding_block: Option<BasicBlock>,
39+
pub(crate) arm_block: BasicBlock,
40+
}
41+
3642
#[derive(Default)]
3743
struct BlockMarkerGen {
3844
num_block_markers: usize,
@@ -150,6 +156,32 @@ impl BranchInfoBuilder {
150156
}
151157
}
152158

159+
pub(crate) fn add_match_arms(&mut self, cfg: &mut CFG<'_>, arms: &[MatchArm]) {
160+
// Match expressions with 0-1 arms don't have any branches for their arms.
161+
if arms.len() < 2 {
162+
return;
163+
}
164+
165+
// FIXME(#124118) The current implementation of branch coverage for
166+
// match arms can't handle or-patterns.
167+
if arms.iter().any(|arm| arm.pre_binding_block.is_none()) {
168+
return;
169+
}
170+
171+
let branch_arms = arms
172+
.iter()
173+
.map(|&MatchArm { source_info, pre_binding_block, arm_block }| {
174+
let pre_guard_marker =
175+
self.markers.inject_block_marker(cfg, source_info, pre_binding_block.unwrap());
176+
let arm_taken_marker =
177+
self.markers.inject_block_marker(cfg, source_info, arm_block);
178+
BranchArm { span: source_info.span, pre_guard_marker, arm_taken_marker }
179+
})
180+
.collect::<Vec<_>>();
181+
182+
self.branch_arm_lists.push(branch_arms);
183+
}
184+
153185
pub(crate) fn into_done(self) -> Option<Box<mir::coverage::BranchInfo>> {
154186
let Self {
155187
nots: _,

‎compiler/rustc_mir_build/src/build/matches/mod.rs

+20-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
use crate::build::expr::as_place::PlaceBuilder;
99
use crate::build::scope::DropKind;
1010
use crate::build::ForGuard::{self, OutsideGuard, RefWithinGuard};
11-
use crate::build::{BlockAnd, BlockAndExtension, Builder};
11+
use crate::build::{coverageinfo, BlockAnd, BlockAndExtension, Builder};
1212
use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode};
1313
use rustc_data_structures::{fx::FxIndexMap, stack::ensure_sufficient_stack};
1414
use rustc_hir::{BindingMode, ByRef};
@@ -470,6 +470,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
470470
outer_source_info: SourceInfo,
471471
fake_borrow_temps: Vec<(Place<'tcx>, Local, FakeBorrowKind)>,
472472
) -> BlockAnd<()> {
473+
let mut coverage_match_arms = self.coverage_branch_info.is_some().then_some(vec![]);
474+
473475
let arm_end_blocks: Vec<_> = arm_candidates
474476
.into_iter()
475477
.map(|(arm, candidate)| {
@@ -504,6 +506,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
504506
opt_scrutinee_place,
505507
);
506508

509+
let pre_binding_block = candidate.pre_binding_block;
510+
507511
let arm_block = this.bind_pattern(
508512
outer_source_info,
509513
candidate,
@@ -513,6 +517,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
513517
false,
514518
);
515519

520+
if let Some(coverage_match_arms) = coverage_match_arms.as_mut() {
521+
coverage_match_arms.push(coverageinfo::MatchArm {
522+
source_info: this.source_info(arm.pattern.span),
523+
pre_binding_block,
524+
arm_block,
525+
})
526+
}
527+
516528
this.fixed_temps_scope = old_dedup_scope;
517529

518530
if let Some(source_scope) = scope {
@@ -524,6 +536,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
524536
})
525537
.collect();
526538

539+
if let Some(coverage_match_arms) = coverage_match_arms {
540+
self.coverage_branch_info
541+
.as_mut()
542+
.expect("checked when creating `coverage_match_arms`")
543+
.add_match_arms(&mut self.cfg, &coverage_match_arms);
544+
}
545+
527546
// all the arm blocks will rejoin here
528547
let end_block = self.cfg.start_new_block();
529548

‎tests/coverage/branch/guard-simple.cov-map

+22-11
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,35 @@
11
Function name: guard_simple::never_taken
2-
Raw bytes (56): 0x[01, 01, 04, 01, 05, 11, 09, 0f, 0d, 05, 09, 08, 01, 08, 01, 02, 1e, 20, 05, 02, 02, 0e, 00, 1e, 05, 00, 22, 00, 24, 11, 01, 0e, 00, 1e, 20, 09, 06, 00, 0e, 00, 1e, 09, 00, 22, 00, 24, 0d, 01, 0e, 00, 10, 0b, 02, 01, 00, 02]
2+
Raw bytes (80): 0x[01, 01, 09, 07, 01, 17, 05, 0d, 09, 01, 05, 17, 11, 0d, 09, 11, 09, 23, 0d, 05, 09, 0a, 01, 08, 01, 02, 1e, 20, 01, 02, 02, 09, 00, 0a, 20, 05, 0e, 00, 0e, 00, 1e, 05, 00, 22, 00, 24, 20, 11, 12, 01, 09, 00, 0a, 11, 00, 0e, 00, 1e, 20, 09, 1a, 00, 0e, 00, 1e, 09, 00, 22, 00, 24, 0d, 01, 0e, 00, 10, 1f, 02, 01, 00, 02]
33
Number of files: 1
44
- file 0 => global file 1
5-
Number of expressions: 4
6-
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
7-
- expression 1 operands: lhs = Counter(4), rhs = Counter(2)
8-
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
9-
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
10-
Number of file 0 mappings: 8
5+
Number of expressions: 9
6+
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(0)
7+
- expression 1 operands: lhs = Expression(5, Add), rhs = Counter(1)
8+
- expression 2 operands: lhs = Counter(3), rhs = Counter(2)
9+
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
10+
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(4)
11+
- expression 5 operands: lhs = Counter(3), rhs = Counter(2)
12+
- expression 6 operands: lhs = Counter(4), rhs = Counter(2)
13+
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(3)
14+
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
15+
Number of file 0 mappings: 10
1116
- Code(Counter(0)) at (prev + 8, 1) to (start + 2, 30)
12-
- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 2, 14) to (start + 0, 30)
17+
- Branch { true: Counter(0), false: Expression(0, Sub) } at (prev + 2, 9) to (start + 0, 10)
18+
true = c0
19+
false = (((c3 + c2) + c1) - c0)
20+
- Branch { true: Counter(1), false: Expression(3, Sub) } at (prev + 0, 14) to (start + 0, 30)
1321
true = c1
1422
false = (c0 - c1)
1523
- Code(Counter(1)) at (prev + 0, 34) to (start + 0, 36)
16-
- Code(Counter(4)) at (prev + 1, 14) to (start + 0, 30)
17-
- Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 14) to (start + 0, 30)
24+
- Branch { true: Counter(4), false: Expression(4, Sub) } at (prev + 1, 9) to (start + 0, 10)
25+
true = c4
26+
false = ((c3 + c2) - c4)
27+
- Code(Counter(4)) at (prev + 0, 14) to (start + 0, 30)
28+
- Branch { true: Counter(2), false: Expression(6, Sub) } at (prev + 0, 14) to (start + 0, 30)
1829
true = c2
1930
false = (c4 - c2)
2031
- Code(Counter(2)) at (prev + 0, 34) to (start + 0, 36)
2132
- Code(Counter(3)) at (prev + 1, 14) to (start + 0, 16)
22-
- Code(Expression(2, Add)) at (prev + 2, 1) to (start + 0, 2)
33+
- Code(Expression(7, Add)) at (prev + 2, 1) to (start + 0, 2)
2334
= ((c1 + c2) + c3)
2435

‎tests/coverage/branch/guard-simple.coverage

+2
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,13 @@
1010
LL| 1| _ if black_box(false) => {}
1111
^0
1212
------------------
13+
| Branch (LL:9): [True: 1, False: 0]
1314
| Branch (LL:14): [True: 0, False: 1]
1415
------------------
1516
LL| 1| _ if black_box(false) => {}
1617
^0
1718
------------------
19+
| Branch (LL:9): [True: 1, False: 0]
1820
| Branch (LL:14): [True: 0, False: 1]
1921
------------------
2022
LL| 1| _ => {}

‎tests/coverage/branch/guard.cov-map

+31-15
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,48 @@
11
Function name: guard::branch_match_guard
2-
Raw bytes (85): 0x[01, 01, 06, 19, 0d, 05, 09, 0f, 15, 13, 11, 17, 0d, 05, 09, 0d, 01, 0c, 01, 01, 10, 1d, 03, 0b, 00, 0c, 15, 01, 14, 02, 0a, 0d, 03, 0e, 00, 0f, 19, 00, 14, 00, 19, 20, 0d, 02, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 11, 03, 0e, 00, 0f, 1d, 00, 14, 00, 19, 20, 11, 09, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 17, 03, 0e, 02, 0a, 0b, 04, 01, 00, 02]
2+
Raw bytes (120): 0x[01, 01, 0d, 1b, 0d, 33, 11, 05, 09, 03, 19, 19, 0d, 1b, 1d, 33, 11, 05, 09, 05, 09, 2b, 15, 2f, 11, 33, 0d, 05, 09, 10, 01, 0c, 01, 01, 10, 1d, 03, 0b, 00, 0c, 20, 15, 03, 01, 09, 00, 10, 15, 00, 14, 02, 0a, 20, 19, 0e, 03, 09, 00, 10, 0d, 00, 0e, 00, 0f, 19, 00, 14, 00, 19, 20, 0d, 12, 00, 14, 00, 1e, 0d, 00, 1d, 02, 0a, 20, 1d, 16, 03, 09, 00, 10, 11, 00, 0e, 00, 0f, 1d, 00, 14, 00, 19, 20, 11, 09, 00, 14, 00, 1e, 11, 00, 1d, 02, 0a, 33, 03, 0e, 02, 0a, 27, 04, 01, 00, 02]
33
Number of files: 1
44
- file 0 => global file 1
5-
Number of expressions: 6
6-
- expression 0 operands: lhs = Counter(6), rhs = Counter(3)
7-
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
8-
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(5)
9-
- expression 3 operands: lhs = Expression(4, Add), rhs = Counter(4)
10-
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(3)
11-
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
12-
Number of file 0 mappings: 13
5+
Number of expressions: 13
6+
- expression 0 operands: lhs = Expression(6, Add), rhs = Counter(3)
7+
- expression 1 operands: lhs = Expression(12, Add), rhs = Counter(4)
8+
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
9+
- expression 3 operands: lhs = Expression(0, Add), rhs = Counter(6)
10+
- expression 4 operands: lhs = Counter(6), rhs = Counter(3)
11+
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(7)
12+
- expression 6 operands: lhs = Expression(12, Add), rhs = Counter(4)
13+
- expression 7 operands: lhs = Counter(1), rhs = Counter(2)
14+
- expression 8 operands: lhs = Counter(1), rhs = Counter(2)
15+
- expression 9 operands: lhs = Expression(10, Add), rhs = Counter(5)
16+
- expression 10 operands: lhs = Expression(11, Add), rhs = Counter(4)
17+
- expression 11 operands: lhs = Expression(12, Add), rhs = Counter(3)
18+
- expression 12 operands: lhs = Counter(1), rhs = Counter(2)
19+
Number of file 0 mappings: 16
1320
- Code(Counter(0)) at (prev + 12, 1) to (start + 1, 16)
1421
- Code(Counter(7)) at (prev + 3, 11) to (start + 0, 12)
15-
- Code(Counter(5)) at (prev + 1, 20) to (start + 2, 10)
16-
- Code(Counter(3)) at (prev + 3, 14) to (start + 0, 15)
22+
- Branch { true: Counter(5), false: Expression(0, Add) } at (prev + 1, 9) to (start + 0, 16)
23+
true = c5
24+
false = (((c1 + c2) + c4) + c3)
25+
- Code(Counter(5)) at (prev + 0, 20) to (start + 2, 10)
26+
- Branch { true: Counter(6), false: Expression(3, Sub) } at (prev + 3, 9) to (start + 0, 16)
27+
true = c6
28+
false = ((((c1 + c2) + c4) + c3) - c6)
29+
- Code(Counter(3)) at (prev + 0, 14) to (start + 0, 15)
1730
- Code(Counter(6)) at (prev + 0, 20) to (start + 0, 25)
18-
- Branch { true: Counter(3), false: Expression(0, Sub) } at (prev + 0, 20) to (start + 0, 30)
31+
- Branch { true: Counter(3), false: Expression(4, Sub) } at (prev + 0, 20) to (start + 0, 30)
1932
true = c3
2033
false = (c6 - c3)
2134
- Code(Counter(3)) at (prev + 0, 29) to (start + 2, 10)
22-
- Code(Counter(4)) at (prev + 3, 14) to (start + 0, 15)
35+
- Branch { true: Counter(7), false: Expression(5, Sub) } at (prev + 3, 9) to (start + 0, 16)
36+
true = c7
37+
false = (((c1 + c2) + c4) - c7)
38+
- Code(Counter(4)) at (prev + 0, 14) to (start + 0, 15)
2339
- Code(Counter(7)) at (prev + 0, 20) to (start + 0, 25)
2440
- Branch { true: Counter(4), false: Counter(2) } at (prev + 0, 20) to (start + 0, 30)
2541
true = c4
2642
false = c2
2743
- Code(Counter(4)) at (prev + 0, 29) to (start + 2, 10)
28-
- Code(Expression(5, Add)) at (prev + 3, 14) to (start + 2, 10)
44+
- Code(Expression(12, Add)) at (prev + 3, 14) to (start + 2, 10)
2945
= (c1 + c2)
30-
- Code(Expression(2, Add)) at (prev + 4, 1) to (start + 0, 2)
46+
- Code(Expression(9, Add)) at (prev + 4, 1) to (start + 0, 2)
3147
= ((((c1 + c2) + c3) + c4) + c5)
3248

‎tests/coverage/branch/guard.coverage

+5
Original file line numberDiff line numberDiff line change
@@ -14,17 +14,22 @@
1414
LL| |
1515
LL| 1| match x {
1616
LL| 1| Some(0) => {
17+
------------------
18+
| Branch (LL:9): [True: 1, False: 3]
19+
------------------
1720
LL| 1| println!("zero");
1821
LL| 1| }
1922
LL| 3| Some(x) if x % 2 == 0 => {
2023
^2
2124
------------------
25+
| Branch (LL:9): [True: 3, False: 0]
2226
| Branch (LL:20): [True: 2, False: 1]
2327
------------------
2428
LL| 2| println!("is nonzero and even");
2529
LL| 2| }
2630
LL| 1| Some(x) if x % 3 == 0 => {
2731
------------------
32+
| Branch (LL:9): [True: 1, False: 0]
2833
| Branch (LL:20): [True: 1, False: 0]
2934
------------------
3035
LL| 1| println!("is nonzero and odd, but divisible by 3");

‎tests/coverage/branch/match-arms.cov-map

+101-31
Original file line numberDiff line numberDiff line change
@@ -1,60 +1,130 @@
11
Function name: match_arms::guards
2-
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]
2+
Raw bytes (212): 0x[01, 01, 2a, 07, 35, 2b, 19, 4b, 1d, 67, 21, 9b, 01, 25, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 2b, 31, 4b, 1d, 67, 21, 9b, 01, 25, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 4b, 2d, 67, 21, 9b, 01, 25, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 67, 29, 9b, 01, 25, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 8f, 01, 25, 93, 01, 21, 97, 01, 1d, 9b, 01, 19, 9f, 01, 15, a3, 01, 11, a7, 01, 0d, 00, 09, 10, 01, 30, 01, 01, 10, 29, 03, 0b, 00, 10, 20, 35, 02, 01, 09, 00, 13, 19, 00, 11, 00, 29, 20, 19, 09, 00, 17, 00, 1b, 20, 31, 26, 01, 09, 00, 13, 1d, 00, 11, 00, 29, 20, 1d, 0d, 00, 17, 00, 1b, 20, 2d, 46, 01, 09, 00, 13, 21, 00, 11, 00, 29, 20, 21, 11, 00, 17, 00, 1b, 20, 29, 62, 01, 09, 00, 13, 25, 00, 11, 00, 29, 20, 25, 15, 00, 17, 00, 1b, 9b, 01, 01, 0e, 00, 18, 8b, 01, 03, 05, 01, 02]
33
Number of files: 1
44
- file 0 => global file 1
5-
Number of expressions: 8
6-
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(5)
7-
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
8-
- expression 2 operands: lhs = Expression(3, Add), rhs = Counter(3)
9-
- expression 3 operands: lhs = Zero, rhs = Counter(2)
10-
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(9)
11-
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(8)
12-
- expression 6 operands: lhs = Expression(7, Add), rhs = Counter(7)
13-
- expression 7 operands: lhs = Expression(0, Add), rhs = Counter(6)
14-
Number of file 0 mappings: 12
5+
Number of expressions: 42
6+
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(13)
7+
- expression 1 operands: lhs = Expression(10, Add), rhs = Counter(6)
8+
- expression 2 operands: lhs = Expression(18, Add), rhs = Counter(7)
9+
- expression 3 operands: lhs = Expression(25, Add), rhs = Counter(8)
10+
- expression 4 operands: lhs = Expression(38, Add), rhs = Counter(9)
11+
- expression 5 operands: lhs = Expression(39, Add), rhs = Counter(5)
12+
- expression 6 operands: lhs = Expression(40, Add), rhs = Counter(4)
13+
- expression 7 operands: lhs = Expression(41, Add), rhs = Counter(3)
14+
- expression 8 operands: lhs = Zero, rhs = Counter(2)
15+
- expression 9 operands: lhs = Expression(10, Add), rhs = Counter(12)
16+
- expression 10 operands: lhs = Expression(18, Add), rhs = Counter(7)
17+
- expression 11 operands: lhs = Expression(25, Add), rhs = Counter(8)
18+
- expression 12 operands: lhs = Expression(38, Add), rhs = Counter(9)
19+
- expression 13 operands: lhs = Expression(39, Add), rhs = Counter(5)
20+
- expression 14 operands: lhs = Expression(40, Add), rhs = Counter(4)
21+
- expression 15 operands: lhs = Expression(41, Add), rhs = Counter(3)
22+
- expression 16 operands: lhs = Zero, rhs = Counter(2)
23+
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(11)
24+
- expression 18 operands: lhs = Expression(25, Add), rhs = Counter(8)
25+
- expression 19 operands: lhs = Expression(38, Add), rhs = Counter(9)
26+
- expression 20 operands: lhs = Expression(39, Add), rhs = Counter(5)
27+
- expression 21 operands: lhs = Expression(40, Add), rhs = Counter(4)
28+
- expression 22 operands: lhs = Expression(41, Add), rhs = Counter(3)
29+
- expression 23 operands: lhs = Zero, rhs = Counter(2)
30+
- expression 24 operands: lhs = Expression(25, Add), rhs = Counter(10)
31+
- expression 25 operands: lhs = Expression(38, Add), rhs = Counter(9)
32+
- expression 26 operands: lhs = Expression(39, Add), rhs = Counter(5)
33+
- expression 27 operands: lhs = Expression(40, Add), rhs = Counter(4)
34+
- expression 28 operands: lhs = Expression(41, Add), rhs = Counter(3)
35+
- expression 29 operands: lhs = Zero, rhs = Counter(2)
36+
- expression 30 operands: lhs = Expression(39, Add), rhs = Counter(5)
37+
- expression 31 operands: lhs = Expression(40, Add), rhs = Counter(4)
38+
- expression 32 operands: lhs = Expression(41, Add), rhs = Counter(3)
39+
- expression 33 operands: lhs = Zero, rhs = Counter(2)
40+
- expression 34 operands: lhs = Expression(35, Add), rhs = Counter(9)
41+
- expression 35 operands: lhs = Expression(36, Add), rhs = Counter(8)
42+
- expression 36 operands: lhs = Expression(37, Add), rhs = Counter(7)
43+
- expression 37 operands: lhs = Expression(38, Add), rhs = Counter(6)
44+
- expression 38 operands: lhs = Expression(39, Add), rhs = Counter(5)
45+
- expression 39 operands: lhs = Expression(40, Add), rhs = Counter(4)
46+
- expression 40 operands: lhs = Expression(41, Add), rhs = Counter(3)
47+
- expression 41 operands: lhs = Zero, rhs = Counter(2)
48+
Number of file 0 mappings: 16
1549
- Code(Counter(0)) at (prev + 48, 1) to (start + 1, 16)
1650
- Code(Counter(10)) at (prev + 3, 11) to (start + 0, 16)
17-
- Code(Counter(6)) at (prev + 1, 17) to (start + 0, 41)
51+
- Branch { true: Counter(13), false: Expression(0, Sub) } at (prev + 1, 9) to (start + 0, 19)
52+
true = c13
53+
false = (((((((((Zero + c2) + c3) + c4) + c5) + c9) + c8) + c7) + c6) - c13)
54+
- Code(Counter(6)) at (prev + 0, 17) to (start + 0, 41)
1855
- Branch { true: Counter(6), false: Counter(2) } at (prev + 0, 23) to (start + 0, 27)
1956
true = c6
2057
false = c2
21-
- Code(Counter(7)) at (prev + 1, 17) to (start + 0, 41)
58+
- Branch { true: Counter(12), false: Expression(9, Sub) } at (prev + 1, 9) to (start + 0, 19)
59+
true = c12
60+
false = ((((((((Zero + c2) + c3) + c4) + c5) + c9) + c8) + c7) - c12)
61+
- Code(Counter(7)) at (prev + 0, 17) to (start + 0, 41)
2262
- Branch { true: Counter(7), false: Counter(3) } at (prev + 0, 23) to (start + 0, 27)
2363
true = c7
2464
false = c3
25-
- Code(Counter(8)) at (prev + 1, 17) to (start + 0, 41)
65+
- Branch { true: Counter(11), false: Expression(17, Sub) } at (prev + 1, 9) to (start + 0, 19)
66+
true = c11
67+
false = (((((((Zero + c2) + c3) + c4) + c5) + c9) + c8) - c11)
68+
- Code(Counter(8)) at (prev + 0, 17) to (start + 0, 41)
2669
- Branch { true: Counter(8), false: Counter(4) } at (prev + 0, 23) to (start + 0, 27)
2770
true = c8
2871
false = c4
29-
- Code(Counter(9)) at (prev + 1, 17) to (start + 0, 41)
72+
- Branch { true: Counter(10), false: Expression(24, Sub) } at (prev + 1, 9) to (start + 0, 19)
73+
true = c10
74+
false = ((((((Zero + c2) + c3) + c4) + c5) + c9) - c10)
75+
- Code(Counter(9)) at (prev + 0, 17) to (start + 0, 41)
3076
- Branch { true: Counter(9), false: Counter(5) } at (prev + 0, 23) to (start + 0, 27)
3177
true = c9
3278
false = c5
33-
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 24)
79+
- Code(Expression(38, Add)) at (prev + 1, 14) to (start + 0, 24)
3480
= ((((Zero + c2) + c3) + c4) + c5)
35-
- Code(Expression(4, Add)) at (prev + 3, 5) to (start + 1, 2)
81+
- Code(Expression(34, Add)) at (prev + 3, 5) to (start + 1, 2)
3682
= ((((((((Zero + c2) + c3) + c4) + c5) + c6) + c7) + c8) + c9)
3783

3884
Function name: match_arms::match_arms
39-
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]
85+
Raw bytes (102): 0x[01, 01, 15, 17, 0d, 4a, 09, 05, 4f, 53, 11, 09, 0d, 4a, 09, 05, 4f, 53, 11, 09, 0d, 05, 4f, 53, 11, 09, 0d, 05, 4f, 53, 11, 09, 0d, 43, 4a, 47, 09, 11, 0d, 05, 4f, 53, 11, 09, 0d, 0a, 01, 18, 01, 01, 10, 05, 03, 0b, 00, 10, 20, 11, 03, 01, 09, 00, 13, 11, 00, 11, 00, 21, 20, 0d, 17, 01, 09, 00, 13, 0d, 00, 11, 00, 21, 20, 09, 4a, 01, 09, 00, 13, 09, 00, 11, 00, 21, 4a, 01, 11, 00, 21, 3f, 03, 05, 01, 02]
4086
Number of files: 1
4187
- file 0 => global file 1
42-
Number of expressions: 6
43-
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Add)
44-
- expression 1 operands: lhs = Expression(2, Add), rhs = Counter(4)
45-
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
46-
- expression 3 operands: lhs = Expression(4, Add), rhs = Expression(0, Sub)
47-
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(2)
48-
- expression 5 operands: lhs = Counter(4), rhs = Counter(3)
49-
Number of file 0 mappings: 7
88+
Number of expressions: 21
89+
- expression 0 operands: lhs = Expression(5, Add), rhs = Counter(3)
90+
- expression 1 operands: lhs = Expression(18, Sub), rhs = Counter(2)
91+
- expression 2 operands: lhs = Counter(1), rhs = Expression(19, Add)
92+
- expression 3 operands: lhs = Expression(20, Add), rhs = Counter(4)
93+
- expression 4 operands: lhs = Counter(2), rhs = Counter(3)
94+
- expression 5 operands: lhs = Expression(18, Sub), rhs = Counter(2)
95+
- expression 6 operands: lhs = Counter(1), rhs = Expression(19, Add)
96+
- expression 7 operands: lhs = Expression(20, Add), rhs = Counter(4)
97+
- expression 8 operands: lhs = Counter(2), rhs = Counter(3)
98+
- expression 9 operands: lhs = Counter(1), rhs = Expression(19, Add)
99+
- expression 10 operands: lhs = Expression(20, Add), rhs = Counter(4)
100+
- expression 11 operands: lhs = Counter(2), rhs = Counter(3)
101+
- expression 12 operands: lhs = Counter(1), rhs = Expression(19, Add)
102+
- expression 13 operands: lhs = Expression(20, Add), rhs = Counter(4)
103+
- expression 14 operands: lhs = Counter(2), rhs = Counter(3)
104+
- expression 15 operands: lhs = Expression(16, Add), rhs = Expression(18, Sub)
105+
- expression 16 operands: lhs = Expression(17, Add), rhs = Counter(2)
106+
- expression 17 operands: lhs = Counter(4), rhs = Counter(3)
107+
- expression 18 operands: lhs = Counter(1), rhs = Expression(19, Add)
108+
- expression 19 operands: lhs = Expression(20, Add), rhs = Counter(4)
109+
- expression 20 operands: lhs = Counter(2), rhs = Counter(3)
110+
Number of file 0 mappings: 10
50111
- Code(Counter(0)) at (prev + 24, 1) to (start + 1, 16)
51112
- Code(Counter(1)) at (prev + 3, 11) to (start + 0, 16)
52-
- Code(Counter(4)) at (prev + 1, 17) to (start + 0, 33)
53-
- Code(Counter(3)) at (prev + 1, 17) to (start + 0, 33)
54-
- Code(Counter(2)) at (prev + 1, 17) to (start + 0, 33)
55-
- Code(Expression(0, Sub)) at (prev + 1, 17) to (start + 0, 33)
113+
- Branch { true: Counter(4), false: Expression(0, Add) } at (prev + 1, 9) to (start + 0, 19)
114+
true = c4
115+
false = (((c1 - ((c2 + c3) + c4)) + c2) + c3)
116+
- Code(Counter(4)) at (prev + 0, 17) to (start + 0, 33)
117+
- Branch { true: Counter(3), false: Expression(5, Add) } at (prev + 1, 9) to (start + 0, 19)
118+
true = c3
119+
false = ((c1 - ((c2 + c3) + c4)) + c2)
120+
- Code(Counter(3)) at (prev + 0, 17) to (start + 0, 33)
121+
- Branch { true: Counter(2), false: Expression(18, Sub) } at (prev + 1, 9) to (start + 0, 19)
122+
true = c2
123+
false = (c1 - ((c2 + c3) + c4))
124+
- Code(Counter(2)) at (prev + 0, 17) to (start + 0, 33)
125+
- Code(Expression(18, Sub)) at (prev + 1, 17) to (start + 0, 33)
56126
= (c1 - ((c2 + c3) + c4))
57-
- Code(Expression(3, Add)) at (prev + 3, 5) to (start + 1, 2)
127+
- Code(Expression(15, Add)) at (prev + 3, 5) to (start + 1, 2)
58128
= (((c4 + c3) + c2) + (c1 - ((c2 + c3) + c4)))
59129

60130
Function name: match_arms::or_patterns

‎tests/coverage/branch/match-arms.coverage

+14-1
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,17 @@
2626
LL| |
2727
LL| 15| match value {
2828
LL| 8| Enum::D(d) => consume(d),
29+
------------------
30+
| Branch (LL:9): [True: 8, False: 7]
31+
------------------
2932
LL| 4| Enum::C(c) => consume(c),
33+
------------------
34+
| Branch (LL:9): [True: 4, False: 3]
35+
------------------
3036
LL| 2| Enum::B(b) => consume(b),
37+
------------------
38+
| Branch (LL:9): [True: 2, False: 1]
39+
------------------
3140
LL| 1| Enum::A(a) => consume(a),
3241
LL| | }
3342
LL| |
@@ -53,18 +62,22 @@
5362
LL| 3| match value {
5463
LL| 8| Enum::D(d) if cond => consume(d),
5564
------------------
65+
| Branch (LL:9): [True: 24, False: 21]
5666
| Branch (LL:23): [True: 8, False: 16]
5767
------------------
5868
LL| 4| Enum::C(c) if cond => consume(c),
5969
------------------
70+
| Branch (LL:9): [True: 12, False: 25]
6071
| Branch (LL:23): [True: 4, False: 8]
6172
------------------
6273
LL| 2| Enum::B(b) if cond => consume(b),
6374
------------------
75+
| Branch (LL:9): [True: 6, False: 27]
6476
| Branch (LL:23): [True: 2, False: 4]
6577
------------------
6678
LL| 1| Enum::A(a) if cond => consume(a),
6779
------------------
80+
| Branch (LL:9): [True: 3, False: 28]
6881
| Branch (LL:23): [True: 1, False: 2]
6982
------------------
7083
LL| 30| _ => consume(0),
@@ -101,5 +114,5 @@
101114
LL| | }
102115
LL| |}
103116
LL| |
104-
LL| |// FIXME(#124118) Actually instrument match arms for branch coverage.
117+
LL| |// FIXME(#124118) Support match expressions with or-patterns.
105118

‎tests/coverage/branch/match-arms.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -87,4 +87,4 @@ fn main() {
8787
}
8888
}
8989

90-
// FIXME(#124118) Actually instrument match arms for branch coverage.
90+
// FIXME(#124118) Support match expressions with or-patterns.

‎tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff

+21
Original file line numberDiff line numberDiff line change
@@ -26,12 +26,25 @@
2626
debug a => _9;
2727
}
2828

29+
coverage branches {
30+
BlockMarkerId(0), BlockMarkerId(1) => $DIR/branch_match_arms.rs:16:9: 16:19 (#0)
31+
BlockMarkerId(2), BlockMarkerId(3) => $DIR/branch_match_arms.rs:17:9: 17:19 (#0)
32+
BlockMarkerId(4), BlockMarkerId(5) => $DIR/branch_match_arms.rs:18:9: 18:19 (#0)
33+
BlockMarkerId(6), BlockMarkerId(7) => $DIR/branch_match_arms.rs:19:9: 19:19 (#0)
34+
}
35+
2936
+ coverage ExpressionId(0) => Expression { lhs: Counter(1), op: Add, rhs: Counter(2) };
3037
+ coverage ExpressionId(1) => Expression { lhs: Expression(0), op: Add, rhs: Counter(3) };
3138
+ coverage ExpressionId(2) => Expression { lhs: Counter(0), op: Subtract, rhs: Expression(1) };
3239
+ coverage ExpressionId(3) => Expression { lhs: Counter(3), op: Add, rhs: Counter(2) };
3340
+ coverage ExpressionId(4) => Expression { lhs: Expression(3), op: Add, rhs: Counter(1) };
3441
+ coverage ExpressionId(5) => Expression { lhs: Expression(4), op: Add, rhs: Expression(2) };
42+
+ coverage ExpressionId(6) => Expression { lhs: Expression(2), op: Add, rhs: Counter(1) };
43+
+ coverage ExpressionId(7) => Expression { lhs: Expression(6), op: Add, rhs: Counter(2) };
44+
+ coverage ExpressionId(8) => Expression { lhs: Expression(7), op: Add, rhs: Counter(3) };
45+
+ coverage Branch { true_term: Counter(1), false_term: Expression(2) } => $DIR/branch_match_arms.rs:18:9 - 18:19;
46+
+ coverage Branch { true_term: Counter(2), false_term: Expression(6) } => $DIR/branch_match_arms.rs:17:9 - 17:19;
47+
+ coverage Branch { true_term: Counter(3), false_term: Expression(7) } => $DIR/branch_match_arms.rs:16:9 - 16:19;
3548
+ coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:14:1 - 15:21;
3649
+ coverage Code(Counter(3)) => $DIR/branch_match_arms.rs:16:17 - 16:33;
3750
+ coverage Code(Counter(2)) => $DIR/branch_match_arms.rs:17:17 - 17:33;
@@ -55,16 +68,19 @@
5568

5669
bb2: {
5770
+ Coverage::CounterIncrement(3);
71+
Coverage::BlockMarker(0);
5872
falseEdge -> [real: bb6, imaginary: bb3];
5973
}
6074

6175
bb3: {
6276
+ Coverage::CounterIncrement(2);
77+
Coverage::BlockMarker(2);
6378
falseEdge -> [real: bb8, imaginary: bb4];
6479
}
6580

6681
bb4: {
6782
+ Coverage::CounterIncrement(1);
83+
Coverage::BlockMarker(4);
6884
falseEdge -> [real: bb10, imaginary: bb5];
6985
}
7086

@@ -74,6 +90,8 @@
7490
_9 = ((_1 as A).0: u32);
7591
StorageLive(_10);
7692
_10 = _9;
93+
Coverage::BlockMarker(6);
94+
Coverage::BlockMarker(7);
7795
_0 = consume(move _10) -> [return: bb12, unwind: bb14];
7896
}
7997

@@ -82,6 +100,7 @@
82100
_3 = ((_1 as D).0: u32);
83101
StorageLive(_4);
84102
_4 = _3;
103+
Coverage::BlockMarker(1);
85104
_0 = consume(move _4) -> [return: bb7, unwind: bb14];
86105
}
87106

@@ -96,6 +115,7 @@
96115
_5 = ((_1 as C).0: u32);
97116
StorageLive(_6);
98117
_6 = _5;
118+
Coverage::BlockMarker(3);
99119
_0 = consume(move _6) -> [return: bb9, unwind: bb14];
100120
}
101121

@@ -110,6 +130,7 @@
110130
_7 = ((_1 as B).0: u32);
111131
StorageLive(_8);
112132
_8 = _7;
133+
Coverage::BlockMarker(5);
113134
_0 = consume(move _8) -> [return: bb11, unwind: bb14];
114135
}
115136

0 commit comments

Comments
 (0)
Please sign in to comment.