CODEWITHSUNDEEP
c++cgccclangcompiler-warnings
Nick
Nick

Reputation: 10539

Why gcc and clang both don't emit any warning?

Suppose we have code like this:

int check(){
    int x = 5;

    ++x; /* line 1.*/

    return 0;
}

int main(){
    return check();
}

If line 1 is commented out and the compiler is started with all warnings enabled, it emits:

warning: unused variable ‘x’ [-Wunused-variable]

However if we un-comment line 1, i.e. increase x, then no warning is emitted.

Why is that? Increasing the variable is not really using it.

This happen in both GCC and Clang for both and .

Upvotes: 4

Views: 632

Answers (7)

Frankie_C
Frankie_C

Reputation: 4877

As per C standard ISO/IEC 9899:201x, expressions evaluation are always executed to allow for expression's side effects to be produced unless the compiler can't be sufficiently sure that removing it the program execution is not altered.

5.1.2.3 Program execution

In the abstract machine, all expressions are evaluated as specified by the semantics. An actual implementation need not evaluate part of an expression if it can deduce that its value is not used and that no needed side effects are produced (including any caused by calling a function or accessing a volatile object).

When removing the line

++x;

The compiler can deduce that the local variable x is defined and initialized, but not used.

When you add it, the expression itself can be considered a void expression, that must be evaluated for side effects, as stated in:

6.8.3 Expression and null statements

The expression in an expression statement is evaluated as a void expression for its side effects.

On the other hand to remove compiler warnings relative to unused variable is very common to cast the expression to void. I.e. for an unused parameter in a function you can write:

int MyFunc(int unused)
{
   (void)unused;
   ...
   return a;
}

In this case we have a void expression that reference the symbol unused.

Upvotes: 0

Sourav Ghosh
Sourav Ghosh

Reputation: 134336

Yes.

x++ is the same as x = x+1;, the assignment. When you are assigning to something, you possibly can not skip using it. The result is not discarded.

Also, from the online gcc manual, regarding -Wunused-variable option

Warn whenever a local or static variable is unused aside from its declaration.

So, when you comment the x++;, it satisfies the condition to generate and emit the warning message. When you uncomment, the usage is visible to the compiler (the "usefulness" of this particular "usage" is questionable, but, it's an usage, nonetheless) and no warning.

Upvotes: 6

geza
geza

Reputation: 29962

I agree with you, it could generate a warning about this. I think it doesn't generate a warning, because developers of the compilers just didn't bothered handling this case (yet). Maybe it is because it is too complicated to do. But maybe they will do this in the future (hint: you can suggest them this warning).

Compilers getting more and more warnings. For example, there is -Wunused-but-set-variable in GCC (which is a "new" warning, introduced in GCC 4.6 in 2011), which warns about this:

void fn() {
    int a;
    a = 2;
}

So it is completely fine to expect that this emits a warning too (there is nothing different here, neither codes do anything useful):

void fn() {
    int a = 1;
    a++;
}

Maybe they could add a new warning, like -Wmeaningless-variable

Upvotes: 1

bipson
bipson

Reputation: 64

I think there is a misconception about the word 'using' and what the compiler means with that. When you have a ++i you are not only accessing the variable, you are even modifying it, and AFAIK this counts as 'use'.

There are limitations to what the compiler can identify as 'how' variables are being used, and if the statements make any sense. In fact both clang and gcc will try to remove unnecessary statements, depending on the -O-flag (sometimes too aggressively). But these optimizations happen without warnings.

Detecting a variable that is never ever accessed or used though (there is no further statement mentioning that variable) is rather easy.

Upvotes: 1

eerorika
eerorika

Reputation: 238351

Why is that? increasing variable not really using it.

Yes, it is really using it. At least from the language point of view. I would hope that an optimizer removes all trace of the variable.

Sure, that particular use has no effect on the rest of the program, so the variable is indeed redundant. I would agree that warning in this case would be helpful. But that is not the purpose of the warning about being unused, that you mention.

However, consider that analyzing whether a particular variable has any effect on the execution of the program in general is quite difficult. There has to be a point where the compiler stops checking whether a variable is actually useful. It appears that the stages that generate warnings of the compilers that you tested only check whether the variable is used at least once. That once was the increment operation.

Upvotes: 1

Jesferman
Jesferman

Reputation: 1084

With the preincrement you are incrementing and assigning the value to the variable again. It is like:

x=x+1

As the gcc documentation says:

-Wunused-variable: Warn whenever a local or static variable is unused aside from its declaration.

If you comment that line you are not using the variable aside of the line in which you declare it

Upvotes: 4

user2371524
user2371524

Reputation:

increasing variable not really using it.

Sure this is using it. It's doing a read and a write access on the stored object. This operation doesn't have any effect in your simple toy code, and the optimizer might notice that and remove the variable altogether. But the logic behind the warning is much simpler: warn iff the variable is never used.

This has actually the benefit that you can silence that warning in cases where it makes sense:

void someCallback(void *data)
{
    (void)data; // <- this "uses" data

    // [...] handler code that doesn't need data
}

Upvotes: 3

Related Questions