Is there a gcc warning for "conditional expression is constant"?

Question

I've inherited a sizeable codebase where someone, somehow, has written several conditionals like so:

enum
{
    FOO_TYPE_A,
    FOO_TYPE_B,
    FOO_TYPE_C,
    FOO_TYPE_D
};

void bar(int fooType)
{
    if (fooType == FOO_TYPE_A || FOO_TYPE_B) // <-- This will always be true, since FOO_TYPE_B is nonzero!
    {
        // Do something intended for only type A or B
    }

    // Do things general to A,B,C,D
}

where the condition check should clearly be:

    if (fooType == FOO_TYPE_A || fooType  == FOO_TYPE_B)

Is there a warning in gcc I can turn on to find them all, similar to MSDN's C4127?

Specifically, I'm using the Android NDK r9d.

If not, why not? It seems like a useful catch-all for unintentional assignment, unsigned > 0 as well as the above foolishness.

EDIT: Made the code more verbose to illustrate the problem.

Also, you can always try `g++ -Wpedantic -Wextra` and see what the gcc can possibly complain about. — oakad, Apr 04 '14 at 02:23
The C4127 warning is more for something like `if (CONSTANT_1 == CONSTANT_2)` isn't it? — Edward, Apr 04 '14 at 02:36
Possible duplicate [Why MSVC generates warning C4127 whan constant is used in "while" - C](http://stackoverflow.com/q/3490823) — Joseph Quinsey, Apr 04 '14 at 03:26
I've updated my example to contrast what's there with what should be there. — etheranger, Apr 04 '14 at 03:56
@Edward C4127 will fire on `if(1)`, which is what this simplifies to. — etheranger, Apr 04 '14 at 04:00
@etheranger ah, now I see. It wasn't clear at first that `CONSTANT_2` couldn't be zero. — Edward, Apr 04 '14 at 14:30

score 2 · Accepted Answer · answered Apr 10 '14 at 21:32

I do not see a warning that corresponds to MSDN C4127. GCC does have a warning that is somewhat similar in intent, but not to address your problem: -Wtype-limits

Warn if a comparison is always true or always false due to the limited range of the data type, but do not warn for constant expressions. For example, warn if an unsigned variable is compared against zero with < or >=. This warning is also enabled by -Wextra.

As you can see, GCC explicitly states it does not warn about constant expressions. The motivation for this may be due to the common use of constant expressions to leverage the compiler's dead code elimination so that macros (or portions of it) can be optimized away by using a compile time constant. It would be used as an alternative to conditional compilation (#if defined() and #if X == Y), as the macro reads more naturally like a regular function. As a hypothetical example:

#define VERIFY(E) \
do { \
    if (NO_VERIFY) break; \
    if (!(E) && (VERIFY_LOG_LEVEL >= log_level() || VERIFY_LOG_ALWAYS)) { \
        log("validation error for: " #E); \
    } \
} while (0)

I agree that such a hypothetical warning shouldn't be on by default, but there are always situations when some warnings will fire spuriously (parameters unused in debug builds, anyone?). That doesn't mean it wouldn't be helpful to have the option. In any case, this is as good an answer as possible, so I'll accept it. — etheranger, Apr 10 '14 at 23:52

WinCloud · Answer 2 · 2014-04-04T03:18:38.810

-1

I think the problem is that variable is a define or a const. CONSTANT_2 is a non-zero constant also make this problem.

edited Apr 04 '14 at 03:18

answered Apr 04 '14 at 02:35

WinCloud

183
7

I think he speaking about `|| CONSTANT_2` it should turn into `if(.. || 2)` in this case a warning could be useful – The Mask Apr 04 '14 at 02:56
Sorry for my poor English, and didn't read the question serious. I think the problem is that variable is a define or a const. CONSTANT_2 is a non-zero constant also make this problem. – WinCloud Apr 04 '14 at 03:14

Is there a gcc warning for "conditional expression is constant"?

2 Answers2

Linked