Optimize MIR CFG generation for chained logical operators (#83623) by sunny026 · Pull Request #157315 · rust-lang/rust

sunny026 · 2026-06-02T13:51:31Z

Description

This PR resolves the issue where chained logical operators (&& and ||) evaluated into a boolean destination generated suboptimal MIR. Previously, the AST lowering in compiler/rustc_mir_build/src/builder/expr/into.rs recursively invoked expr_into_dest, which allocated duplicate destination = false basic blocks for every operator in the chain. This fractured control flow prevented LLVM's mem2reg pass from recognizing the pattern and blocked auto-vectorization.

Changes

Modified ExprKind::LogicalOp lowering inside into.rs to route the entire expression through then_else_break.
Because then_else_break optimally shares if/then/else scopes without creating temporary booleans, this natively collapses all short-circuiting branches into a single unified success block and a single unified failure block.

Result

LLVM can now instantly convert the unified goto failures into SSA Phi nodes, enabling seamless SIMD vectorization for constructs like #[derive(PartialEq)] on large structs!

rustbot · 2026-06-02T13:51:35Z

Some changes occurred in coverage instrumentation.

cc @Zalathar

rustbot · 2026-06-02T13:51:38Z

Thanks for the pull request, and welcome! The Rust team is excited to review your changes, and you should hear from @nikomatsakis (or someone else) some time within the next two weeks.

Please see the contribution instructions for more information. Namely, in order to ensure the minimum review times lag, PR authors and assigned reviewers should ensure that the review label (S-waiting-on-review and S-waiting-on-author) stays updated, invoking these commands when appropriate:

@rustbot author: the review is finished, PR author should check the comments and take action accordingly
@rustbot review: the author is ready for a review, this PR will be queued again in the reviewer's queue

Why was this reviewer chosen?

The reviewer was selected based on:

Owners of files modified in this PR: compiler, mir
compiler, mir expanded to 73 candidates
Random selection from 18 candidates

cjgillot · 2026-06-02T14:36:36Z

How does this fix the bug? From a glance it looks like it's making it worse. Do you have a test?

rust-log-analyzer · 2026-06-02T14:40:34Z

The job aarch64-gnu-llvm-21-1 failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

test [coverage-map] tests/coverage/uses_inline_crate.rs ... ok

failures:

---- [coverage-map] tests/coverage/branch/lazy-boolean.rs stdout ----
Saved the actual cov-map to `/checkout/obj/build/aarch64-unknown-linux-gnu/test/coverage/branch/lazy-boolean.coverage-map/lazy-boolean.cov-map`
diff of cov-map:

1 Function name: lazy_boolean::branch_and
- Raw bytes (53): 0x[01, 01, 01, 01, 05, 09, 01, 13, 01, 00, 20, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
+ Raw bytes (62): 0x[01, 01, 02, 01, 05, 05, 09, 0a, 01, 13, 01, 00, 20, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
3 Number of files: 1
4 - file 0 => $DIR/lazy-boolean.rs
- Number of expressions: 1
+ Number of expressions: 2
6 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- Number of file 0 mappings: 9
+ - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
+ Number of file 0 mappings: 10
8 - Code(Counter(0)) at (prev + 19, 1) to (start + 0, 32)
9 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
10 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

13     true  = c1
14     false = (c0 - c1)
15 - Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
+ - Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 18) to (start + 0, 19)
+     true  = c2
+     false = (c1 - c2)
16 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
17 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
18 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)

- Highest counter ID seen: c1
+ Highest counter ID seen: c2
20 
21 Function name: lazy_boolean::branch_or
- Raw bytes (53): 0x[01, 01, 01, 01, 05, 09, 01, 1b, 01, 00, 1f, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
+ Raw bytes (64): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 0a, 01, 1b, 01, 00, 1f, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
23 Number of files: 1
24 - file 0 => $DIR/lazy-boolean.rs
- Number of expressions: 1
+ Number of expressions: 3
26 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- Number of file 0 mappings: 9
+ - expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
+ - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
+ Number of file 0 mappings: 10
28 - Code(Counter(0)) at (prev + 27, 1) to (start + 0, 31)
29 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
30 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

34     false = (c0 - c1)
35 - Code(Expression(0, Sub)) at (prev + 0, 18) to (start + 0, 19)
36     = (c0 - c1)
+ - Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 18) to (start + 0, 19)
+     true  = c2
+     false = (c0 - (c1 + c2))
37 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
38 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
39 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)

- Highest counter ID seen: c1
+ Highest counter ID seen: c2
41 
42 Function name: lazy_boolean::chain
- Raw bytes (161): 0x[01, 01, 0f, 01, 05, 05, 09, 09, 0d, 01, 11, 01, 11, 01, 3b, 11, 15, 01, 3b, 11, 15, 01, 37, 3b, 19, 11, 15, 01, 37, 3b, 19, 11, 15, 17, 01, 24, 01, 00, 11, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 05, 02, 00, 0d, 00, 12, 05, 00, 16, 00, 1b, 20, 09, 06, 00, 16, 00, 1b, 09, 00, 1f, 00, 24, 20, 0d, 0a, 00, 1f, 00, 24, 0d, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 11, 12, 00, 0d, 00, 12, 12, 00, 16, 00, 1b, 20, 15, 1e, 00, 16, 00, 1b, 1e, 00, 1f, 00, 24, 20, 19, 32, 00, 1f, 00, 24, 32, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
+ Raw bytes (185): 0x[01, 01, 14, 01, 05, 05, 09, 09, 0d, 0d, 11, 01, 15, 01, 15, 01, 4f, 15, 19, 01, 4f, 15, 19, 01, 4b, 4f, 1d, 15, 19, 01, 4b, 4f, 1d, 15, 19, 01, 47, 4b, 21, 4f, 1d, 15, 19, 19, 01, 24, 01, 00, 11, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 05, 02, 00, 0d, 00, 12, 05, 00, 16, 00, 1b, 20, 09, 06, 00, 16, 00, 1b, 09, 00, 1f, 00, 24, 20, 0d, 0a, 00, 1f, 00, 24, 0d, 00, 28, 00, 2d, 20, 11, 0e, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 15, 16, 00, 0d, 00, 12, 16, 00, 16, 00, 1b, 20, 19, 22, 00, 16, 00, 1b, 22, 00, 1f, 00, 24, 20, 1d, 36, 00, 1f, 00, 24, 36, 00, 28, 00, 2d, 20, 21, 42, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
44 Number of files: 1
45 - file 0 => $DIR/lazy-boolean.rs
- Number of expressions: 15
+ Number of expressions: 20
47 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
48 - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
49 - expression 2 operands: lhs = Counter(2), rhs = Counter(3)

- - expression 3 operands: lhs = Counter(0), rhs = Counter(4)
- - expression 4 operands: lhs = Counter(0), rhs = Counter(4)
- - expression 5 operands: lhs = Counter(0), rhs = Expression(14, Add)
- - expression 6 operands: lhs = Counter(4), rhs = Counter(5)
- - expression 7 operands: lhs = Counter(0), rhs = Expression(14, Add)
- - expression 8 operands: lhs = Counter(4), rhs = Counter(5)
- - expression 9 operands: lhs = Counter(0), rhs = Expression(13, Add)
- - expression 10 operands: lhs = Expression(14, Add), rhs = Counter(6)
- - expression 11 operands: lhs = Counter(4), rhs = Counter(5)
- - expression 12 operands: lhs = Counter(0), rhs = Expression(13, Add)
- - expression 13 operands: lhs = Expression(14, Add), rhs = Counter(6)
- - expression 14 operands: lhs = Counter(4), rhs = Counter(5)
- Number of file 0 mappings: 23
+ - expression 3 operands: lhs = Counter(3), rhs = Counter(4)
+ - expression 4 operands: lhs = Counter(0), rhs = Counter(5)
+ - expression 5 operands: lhs = Counter(0), rhs = Counter(5)
+ - expression 6 operands: lhs = Counter(0), rhs = Expression(19, Add)
+ - expression 7 operands: lhs = Counter(5), rhs = Counter(6)
+ - expression 8 operands: lhs = Counter(0), rhs = Expression(19, Add)
+ - expression 9 operands: lhs = Counter(5), rhs = Counter(6)
+ - expression 10 operands: lhs = Counter(0), rhs = Expression(18, Add)
+ - expression 11 operands: lhs = Expression(19, Add), rhs = Counter(7)
+ - expression 12 operands: lhs = Counter(5), rhs = Counter(6)
+ - expression 13 operands: lhs = Counter(0), rhs = Expression(18, Add)
+ - expression 14 operands: lhs = Expression(19, Add), rhs = Counter(7)
+ - expression 15 operands: lhs = Counter(5), rhs = Counter(6)
+ - expression 16 operands: lhs = Counter(0), rhs = Expression(17, Add)
+ - expression 17 operands: lhs = Expression(18, Add), rhs = Counter(8)
+ - expression 18 operands: lhs = Expression(19, Add), rhs = Counter(7)
+ - expression 19 operands: lhs = Counter(5), rhs = Counter(6)
+ Number of file 0 mappings: 25
63 - Code(Counter(0)) at (prev + 36, 1) to (start + 0, 17)
64 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
65 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

76     true  = c3
77     false = (c2 - c3)
78 - Code(Counter(3)) at (prev + 0, 40) to (start + 0, 45)
+ - Branch { true: Counter(4), false: Expression(3, Sub) } at (prev + 0, 40) to (start + 0, 45)
+     true  = c4
+     false = (c3 - c4)
79 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
80 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
81 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

82 - Code(Counter(0)) at (prev + 0, 13) to (start + 0, 18)
- - Branch { true: Counter(4), false: Expression(4, Sub) } at (prev + 0, 13) to (start + 0, 18)
-     true  = c4
-     false = (c0 - c4)
- - Code(Expression(4, Sub)) at (prev + 0, 22) to (start + 0, 27)
-     = (c0 - c4)
- - Branch { true: Counter(5), false: Expression(7, Sub) } at (prev + 0, 22) to (start + 0, 27)
+ - Branch { true: Counter(5), false: Expression(5, Sub) } at (prev + 0, 13) to (start + 0, 18)
89     true  = c5
-     false = (c0 - (c4 + c5))
- - Code(Expression(7, Sub)) at (prev + 0, 31) to (start + 0, 36)
-     = (c0 - (c4 + c5))
- - Branch { true: Counter(6), false: Expression(12, Sub) } at (prev + 0, 31) to (start + 0, 36)
+     false = (c0 - c5)
+ - Code(Expression(5, Sub)) at (prev + 0, 22) to (start + 0, 27)
+     = (c0 - c5)
+ - Branch { true: Counter(6), false: Expression(8, Sub) } at (prev + 0, 22) to (start + 0, 27)
94     true  = c6
-     false = (c0 - ((c4 + c5) + c6))
- - Code(Expression(12, Sub)) at (prev + 0, 40) to (start + 0, 45)
-     = (c0 - ((c4 + c5) + c6))
+     false = (c0 - (c5 + c6))
+ - Code(Expression(8, Sub)) at (prev + 0, 31) to (start + 0, 36)
+     = (c0 - (c5 + c6))
+ - Branch { true: Counter(7), false: Expression(13, Sub) } at (prev + 0, 31) to (start + 0, 36)
+     true  = c7
+     false = (c0 - ((c5 + c6) + c7))
+ - Code(Expression(13, Sub)) at (prev + 0, 40) to (start + 0, 45)
+     = (c0 - ((c5 + c6) + c7))
+ - Branch { true: Counter(8), false: Expression(16, Sub) } at (prev + 0, 40) to (start + 0, 45)
+     true  = c8
+     false = (c0 - (((c5 + c6) + c7) + c8))
98 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
99 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
100 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)

- Highest counter ID seen: c6
+ Highest counter ID seen: c8
102 
103 Function name: lazy_boolean::nested_mixed
- Raw bytes (157): 0x[01, 01, 0d, 01, 05, 01, 1f, 05, 09, 05, 09, 1f, 0d, 05, 09, 1f, 0d, 05, 09, 01, 11, 11, 15, 01, 15, 01, 33, 15, 19, 17, 01, 31, 01, 00, 18, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 05, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 09, 06, 00, 17, 00, 1d, 1f, 00, 23, 00, 28, 20, 0d, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 11, 22, 00, 0e, 00, 13, 11, 00, 17, 00, 1c, 20, 15, 26, 00, 17, 00, 1c, 2a, 00, 22, 00, 28, 20, 19, 2e, 00, 22, 00, 28, 19, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
+ Raw bytes (179): 0x[01, 01, 11, 01, 05, 01, 27, 05, 09, 05, 09, 27, 0d, 05, 09, 27, 0d, 05, 09, 27, 2b, 05, 09, 0d, 21, 01, 11, 11, 15, 01, 15, 01, 3f, 15, 19, 19, 1d, 19, 01, 31, 01, 00, 18, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 05, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 09, 06, 00, 17, 00, 1d, 27, 00, 23, 00, 28, 20, 0d, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 20, 21, 22, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 11, 2e, 00, 0e, 00, 13, 11, 00, 17, 00, 1c, 20, 15, 32, 00, 17, 00, 1c, 36, 00, 22, 00, 28, 20, 19, 3a, 00, 22, 00, 28, 19, 00, 2c, 00, 33, 20, 1d, 42, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
105 Number of files: 1
106 - file 0 => $DIR/lazy-boolean.rs
- Number of expressions: 13
+ Number of expressions: 17
108 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- - expression 1 operands: lhs = Counter(0), rhs = Expression(7, Add)
+ - expression 1 operands: lhs = Counter(0), rhs = Expression(9, Add)
110 - expression 2 operands: lhs = Counter(1), rhs = Counter(2)
111 - expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- - expression 4 operands: lhs = Expression(7, Add), rhs = Counter(3)
+ - expression 4 operands: lhs = Expression(9, Add), rhs = Counter(3)
113 - expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- - expression 6 operands: lhs = Expression(7, Add), rhs = Counter(3)
+ - expression 6 operands: lhs = Expression(9, Add), rhs = Counter(3)
115 - expression 7 operands: lhs = Counter(1), rhs = Counter(2)
- - expression 8 operands: lhs = Counter(0), rhs = Counter(4)
- - expression 9 operands: lhs = Counter(4), rhs = Counter(5)
- - expression 10 operands: lhs = Counter(0), rhs = Counter(5)
- - expression 11 operands: lhs = Counter(0), rhs = Expression(12, Add)
- - expression 12 operands: lhs = Counter(5), rhs = Counter(6)
- Number of file 0 mappings: 23
+ - expression 8 operands: lhs = Expression(9, Add), rhs = Expression(10, Add)
+ - expression 9 operands: lhs = Counter(1), rhs = Counter(2)
+ - expression 10 operands: lhs = Counter(3), rhs = Counter(8)
+ - expression 11 operands: lhs = Counter(0), rhs = Counter(4)
+ - expression 12 operands: lhs = Counter(4), rhs = Counter(5)
+ - expression 13 operands: lhs = Counter(0), rhs = Counter(5)
+ - expression 14 operands: lhs = Counter(0), rhs = Expression(15, Add)
+ - expression 15 operands: lhs = Counter(5), rhs = Counter(6)
+ - expression 16 operands: lhs = Counter(6), rhs = Counter(7)
+ Number of file 0 mappings: 25
122 - Code(Counter(0)) at (prev + 49, 1) to (start + 0, 24)
123 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
124 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

131 - Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 23) to (start + 0, 29)
132     true  = c2
133     false = (c0 - (c1 + c2))
- - Code(Expression(7, Add)) at (prev + 0, 35) to (start + 0, 40)
+ - Code(Expression(9, Add)) at (prev + 0, 35) to (start + 0, 40)
135     = (c1 + c2)
136 - Branch { true: Counter(3), false: Expression(6, Sub) } at (prev + 0, 35) to (start + 0, 40)
137     true  = c3

138     false = ((c1 + c2) - c3)
139 - Code(Expression(6, Sub)) at (prev + 0, 44) to (start + 0, 51)
140     = ((c1 + c2) - c3)
+ - Branch { true: Counter(8), false: Expression(8, Sub) } at (prev + 0, 44) to (start + 0, 51)
+     true  = c8
+     false = ((c1 + c2) - (c3 + c8))
141 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
142 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
143 - Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)

144 - Code(Counter(0)) at (prev + 0, 14) to (start + 0, 19)
- - Branch { true: Counter(4), false: Expression(8, Sub) } at (prev + 0, 14) to (start + 0, 19)
+ - Branch { true: Counter(4), false: Expression(11, Sub) } at (prev + 0, 14) to (start + 0, 19)
146     true  = c4
147     false = (c0 - c4)
148 - Code(Counter(4)) at (prev + 0, 23) to (start + 0, 28)

- - Branch { true: Counter(5), false: Expression(9, Sub) } at (prev + 0, 23) to (start + 0, 28)
+ - Branch { true: Counter(5), false: Expression(12, Sub) } at (prev + 0, 23) to (start + 0, 28)
150     true  = c5
151     false = (c4 - c5)
- - Code(Expression(10, Sub)) at (prev + 0, 34) to (start + 0, 40)
+ - Code(Expression(13, Sub)) at (prev + 0, 34) to (start + 0, 40)
153     = (c0 - c5)
- - Branch { true: Counter(6), false: Expression(11, Sub) } at (prev + 0, 34) to (start + 0, 40)
+ - Branch { true: Counter(6), false: Expression(14, Sub) } at (prev + 0, 34) to (start + 0, 40)
155     true  = c6
156     false = (c0 - (c5 + c6))
157 - Code(Counter(6)) at (prev + 0, 44) to (start + 0, 51)

+ - Branch { true: Counter(7), false: Expression(16, Sub) } at (prev + 0, 44) to (start + 0, 51)
+     true  = c7
+     false = (c6 - c7)
158 - Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
159 - Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
160 - Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)

- Highest counter ID seen: c6
+ Highest counter ID seen: c8
162 
163 


The actual cov-map differed from the expected cov-map

error: an error occurred comparing coverage output.
status: exit status: 0
command: "/checkout/obj/build/aarch64-unknown-linux-gnu/stage1-tools-bin/coverage-dump" "/checkout/obj/build/aarch64-unknown-linux-gnu/test/coverage/branch/lazy-boolean.coverage-map/lazy-boolean.ll"
--- stdout -------------------------------
Function name: lazy_boolean::branch_and
Raw bytes (62): 0x[01, 01, 02, 01, 05, 05, 09, 0a, 01, 13, 01, 00, 20, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 05, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => /checkout/tests/coverage/branch/lazy-boolean.rs
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 32)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(0, 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(1, Sub) } at (prev + 0, 18) to (start + 0, 19)
    true  = c2
    false = (c1 - c2)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
Highest counter ID seen: c2

Function name: lazy_boolean::branch_or
Raw bytes (64): 0x[01, 01, 03, 01, 05, 01, 0b, 05, 09, 0a, 01, 1b, 01, 00, 1f, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 02, 00, 0d, 00, 0e, 02, 00, 12, 00, 13, 20, 09, 06, 00, 12, 00, 13, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => /checkout/tests/coverage/branch/lazy-boolean.rs
Number of expressions: 3
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Expression(2, Add)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 27, 1) to (start + 0, 31)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 14)
- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 14)
    true  = c1
    false = (c0 - c1)
- Code(Expression(0, Sub)) at (prev + 0, 18) to (start + 0, 19)
    = (c0 - c1)
- Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 18) to (start + 0, 19)
    true  = c2
    false = (c0 - (c1 + c2))
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
Highest counter ID seen: c2

Function name: lazy_boolean::chain
Raw bytes (185): 0x[01, 01, 14, 01, 05, 05, 09, 09, 0d, 0d, 11, 01, 15, 01, 15, 01, 4f, 15, 19, 01, 4f, 15, 19, 01, 4b, 4f, 1d, 15, 19, 01, 4b, 4f, 1d, 15, 19, 01, 47, 4b, 21, 4f, 1d, 15, 19, 19, 01, 24, 01, 00, 11, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 05, 02, 00, 0d, 00, 12, 05, 00, 16, 00, 1b, 20, 09, 06, 00, 16, 00, 1b, 09, 00, 1f, 00, 24, 20, 0d, 0a, 00, 1f, 00, 24, 0d, 00, 28, 00, 2d, 20, 11, 0e, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0d, 00, 12, 20, 15, 16, 00, 0d, 00, 12, 16, 00, 16, 00, 1b, 20, 19, 22, 00, 16, 00, 1b, 22, 00, 1f, 00, 24, 20, 1d, 36, 00, 1f, 00, 24, 36, 00, 28, 00, 2d, 20, 21, 42, 00, 28, 00, 2d, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => /checkout/tests/coverage/branch/lazy-boolean.rs
Number of expressions: 20
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
- expression 2 operands: lhs = Counter(2), rhs = Counter(3)
- expression 3 operands: lhs = Counter(3), rhs = Counter(4)
- expression 4 operands: lhs = Counter(0), rhs = Counter(5)
- expression 5 operands: lhs = Counter(0), rhs = Counter(5)
- expression 6 operands: lhs = Counter(0), rhs = Expression(19, Add)
- expression 7 operands: lhs = Counter(5), rhs = Counter(6)
- expression 8 operands: lhs = Counter(0), rhs = Expression(19, Add)
- expression 9 operands: lhs = Counter(5), rhs = Counter(6)
- expression 10 operands: lhs = Counter(0), rhs = Expression(18, Add)
- expression 11 operands: lhs = Expression(19, Add), rhs = Counter(7)
- expression 12 operands: lhs = Counter(5), rhs = Counter(6)
- expression 13 operands: lhs = Counter(0), rhs = Expression(18, Add)
- expression 14 operands: lhs = Expression(19, Add), rhs = Counter(7)
- expression 15 operands: lhs = Counter(5), rhs = Counter(6)
- expression 16 operands: lhs = Counter(0), rhs = Expression(17, Add)
- expression 17 operands: lhs = Expression(18, Add), rhs = Counter(8)
- expression 18 operands: lhs = Expression(19, Add), rhs = Counter(7)
- expression 19 operands: lhs = Counter(5), rhs = Counter(6)
Number of file 0 mappings: 25
- Code(Counter(0)) at (prev + 36, 1) to (start + 0, 17)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 18)
- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 13) to (start + 0, 18)
    true  = c1
    false = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 22) to (start + 0, 27)
- Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 22) to (start + 0, 27)
    true  = c2
    false = (c1 - c2)
- Code(Counter(2)) at (prev + 0, 31) to (start + 0, 36)
- Branch { true: Counter(3), false: Expression(2, Sub) } at (prev + 0, 31) to (start + 0, 36)
    true  = c3
    false = (c2 - c3)
- Code(Counter(3)) at (prev + 0, 40) to (start + 0, 45)
- Branch { true: Counter(4), false: Expression(3, Sub) } at (prev + 0, 40) to (start + 0, 45)
    true  = c4
    false = (c3 - c4)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 13) to (start + 0, 18)
- Branch { true: Counter(5), false: Expression(5, Sub) } at (prev + 0, 13) to (start + 0, 18)
    true  = c5
    false = (c0 - c5)
- Code(Expression(5, Sub)) at (prev + 0, 22) to (start + 0, 27)
    = (c0 - c5)
- Branch { true: Counter(6), false: Expression(8, Sub) } at (prev + 0, 22) to (start + 0, 27)
    true  = c6
    false = (c0 - (c5 + c6))
- Code(Expression(8, Sub)) at (prev + 0, 31) to (start + 0, 36)
    = (c0 - (c5 + c6))
- Branch { true: Counter(7), false: Expression(13, Sub) } at (prev + 0, 31) to (start + 0, 36)
    true  = c7
    false = (c0 - ((c5 + c6) + c7))
- Code(Expression(13, Sub)) at (prev + 0, 40) to (start + 0, 45)
    = (c0 - ((c5 + c6) + c7))
- Branch { true: Counter(8), false: Expression(16, Sub) } at (prev + 0, 40) to (start + 0, 45)
    true  = c8
    false = (c0 - (((c5 + c6) + c7) + c8))
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
Highest counter ID seen: c8

Function name: lazy_boolean::nested_mixed
Raw bytes (179): 0x[01, 01, 11, 01, 05, 01, 27, 05, 09, 05, 09, 27, 0d, 05, 09, 27, 0d, 05, 09, 27, 2b, 05, 09, 0d, 21, 01, 11, 11, 15, 01, 15, 01, 3f, 15, 19, 19, 1d, 19, 01, 31, 01, 00, 18, 01, 01, 05, 00, 0e, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 05, 02, 00, 0e, 00, 13, 02, 00, 17, 00, 1d, 20, 09, 06, 00, 17, 00, 1d, 27, 00, 23, 00, 28, 20, 0d, 1a, 00, 23, 00, 28, 1a, 00, 2c, 00, 33, 20, 21, 22, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 03, 09, 00, 0a, 01, 00, 0e, 00, 13, 20, 11, 2e, 00, 0e, 00, 13, 11, 00, 17, 00, 1c, 20, 15, 32, 00, 17, 00, 1c, 36, 00, 22, 00, 28, 20, 19, 3a, 00, 22, 00, 28, 19, 00, 2c, 00, 33, 20, 1d, 42, 00, 2c, 00, 33, 01, 01, 05, 00, 0e, 01, 00, 0f, 00, 10, 01, 01, 01, 00, 02]
Number of files: 1
- file 0 => /checkout/tests/coverage/branch/lazy-boolean.rs
Number of expressions: 17
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(0), rhs = Expression(9, Add)
- expression 2 operands: lhs = Counter(1), rhs = Counter(2)
- expression 3 operands: lhs = Counter(1), rhs = Counter(2)
- expression 4 operands: lhs = Expression(9, Add), rhs = Counter(3)
- expression 5 operands: lhs = Counter(1), rhs = Counter(2)
- expression 6 operands: lhs = Expression(9, Add), rhs = Counter(3)
- expression 7 operands: lhs = Counter(1), rhs = Counter(2)
- expression 8 operands: lhs = Expression(9, Add), rhs = Expression(10, Add)
- expression 9 operands: lhs = Counter(1), rhs = Counter(2)
- expression 10 operands: lhs = Counter(3), rhs = Counter(8)
- expression 11 operands: lhs = Counter(0), rhs = Counter(4)
- expression 12 operands: lhs = Counter(4), rhs = Counter(5)
- expression 13 operands: lhs = Counter(0), rhs = Counter(5)
- expression 14 operands: lhs = Counter(0), rhs = Expression(15, Add)
- expression 15 operands: lhs = Counter(5), rhs = Counter(6)
- expression 16 operands: lhs = Counter(6), rhs = Counter(7)
Number of file 0 mappings: 25
- Code(Counter(0)) at (prev + 49, 1) to (start + 0, 24)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 19)
- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 0, 14) to (start + 0, 19)
    true  = c1
    false = (c0 - c1)
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 29)
    = (c0 - c1)
- Branch { true: Counter(2), false: Expression(1, Sub) } at (prev + 0, 23) to (start + 0, 29)
    true  = c2
    false = (c0 - (c1 + c2))
- Code(Expression(9, Add)) at (prev + 0, 35) to (start + 0, 40)
    = (c1 + c2)
- Branch { true: Counter(3), false: Expression(6, Sub) } at (prev + 0, 35) to (start + 0, 40)
    true  = c3
    false = ((c1 + c2) - c3)
- Code(Expression(6, Sub)) at (prev + 0, 44) to (start + 0, 51)
    = ((c1 + c2) - c3)
- Branch { true: Counter(8), false: Expression(8, Sub) } at (prev + 0, 44) to (start + 0, 51)
    true  = c8
    false = ((c1 + c2) - (c3 + c8))
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 3, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 19)
- Branch { true: Counter(4), false: Expression(11, Sub) } at (prev + 0, 14) to (start + 0, 19)
    true  = c4
    false = (c0 - c4)
- Code(Counter(4)) at (prev + 0, 23) to (start + 0, 28)
- Branch { true: Counter(5), false: Expression(12, Sub) } at (prev + 0, 23) to (start + 0, 28)
    true  = c5
    false = (c4 - c5)
- Code(Expression(13, Sub)) at (prev + 0, 34) to (start + 0, 40)
    = (c0 - c5)
- Branch { true: Counter(6), false: Expression(14, Sub) } at (prev + 0, 34) to (start + 0, 40)
    true  = c6
    false = (c0 - (c5 + c6))
- Code(Counter(6)) at (prev + 0, 44) to (start + 0, 51)
- Branch { true: Counter(7), false: Expression(16, Sub) } at (prev + 0, 44) to (start + 0, 51)
    true  = c7
    false = (c6 - c7)
- Code(Counter(0)) at (prev + 1, 5) to (start + 0, 14)
- Code(Counter(0)) at (prev + 0, 15) to (start + 0, 16)
- Code(Counter(0)) at (prev + 1, 1) to (start + 0, 2)
Highest counter ID seen: c8
------------------------------------------
stderr: none

---- [coverage-map] tests/coverage/branch/lazy-boolean.rs stdout end ----
---- [coverage-map] tests/coverage/unreachable.rs stdout ----
Saved the actual cov-map to `/checkout/obj/build/aarch64-unknown-linux-gnu/test/coverage/unreachable.coverage-map/unreachable.cov-map`
diff of cov-map:

- Function name: unreachable::UNREACHABLE_CLOSURE::{closure#0} (unused)
- Raw bytes (9): 0x[01, 01, 00, 01, 00, 0e, 30, 00, 45]
+ Function name: unreachable::UNREACHABLE_CLOSURE::{closure#0}
+ Raw bytes (9): 0x[01, 01, 00, 01, 01, 0e, 30, 00, 45]
3 Number of files: 1
4 - file 0 => $DIR/unreachable.rs
5 Number of expressions: 0

6 Number of file 0 mappings: 1
- - Code(Zero) at (prev + 14, 48) to (start + 0, 69)
- Highest counter ID seen: (none)
+ - Code(Counter(0)) at (prev + 14, 48) to (start + 0, 69)
+ Highest counter ID seen: c0
9 
10 Function name: unreachable::unreachable_function (unused)
11 Raw bytes (14): 0x[01, 01, 00, 02, 00, 10, 01, 00, 1a, 00, 01, 0e, 00, 23]


The actual cov-map differed from the expected cov-map

error: an error occurred comparing coverage output.
status: exit status: 0
command: "/checkout/obj/build/aarch64-unknown-linux-gnu/stage1-tools-bin/coverage-dump" "/checkout/obj/build/aarch64-unknown-linux-gnu/test/coverage/unreachable.coverage-map/unreachable.ll"
--- stdout -------------------------------
Function name: unreachable::UNREACHABLE_CLOSURE::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0e, 30, 00, 45]
Number of files: 1
- file 0 => /checkout/tests/coverage/unreachable.rs
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 14, 48) to (start + 0, 69)
Highest counter ID seen: c0

Function name: unreachable::unreachable_function (unused)
Raw bytes (14): 0x[01, 01, 00, 02, 00, 10, 01, 00, 1a, 00, 01, 0e, 00, 23]
Number of files: 1
- file 0 => /checkout/tests/coverage/unreachable.rs
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Zero) at (prev + 16, 1) to (start + 0, 26)
- Code(Zero) at (prev + 1, 14) to (start + 0, 35)
Highest counter ID seen: (none)

Function name: unreachable::unreachable_intrinsic (unused)
Raw bytes (14): 0x[01, 01, 00, 02, 00, 15, 01, 00, 1b, 00, 01, 0e, 00, 2a]

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Jun 2, 2026

rustbot assigned nikomatsakis Jun 2, 2026

This comment has been minimized.

Sign in to view

sunny026 force-pushed the fix-mir-logical-ops branch from 33084fa to d5c3189 Compare June 2, 2026 13:53

This comment has been minimized.

Sign in to view

Optimize MIR CFG generation for logical operators

594756f

sunny026 force-pushed the fix-mir-logical-ops branch from d5c3189 to 594756f Compare June 2, 2026 14:04

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Optimize MIR CFG generation for chained logical operators (#83623)#157315

Optimize MIR CFG generation for chained logical operators (#83623)#157315
sunny026 wants to merge 1 commit into
rust-lang:mainfrom
sunny026:fix-mir-logical-ops

sunny026 commented Jun 2, 2026 •

edited by rustbot

Loading

Uh oh!

rustbot commented Jun 2, 2026

Uh oh!

rustbot commented Jun 2, 2026

Uh oh!

This comment has been minimized.

This comment has been minimized.

cjgillot commented Jun 2, 2026

Uh oh!

rust-log-analyzer commented Jun 2, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

Uh oh!

Conversation

sunny026 commented Jun 2, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

Changes

Result

Uh oh!

rustbot commented Jun 2, 2026

Uh oh!

rustbot commented Jun 2, 2026

Uh oh!

This comment has been minimized.

This comment has been minimized.

cjgillot commented Jun 2, 2026

Uh oh!

rust-log-analyzer commented Jun 2, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

sunny026 commented Jun 2, 2026 •

edited by rustbot

Loading