3

I would like to know if the following piece of code is going to throw an error or a warning upon compilation with any kind of gcc/g++ optimizations enabled.

int a;
a = func();
if (a == 2) {
    assert(false);
}

I think the following code can throw a warning "set but unused variable", in release configuration.

int a;
a = func();
assert(a != 2);

But what about the above code? (gcc can remove the if statement itself because nothing is going to be done either in the if-statement or in the if-block (in release build), and then throw a warning "unused but set variable" )

edit : this definitely is not a question regarding reducing the size of code or exe. I want to know a piece of code that succeeds in any build configuration.

edit: we disable assert in release mode

Improve this question
6
  • 1
    From what I've seen, gcc doesn't issue warnings about what happens to code after the optimizer runs. And I think it would be wrong to do so in fact. The purpose of warnings isn't to warn you that the optimizer makes things you're doing in your code superfluous. Commented Jun 22, 2012 at 7:51
  • @LuchianGrigore yes, I have tried with -0s -O3 etc. The compilation was successful. But I am not sure if there can exist some random configuration capable of failing the build. Commented Jun 22, 2012 at 7:54
  • @Omnifarious gcc can definitely issue extra warnings as a result of a more aggressive optimization. See here for more information. Commented Jun 22, 2012 at 7:56
  • @juanchopanza, that book is out of date, -Wuninitialized is enabled at -O0 now (but doesn't work very well, so still doesn't warn on that code, so your point holds) Commented Jun 22, 2012 at 7:58
  • 1
    @juanchopanza - nod My point is a bit more subtle than that. Yes, the optimizer will give you better quality warnings. But those warnings are not about what the code looked like after the optimizer finished operating on your code. They're about things it discovered in the code you originally had after it did a deeper analysis. Commented Jun 22, 2012 at 8:06

6 Answers 6

Reset to default
4

According to my tests, the following code generates a warning with -Wall -Wextra -O2 -DNDEBUG:

int a = func(); // warning: unused variable ‘a’
assert(a != 2);

But the following code does not:

// no warnings
int a;
a = func();
assert(a != 2);

However, you can always suppress unused variable warnings by casting to void.

int a = func();
(void) a; // suppresses "unused variable" warning
assert(a != 2);

As far as I can tell, the line a = func() statement always counts as use of the variable a, whereas initialization does not count as use.

I wouldn't try to hedge against future possible compiler warnings as compilers change and their diagnostics improve, since the hedges can sometimes suppress valid warnings by accident.

How is assert defined?

The standards committees and C implementers have designed assert carefully so it doesn't generate spurious warnings. Note how common casts to void are...

  • Without NDEBUG, glibc defines assert roughly in the following way (except with something other than abort):

    #define assert(expr) ((expr) ? (void) 0 : abort())

  • With NDEBUG, glibc defines it this way (as mandated by the C standard):

    #define assert(expr) ((void) 0)

  • The following definition of assert is not compliant, since it does not expand to an expression:

    #define assert(expr) { if (expr) { ... } } // wrong

The definitions are slightly different for C++, too. So you see, assert is defined in just the right way so it doesn't create any bogus compiler warnings, and it really does behave syntactically like a function call.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

This may cause problems if your assert is removed by the preprocessor, like this:

#ifdef ENABLE_ASSERT
#define assert (CONDITION) {if (!(CONDITION)) abort ();}
#else
#define assert (CONDITION) /* Nothing */
#endif

But, if you do it properly then there will be no problems:

#define assert (CONDITION) {if ((ENABLE_ASSERT) && !(CONDITION)) abort ();}

In this case the compiler will still see that a is used in CONDITION, but will optimize it away when ENABLE_ASSERT is zero. It's usually better to let the compiler optimizers remove code than using the preprocessor: it avoids warnings like this, and usually leads to more readable code, and the code doesn't need to be rewritten if it turns into a run-time test one day.

Obviously, ENABLE_ASSERT must always be defined to either zero or non-zero.

Improve this answer

5 Comments

With NDEBUG defined the C standard (7.2/1) requires #define assert(ignore) ((void)0)
Also, the assert macro must expand to a void expression, so compliant implementations are not permitted to implement it using an if statement.
@DietrichEpp: If that's a real problem for your code you can use an inline function instead of a macro. The compiler will optimise it away just the same.
@JonathanWakely: well, that's unhelpful!
@ams: The definition of the assert macro predates the existence of the inline keyword. Legacy code might be using #ifdef assert something of the sort, so defining it as a function would break old code. Them's the breaks.
1

It's not possible in general to say a piece of code will never get any warnings from a compiler, as new warnings could be added in future or compiler bugs could cause spurious warnings.

I'm pretty sure GCC will not warn for an empty if body defined with braces, precisely because that can easily happen in valid code, such as this (which is essentially very similar to your case):

int a = func();
if (a == 2)
{
#ifdef SOME_BUILD_SETTING
    launch_missiles();
#endif
}

The manual shows

-Wempty-body
  Warn if an empty body occurs in an if, else or do while statement. This warning is also enabled by -Wextra.

Which would apply for:

#ifdef SOME_BUILD_OPTION
# define LAUNCH_MISSILES launch_missiles()
#else
# define LAUNCH_MISSILES
#endif
if (a==2)
  LAUNCH_MISSILES;

Then compiled with -Wextra without SOME_BUILD_OPTION defined.

But with the braces it doesn't warn, and as Dietrich Epp comments, with assert it doesn't warn because it doesn't expand to nothing even with NDEBUG defined.

In your code a is initialized and its value is used, so I would be surprised for it to warn.

Improve this answer

2 Comments

if (a == 2) assert(false); will never generate an empty body warning, even with NDEBUG. When NDEBUG is defined, assert(false) will be expanded to (void) 0, which counts as a non-empty body even though it does nothing.
Good point, I should have tested exactly that code, not an approximation. Fixed now, thanks.
0

Both code blocks are ok, but i would prefere:

int a = func();
assert(a != 2);
Improve this answer

4 Comments

If he doesn't reuse a, he can even do assert(func() != 2);
@olchauvin: this can behave different in release mode when assertation are disabled - func() will not be called at all. But func may do some things (possibly increment call counter)
@Andrew there is nothing in the code to suggest the assert is disabled in release mode.
@Andrew You are right. I wrongly assumed that this was a unit test that wouldn't be put at all in the release.
0

As you probably know the assert macro is managed with the macro NDEBUG. I think something that uses an #ifdef NDEBUG would be easier to read and have the same effect.

Improve this answer

Comments

0

Yes, this code may emit warnings with some odd compiler setting at some point in time in the future.

Your question will never be answered in the affirmative. It can't be. The future is unpredictable. And even in the present, the number of compiler flags represents a combinatorial explosion that can be very difficult to fully analyze. Anybody who gave you a 'yes' answer to that is likely overlooking something.

Now, I will say that the compiler generally (in my experience) only issues warning for what your code actually looks like, not for what it looks like after the optimizer finishes with it. Yes, if you run the optimizer it may be able to do a deeper analysis and find more subtle problems. But it isn't going to start flagging you about a construct that's now superfluous because the optimizer was able to completely remove it.

So, I think you're mostly safe here, which is as close to a 'yes' as you're going to get from me.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.