Coverage: Add condition coverage

compiler/rustc_mir_build/src/build/expr/into.rs

@@ -148,43 +148,90 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             ExprKind::LogicalOp { op, lhs, rhs } => {
                 let condition_scope = this.local_scope();
                 let source_info = this.source_info(expr.span);
-                // We first evaluate the left-hand side of the predicate ...
-                let (then_block, else_block) =
-                    this.in_if_then_scope(condition_scope, expr.span, |this| {
-                        this.then_else_break(
-                            block,
-                            lhs,
-                            Some(condition_scope), // Temp scope
-                            source_info,
-                            // This flag controls how inner `let` expressions are lowered,
-                            // but either way there shouldn't be any of those in here.
-                            true,
-                        )
-                    });
-                let (short_circuit, continuation, constant) = match op {
-                    LogicalOp::And => (else_block, then_block, false),
-                    LogicalOp::Or => (then_block, else_block, true),
+
+                let push_constant_bool = |this: &mut Builder<'a, 'tcx>, bb, dest, value| {
+                    this.cfg.push_assign_constant(
+                        bb,
+                        source_info,
+                        dest,
+                        ConstOperand {
+                            span: expr.span,
+                            user_ty: None,
+                            const_: Const::from_bool(this.tcx, value),
+                        },
+                    );
                 };
-                // At this point, the control flow splits into a short-circuiting path
-                // and a continuation path.
-                // - If the operator is `&&`, passing `lhs` leads to continuation of evaluation on `rhs`;
-                //   failing it leads to the short-circuting path which assigns `false` to the place.
-                // - If the operator is `||`, failing `lhs` leads to continuation of evaluation on `rhs`;
-                //   passing it leads to the short-circuting path which assigns `true` to the place.
-                this.cfg.push_assign_constant(
-                    short_circuit,
-                    source_info,
-                    destination,
-                    ConstOperand {
-                        span: expr.span,
-                        user_ty: None,
-                        const_: Const::from_bool(this.tcx, constant),
-                    },
-                );
-                let rhs = unpack!(this.expr_into_dest(destination, continuation, rhs));
+                // A simple optimization on boolean expression with short-circuit
+                // operators is to not create a branch for the last operand.
+                // Example:
+                //      let x: bool = a && b;
+                //  would be compiled into something semantically closer to
+                //      let x = if a { b } else { false };
+                //  rather than
+                //      let x = if a && b { true } else { false };
+                //
+                // In case `a` is true, evaluate `b` and assign it to `x`,
+                // thus there is no need to create an actual branch for `b`.
+                // Otherwise, assign false to `x`.
+                //
+                // The exception is when we instrument the code for condition coverage,
+                // which tracks the outcome of all operands of boolean expressions.
+
+                let (outcome1, outcome2) = if this.tcx.sess.instrument_coverage_condition() {
+                    // We first evaluate the left-hand side of the predicate ...
+                    let (then_block, else_block) =
+                        this.in_if_then_scope(condition_scope, expr.span, |this| {
+                            this.then_else_break(
+                                block,
+                                expr_id,
+                                Some(condition_scope), // Temp scope
+                                source_info,
+                                // This flag controls how inner `let` expressions are lowered,
+                                // but either way there shouldn't be any of those in here.
+                                true,
+                            )
+                        });
+
+                    // Write true on expression success...
+                    push_constant_bool(this, then_block, destination, true);
+                    // ...and false on failure.
+                    push_constant_bool(this, else_block, destination, false);
+
+                    (then_block, else_block)
+                } else {
+                    // We first evaluate the left-hand side of the predicate ...
+                    let (then_block, else_block) =
+                        this.in_if_then_scope(condition_scope, expr.span, |this| {
+                            this.then_else_break(
+                                block,
+                                lhs,
+                                Some(condition_scope), // Temp scope
+                                source_info,
+                                // This flag controls how inner `let` expressions are lowered,
+                                // but either way there shouldn't be any of those in here.
+                                true,
+                            )
+                        });
+                    let (short_circuit, continuation, constant) = match op {
+                        LogicalOp::And => (else_block, then_block, false),
+                        LogicalOp::Or => (then_block, else_block, true),
+                    };
+                    // At this point, the control flow splits into a short-circuiting path
+                    // and a continuation path.
+                    // - If the operator is `&&`, passing `lhs` leads to continuation of evaluation on `rhs`;
+                    //   failing it leads to the short-circuting path which assigns `false` to the place.
+                    // - If the operator is `||`, failing `lhs` leads to continuation of evaluation on `rhs`;
+                    //   passing it leads to the short-circuting path which assigns `true` to the place.
+                    push_constant_bool(this, short_circuit, destination, constant);
+
+                    let rhs = unpack!(this.expr_into_dest(destination, continuation, rhs));
+
+                    (short_circuit, rhs)
+                };
+
                 let target = this.cfg.start_new_block();
-                this.cfg.goto(rhs, source_info, target);
-                this.cfg.goto(short_circuit, source_info, target);
+                this.cfg.goto(outcome1, source_info, target);
+                this.cfg.goto(outcome2, source_info, target);
                 target.unit()
             }
             ExprKind::Loop { body } => {

compiler/rustc_session/src/config.rs

@@ -157,8 +157,24 @@ pub enum CoverageLevel {
     Block,
     /// Also instrument branch points (includes block coverage).
     Branch,
-    /// Instrument for MC/DC. Mostly a superset of branch coverage, but might
-    /// differ in some corner cases.
+    /// Same as branch condition, with a single different case:
+    /// In boolean expressions that are not inside a control-flow decision,
+    /// it will intentionally insert an instrumented branch for the last operand.
+    ///
+    /// Example:
+    /// ```
+    /// # let (a, b) = (false, true);
+    /// let x = a && b;
+    /// //           ^ last operand
+    /// ```
+    /// Condition coverage does track true/false coverage for `b`,
+    /// but branch coverage doesn't.
+    ///
+    /// The main purpose of this coverage level is to be reused by MCDC.
+    Condition,
+    /// Instrument for MC/DC. Enables condition coverage under the hood.
+    /// Mostly a superset of branch coverage, but might differ in some
+    /// corner cases.
     Mcdc,
 }
 

compiler/rustc_session/src/options.rs

@@ -948,6 +948,7 @@ mod parse {
             match option {
                 "block" => slot.level = CoverageLevel::Block,
                 "branch" => slot.level = CoverageLevel::Branch,
+                "condition" => slot.level = CoverageLevel::Condition,
                 "mcdc" => slot.level = CoverageLevel::Mcdc,
                 _ => return false,
             }

compiler/rustc_session/src/session.rs

@@ -353,6 +353,11 @@ impl Session {
             && self.opts.unstable_opts.coverage_options.level >= CoverageLevel::Branch
     }
 
+    pub fn instrument_coverage_condition(&self) -> bool {
+        self.instrument_coverage()
+            && self.opts.unstable_opts.coverage_options.level >= CoverageLevel::Condition
+    }
+
     pub fn instrument_coverage_mcdc(&self) -> bool {
         self.instrument_coverage()
             && self.opts.unstable_opts.coverage_options.level >= CoverageLevel::Mcdc

tests/coverage/branch/conditions.cov-map

@@ -0,0 +1,152 @@
+Function name: conditions::assign_3
+Raw bytes (73): 0x[01, 01, 09, 07, 0b, 05, 09, 0d, 11, 01, 05, 01, 05, 22, 11, 01, 05, 22, 11, 01, 05, 09, 01, 17, 01, 00, 28, 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]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 9
+- expression 0 operands: lhs = Expression(1, Add), rhs = Expression(2, Add)
+- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
+- expression 2 operands: lhs = Counter(3), rhs = Counter(4)
+- 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)
+Number of file 0 mappings: 9
+- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 40)
+- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
+    = ((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)
+    true  = c1
+    false = (c0 - c1)
+- Code(Expression(8, 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)
+    false = c4
+- Code(Expression(7, Sub)) at (prev + 0, 23) to (start + 0, 24)
+    = ((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))
+
+Function name: conditions::assign_3_bis
+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, 2c, 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]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 7
+- 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)
+Number of file 0 mappings: 9
+- Code(Counter(0)) at (prev + 28, 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)
+- Branch { true: Counter(1), false: Expression(6, 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)
+    true  = c2
+    false = (c1 - c2)
+- Code(Expression(4, Add)) at (prev + 0, 23) to (start + 0, 24)
+    = ((c1 - c2) + (c0 - c1))
+- Branch { true: Counter(3), false: Counter(4) } at (prev + 0, 23) to (start + 0, 24)
+    true  = c3
+    false = c4
+- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 1, 2)
+    = ((c2 + c3) + c4)
+
+Function name: conditions::assign_and
+Raw bytes (51): 0x[01, 01, 04, 09, 07, 0d, 0e, 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]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 4
+- expression 0 operands: lhs = Counter(2), rhs = Expression(1, Add)
+- expression 1 operands: lhs = Counter(3), rhs = Expression(3, Sub)
+- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
+- 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(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
+    false = (c0 - c1)
+- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
+- 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)))
+
+Function name: conditions::assign_or
+Raw bytes (51): 0x[01, 01, 04, 07, 0d, 05, 09, 01, 05, 01, 05, 07, 01, 12, 01, 00, 20, 03, 01, 09, 00, 0a, 01, 00, 0d, 00, 0e, 20, 05, 0e, 00, 0d, 00, 0e, 0e, 00, 12, 00, 13, 20, 09, 0d, 00, 12, 00, 13, 03, 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 = Counter(3)
+- expression 1 operands: lhs = Counter(1), rhs = Counter(2)
+- expression 2 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
+Number of file 0 mappings: 7
+- Code(Counter(0)) at (prev + 18, 1) to (start + 0, 32)
+- Code(Expression(0, Add)) at (prev + 1, 9) to (start + 0, 10)
+    = ((c1 + c2) + c3)
+- 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
+    false = (c0 - c1)
+- Code(Expression(3, Sub)) at (prev + 0, 18) to (start + 0, 19)
+    = (c0 - c1)
+- 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)
+    = ((c1 + c2) + c3)
+
+Function name: conditions::foo
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
+
+Function name: conditions::func_call
+Raw bytes (39): 0x[01, 01, 03, 01, 05, 09, 0b, 0d, 02, 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]
+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(2), rhs = Expression(2, Add)
+- expression 2 operands: lhs = Counter(3), rhs = Expression(0, Sub)
+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)
+    true  = c1
+    false = (c0 - c1)
+- Code(Counter(1)) at (prev + 0, 14) to (start + 0, 15)
+- 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)))
+
+Function name: conditions::simple_assign
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 08, 01, 03, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 8, 1) to (start + 3, 2)
+