Evaluation Order of C Language

Question

1. Is x+=x*=x undefined behavior?
2. Can anyone explain this rule in Order of evaluation? What is "single evaluation"? What is the opposite of "single evaluation"?

   14) With respect to an indeterminately-sequenced function call, the operation of compound assignment operators, and both prefix and postfix forms of increment and decrement operators are single evaluations.

Answer 1

x+=x*=x has undefined behaviour because x is assigned to twice between sequence points.

---

The text corresponding to 14) in C11, C17 says

A compound assignment of the form E1 op= E2 is equivalent to the simple assignment expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with respect to an indeterminately-sequenced function call, the operation of a compound assignment is a single evaluation.

What I believe it means is that

int x = 0;

int foo(void) {
    x = 5;
    return x;
}

int main(void) {
    int y = foo() + (x += 2); 
}

will have either the behaviour of

int main(void) {
    int _tmp = x += 2;
    int y = foo() + _tmp; 
}

or

int main(void) {
    int _tmp = foo();
    int y = _tmp + (x += 2); 
}

and cannot be split to for example

int main(void) {
    int _tmp = x;
    int _tmp2 = foo();
    x = _tmp + 2;
    int y = _tmp2 + x; 
}

Note that this guarantee is new in C11, and it does not exist in C89, C99.

Answer 2

1) Yes.

C17 6.5.16 Assignment operators, §3

The evaluations of the operands are unsequenced.

Which makes it UB because of C17 6.5 §2

If a side effect on a scalar object is unsequenced relative to either a different side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined.

Every assignment is a side effect. C99 had the same rule but it was much easier to understand:

C99 6.5 §2

Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. Furthermore, the prior value shall be read only to determine the value to be stored.

---

2) All the text with C11 sequencing changes is rather confusing to read. They use terms that aren't formally defined anywhere, such as "single evaluation".

The normative text is C17 6.5.15.2 §3

A compound assignment of the form E1 op= E2 is equivalent to the simple assignment expression E1 = E1 op (E2), except that the lvalue E1 is evaluated only once, and with respect to an indeterminately-sequenced function call, the operation of a compound assignment is a single evaluation.

I suppose that this simply means that an operation like int x; ... x += 1 should result in machine code like:

• Store 1 in register
• Add x to register
• Write register to x

Otherwise, suppose something gets sequences in between those operations that updates x. But compound assignment isn't atomic no matter, so I don't quite understand what the standard is after here.