MISRA C:2012 Rule 13.5

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

Description

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

Rationale

The right operand of the || operator is not evaluated if the left operand is true. The right operand of the && 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.

Polyspace Implementation

The rule checker reports situations where the right side of a logical || or && operator has persistent side effects. For instance, if the right 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 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 performs only 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 checker determines that the callee is a pure function, then the calling function is considered 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. Polyspace does not report a violation 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

PQL Name: std.misra_c_2012.R13_5

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.