simplify expressions of branches

Author: Swatinem

compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs

@@ -159,6 +159,16 @@ impl<'tcx> FunctionCoverage<'tcx> {
         // can have those operands replaced with `Operand::Zero`.
         let mut zero_expressions = FxIndexSet::default();
 
+        // If an operand refers to an expression that is always zero, then
+        // that operand can be replaced with `Operand::Zero`.
+        let maybe_set_operand_to_zero =
+            |zero_expressions: &FxIndexSet<ExpressionId>, operand: &mut Operand| match &*operand {
+                Operand::Expression(id) if zero_expressions.contains(id) => {
+                    *operand = Operand::Zero;
+                }
+                _ => (),
+            };
+
         // For each expression, perform simplifications based on lower-numbered
         // expressions, and then update the set of always-zero expressions if
         // necessary.
@@ -172,16 +182,8 @@ impl<'tcx> FunctionCoverage<'tcx> {
                 continue;
             };
 
-            // If an operand refers to an expression that is always zero, then
-            // that operand can be replaced with `Operand::Zero`.
-            let maybe_set_operand_to_zero = |operand: &mut Operand| match &*operand {
-                Operand::Expression(id) if zero_expressions.contains(id) => {
-                    *operand = Operand::Zero;
-                }
-                _ => (),
-            };
-            maybe_set_operand_to_zero(&mut expression.lhs);
-            maybe_set_operand_to_zero(&mut expression.rhs);
+            maybe_set_operand_to_zero(&zero_expressions, &mut expression.lhs);
+            maybe_set_operand_to_zero(&zero_expressions, &mut expression.rhs);
 
             // Coverage counter values cannot be negative, so if an expression
             // involves subtraction from zero, assume that its RHS must also be zero.
@@ -196,6 +198,12 @@ impl<'tcx> FunctionCoverage<'tcx> {
                 zero_expressions.insert(id);
             }
         }
+
+        // Do the same simplification for each side of a branch region.
+        for branch in &mut self.branches {
+            maybe_set_operand_to_zero(&zero_expressions, &mut branch.true_);
+            maybe_set_operand_to_zero(&zero_expressions, &mut branch.false_);
+        }
     }
 
     /// Return the source hash, generated from the HIR node structure, and used to indicate whether

compiler/rustc_mir_transform/src/coverage/mod.rs

@@ -231,7 +231,9 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                 &mut debug_used_expressions,
             );
 
+            // TODO: if self.tcx.sess.instrument_coverage_branch() {
             self.inject_branch_counters(std::mem::take(branches));
+            // }
 
             ////////////////////////////////////////////////////
             // For any remaining `BasicCoverageBlock` counters (that were not associated with

tests/coverage-map/status-quo/async2.cov-map

@@ -128,18 +128,16 @@ Number of file 0 mappings: 1
 - Code(Counter(0)) at (prev + 35, 1) to (start + 7, 2)
 
 Function name: async2::non_async_func
-Raw bytes (35): 0x[01, 01, 02, 00, 00, 05, 00, 05, 01, 09, 01, 03, 09, 20, 05, 02, 03, 08, 00, 09, 05, 00, 0a, 02, 06, 00, 02, 06, 00, 07, 07, 01, 01, 00, 02]
+Raw bytes (33): 0x[01, 01, 01, 05, 00, 05, 01, 09, 01, 03, 09, 20, 05, 00, 03, 08, 00, 09, 05, 00, 0a, 02, 06, 00, 02, 06, 00, 07, 03, 01, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 2
-- expression 0 operands: lhs = Zero, rhs = Zero
-- expression 1 operands: lhs = Counter(1), rhs = Zero
+Number of expressions: 1
+- expression 0 operands: lhs = Counter(1), rhs = Zero
 Number of file 0 mappings: 5
 - Code(Counter(0)) at (prev + 9, 1) to (start + 3, 9)
-- Branch { true: Counter(1), false: Expression(0, Sub) } at (prev + 3, 8) to (start + 0, 9)
-    false = (Zero - Zero)
+- Branch { true: Counter(1), false: Zero } at (prev + 3, 8) to (start + 0, 9)
 - Code(Counter(1)) at (prev + 0, 10) to (start + 2, 6)
 - Code(Zero) at (prev + 2, 6) to (start + 0, 7)
-- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
+- Code(Expression(0, Add)) at (prev + 1, 1) to (start + 0, 2)
     = (c1 + Zero)