CODEWITHSUNDEEP
c++cgcccompiler-warningssequence-points
halex
halex

Reputation: 16403

Why does gcc not give a warning at undefined behaviour in code inside?

I just read this SO C++ FAQ about undefined behavior and sequence points and experimented a bit. In the following code gcc-4.5.2 gives me a warning only in the line mentioned in the code comment, although the one line before shows undefined behaviour too, doesn't it? You can't say which operand of addition is executed first (as + is no sequence point). Why does gcc not give me a warning in this line too?

int i=0;
int j=0;

int foo(void) {
    i=1;
    return i;
}

int main(void) {
    i = i + foo(); 
    j = j + (j=1); //Here is a rightly warning
    return 0;
}

Thank you for helping.

Upvotes: 7

Views: 1878

Answers (3)

Pascal Cuoq
Pascal Cuoq

Reputation: 80276

The line i = i + foo(); in your program is unspecified but not undefined.

Compilers try to emit warnings without false positives (every time the compiler warn, there is a defect that the programmer should fix), or at least with very low rates of false positives. This means that in exchange, they have quite a few false negatives. In keeping with the same philosophy, compilers usually do not warn for unspecified behaviors.

To get a warning about your program, you should look into static analyzers, which are more aggressive about warnings, at the cost of slightly more false positives. Static analyzers can very well decide to warn about unspecified behaviors. Some of them even warn about defined behaviors that, although being defined, indicate that the programmer was probably confused.

Upvotes: 2

bert-jan
bert-jan

Reputation: 968

It is visible to humans that calling foo() would alter i, but for a computer programme it is hard to see. It's just not designed to see this.

Upvotes: -6

user743382
user743382

Reputation:

The behaviour of i = i + foo(); is unspecified but not undefined. Undefined means any possible behaviour is permitted, even aborting the program. Unspecified means either i is evaluated first, or foo(). Yes, foo writes to that same i, but since it happens in a separate statement, there is a sequence point before and after that store.

Upvotes: 17

Related Questions