Evaluation order, sequence points and undefined behaviour

Why it exists

Look at i = i++ + ++i;. Students try to compute a number, and some textbooks even give one. The honest answer is that the C language gives no meaning to this line at all. The standard deliberately leaves the order of some operations open, and it forbids certain combinations altogether, so that compilers can optimise freely. If you do not know which situations are defined, implementation-defined, unspecified or undefined, you cannot tell whether a GATE question has an answer.

Prerequisites

Precise definitions

C11 section 3.4 defines three kinds of behaviour that are not fully determined by the standard (implementation-defined, undefined, unspecified). "Well-defined" is just the everyday word for everything else. Learn the vocabulary exactly:

• Well-defined. The standard says what happens, so the observable result is the same on every conforming compiler.
• Implementation-defined. The standard allows several results, but each compiler must document its choice. Examples: the size of int, whether plain char is signed, the result of right-shifting a negative number, the result of converting an out-of-range value to a signed type.
• Unspecified. The standard allows two or more results and does not require the compiler to say which, nor to be consistent. The program is still valid and some allowed result occurs. Example: the order in which the arguments of a function call, or the operands of +, are evaluated.
• Undefined behaviour (UB). The standard imposes no requirements at all. The compiler may ignore the situation with unpredictable results, behave in a documented way, or terminate with a diagnostic. In practice the program may crash, print anything, appear to work, or behave differently after you change the compiler flags. Examples: signed overflow, division by zero, out-of-bounds access, dereferencing a null or dangling pointer, modifying a string literal, modifying an object twice without sequencing.

Sequence point. A point in the execution at which all side effects (changes to variables) of everything evaluated so far have finished, and no side effect of anything later has begun. The sequence points you need:

1. At the end of a full expression: the ; of an expression statement, an initialiser, the controlling expression of if, switch, while, do, each of the three expressions in a for (...) header, and a return expression.
2. After the first operand of &&, ||, the ?: condition, and the comma operator ,.
3. After all arguments of a function call have been evaluated, just before the function runs.
4. At the end of a full declarator in a declaration (int a = 1, b = a; is fine).

Note that the commas separating function arguments are not the comma operator, so they give no sequencing between the arguments.

The rule. The classic form (C89 and C99, and the one GATE questions use): between two sequence points, a scalar object may be modified at most once, and if it is modified, any other read of it must be only to compute the value to be stored. Break it and the behaviour is undefined. C11 6.5p2 states the same idea with sequenced-before: if a side effect on a scalar object is unsequenced relative to another side effect on the same object, or to a read of its value, the behaviour is undefined. If the operands can be evaluated in several allowed orders, it is undefined when the clash occurs in any of the orders.

How it works

Below are real programs, each compiled and run for real at several optimisation levels and under the sanitizers. Pick a tab, read the source, and look at what each setting did. Where the settings agree, that proves nothing; where they disagree, or a sanitizer objects, you are seeing undefined behaviour at work.

#include <stdio.h>
int f(void) { printf("f "); return 1; }
int g(void) { printf("g "); return 2; }
int main(void) {
    printf("%d %d\n", f(), g());
    int s = f() + g();
    printf("%d\n", s);
    return 0;
}

g f 1 2
f g 3

g f 1 2
f g 3

g f 1 2
f g 3

g f 1 2
f g 3

Some things to see:

• Argument order. For printf("%d %d\n", f(), g()) this gcc ran g before f, yet for f() + g() it ran f first. Both are allowed. Another compiler may do the opposite, and so can the same compiler tomorrow.
• i = i++ + ++i. gcc itself warns that "operation on 'i' may be undefined" and, in this run, printed the same number at every level. That agreement is an accident of one compiler and carries no guarantee.
• Signed overflow printed a wrapped number without the sanitizer. Under UBSan it is reported as a runtime error, because the standard says the program already broke the rules.
• Array out of bounds printed 3 at one level and 32767 at another, and AddressSanitizer stops it. The element read is simply whatever sits in memory next to the array.

Worked examples

#include <stdio.h>
 
int main(void) {
    int i = 0;
    if (i++ == 0 && i++ == 1) printf("both ");
    printf("%d\n", i);
    return 0;
}

both 2

#include <stdio.h>
 
int main(void) {
    int a = 1;
    int r = (a++, a++, a);
    printf("%d %d\n", r, a);
    return 0;
}

3 3

#include <stdio.h>
 
int main(void) {
    int k = 0;
    int r = (k++ ? 100 : -k);
    printf("%d %d\n", r, k);
    return 0;
}

-1 1

#include <stdio.h>
 
int sq(int x) {
    return x * x;
}
 
int main(void) {
    int r = sq(2) + sq(3);
    printf("%d\n", r);
    return 0;
}

13

Cheat box

Traps and GATE patterns

Connections

The same idea that "the language does not fix this order" appears in compilers as the evaluation orders of attributes in syntax-directed definitions. Many undefined-behaviour examples (out-of-range indexing, use after free) come from arrays and dynamic memory.

PYQs

Consider the following ANSI C program.
  #include <stdio.h>
   int main()
{
int i, j, count;
count = 0;
i = 0;
for (j = –3, j <= 3; j++)

{
 if ((j >= 0) && (i++))
 count = count + j;

}
count = count + i;
printf("%d", count);
   return 0;
}

Which of one of the following options is correct?

Consider the following C program. Assume
parameters to a function are evaluated from right to
left.

 #include <stdio.h>
int g(int p) {
    printf("%d", p);
    return p;
}
int h(int q) {
    printf("%d", q);
    return q;
}
void f(int x, int y) {
    g(x);
    h(y);
}
int main() {
    f(g(10), h(20));
}
Which one of the following options is the CORRECT
output of the above C program?

Self-check

#include <stdio.h>
 
int main(void) {
    int a = 3;
    int r = (a > 2) ? a++ : a--;
    printf("%d %d\n", r, a);
    return 0;
}

3 4

#include <stdio.h>
 
int main(void) {
    int i = 1;
    i = (i++, i + 5);
    printf("%d\n", i);
    return 0;
}

7

Revision card

References