MISRA C:2012 Rule 13.2

The value of an expression and its persistent side effects shall be the same under all permitted evaluation orders

Description

Rule Definition

The value of an expression and its persistent side effects shall be the same under all permitted evaluation orders.

Rationale

If an expression results in different values depending on the order of evaluation, its value becomes implementation-defined.

Polyspace Implementation

Polyspace^® raises a violation if an expression satisfies any of these conditions:

• The same variable is modified more than once in the expression or it is both read and written.

• The expression allows more than one order of evaluation.

• The expression contains a single volatile object that occurs multiple times.

• The expression contains more than one volatile object.

Because volatile objects can change their value at anytime, an expression containing multiple volatile variables or multiple instances of the same volatile variable might have different results depending on the order of evaluation.

Additional Message in Report

The value of 'XX' depends on the order of evaluation. The value of volatile 'XX' depends on the order of evaluation because of multiple accesses.

Troubleshooting

If you expect a rule violation but do not see it, refer to the documentation of Polyspace Code Prover™ or Polyspace Code Prover Server™.

Examples

Variable Modified More Than Once in Expression

int a[10], b[10];
#define COPY_ELEMENT(index) (a[(index)]=b[(index)])/* Noncompliant  */

void main () {
    int i=0, k=0;

    COPY_ELEMENT (k);         /* Compliant */
    COPY_ELEMENT (i++);}

In this example, the rule is violated by the statement COPY_ELEMENT(i++) because i++ occurs twice and the order of evaluation of the two expressions is unspecified.

Variable Modified and Used in Multiple Function Arguments

void f (unsigned int param1, unsigned int param2) {}

void main () {
    unsigned int i=0;
    f ( i++, i );                 /* Non-compliant */
}

In this example, the rule is violated because it is unspecified whether the operation i++ occurs before or after the second argument is passed to f. The call f(i++,i) can translate to either f(0,0) or f(0,1).

Multiple volatile Variables in Expression

struct {
	volatile float x; 
	volatile float y; 
} volData;

float xCopy;
float yCopy;
float res, res2;

void function4(void) {
	res = volData.x + volData.y;         //Noncompliant
	res = volData.x * volData.x;	  //Noncompliant
	xCopy = volData.x;
	yCopy = volData.y;
	res = xCopy + yCopy;  //Compliant
}  

In this example, the expression volData.x + volData.y is noncompliant because the expression involves multiple volatile objects. The expression consists of three operations: accessing the value of volData.x, accessing the value of volData.y, and the addition. The values of the volatile fields x and y in the volData structure might change at any time. The value of res might vary depending on which variable is read first. Because the C standard does not specify the order in which the variables are read, the value of res might depend on the hardware and software that you use. Polyspace flags one of the volatile objects in the expression. Similarly, Polyspace flags one of the volatile objects in the expression volData.x * volData.x.

To avoid the violation, assign the volatile variables to nonvolatile temporary variables and use these temporary variables in the expression.

Check Information

Group: Side Effects

Category: Required

AGC Category: Required