MISRA C:2012 Rule 13.5

The right hand operand of a logical && or || operator shall not contain persistent side effects

Description

Rule Definition

The right hand operand of a logical && or || operator shall not contain persistent side effects¹ .

Rationale

The right operand of an || operator is not evaluated if the left operand is true. The right operand of an && operator is not evaluated if the left operand is false. In these cases, if the right operand modifies the value of a variable, the modification does not take place. Following the operation, if you expect a modified value of the variable, the modification might not always happen.

Polyspace Implementation

The rule checker reports situations where the right hand side of a logical || or && operator has persistent side effects. For instance, if the right hand side contains a function call and the function modifies a global variable, the rule checker reports a violation.

The rule checker does not report a violation if the right hand side contains a call to a pure function, that is, a function without side effects. The checker considers a function as pure if the function only performs simple operations such as:

• Reading a nonvolatile parameter or global variable.

• Writing to a local variable.

In addition to simple operations, if the function contains a call to another function, the checker attempts to determine if the callee is a pure function. If the callee is determined to be a pure function, the checker propagates this information and tags the calling function as a pure function (as long as the other operations in the calling function are simple operations).

The rule checker does not consider a function as pure if the function does one of the following:

• Writes to a global variable or the dereference of a parameter.

• Reads or writes to a volatile variable, or contains an asm block.

To determine if a function is pure, the checker needs to analyze the function definition. The checker looks for function definitions only within the same translation unit as the function call (a translation unit is a source file plus all headers included in the source). If a function definition is not found in the current translation unit, the checker does not report a violation of this rule. The checker also does not analyze functions called via function pointers.

If the right operand of the logical || or && operator invokes a function by using a function pointer, Polyspace^® cannot determine whether the invoked function has side effects. No violations are reported in this case.

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Right Operand of Logical Operator with Persistent Side Effects

int check (int arg) {
    static int count;
    if(arg > 0) {
        count++;                   /* Persistent side effect */
        return 1;
    }
    else
        return 0;
}

int getSwitch(void);
int getVal(void);

void main(void) {
    int val = getVal();
    int mySwitch = getSwitch();
    int checkResult;

    if(mySwitch && check(val)) {   /* Non-compliant */
    }

    checkResult = check(val);
    if(checkResult && mySwitch) {  /* Compliant */
    }
    
    if(check(val) && mySwitch) {   /* Compliant */
    }
}

In this example, the rule is violated when the right operand of the && operation contains a function call. The function call has a persistent side effect because the static variable count is modified in the function body. Depending on mySwitch, this modification might or might not happen.

The rule is not violated when the left operand contains a function call. Alternatively, to avoid the rule violation, assign the result of the function call to a variable. Use this variable in the logical operation in place of the function call.

Check Information

Group: Side Effects

Category: Required

AGC Category: Required

Version History

Introduced in R2014b

R2025a: Violation not reported if only side effect is modifying errno

Polyspace does not report a violation if the right operand of a logical && or || operator has no side effects other than modifying errno.

R2023b: Reading volatile variable counted as persistent side effect

If the right operand of a logical && or || operator contains volatile variables, the rule checker reports a violation.

R2023a: Improved detection of pure functions

The rule checker no longer reports a violation of this rule in these situations.

• The right side operand of a logical && or || operator contains a call to a function, for example, A(), and Polyspace considers A() to be pure.

• If A() calls another function, for example, B(), and Polyspace considers B() to be pure.

Previously, the checker reported a violation if the right operand of a logical && or || operator contained a function call, whether pure or not. For more information on how the checker detects pure functions, see MISRA C:2012 Rule 13.5.