if 0 is compiled in c program

Question

I'm trying to removed unused code from my program - I can't delete the code for now, I just want to disable it for a start.

Let's say that I have the following code:

if (cond){
  doSomething()
}

and cond is always false so doSomething is never called.

I want to do something like:

#define REMOVE_UNUSED_CODE 0
if (cond && REMOVE_UNUSED_CODE){
  doSomething()
}

Now this is obvious to us (and hopefully for the compiler) that this code is unused.

Will the compiler remove all this if condition or it will leave it and never get in?

P.S.: I can't use #if 0 for this purpose

Answer 1

GCC will explicitly remove conditional blocks that have a constant expression controlling them, and the GNU coding standards explicitly recommend that you take advantage of this, instead of using cruder methods such as relying on the preprocessor. Although using preprocessor #if may seem more efficient because it removes code at an earlier stage, in practice modern optimizers work best when you give them as much information as possible (and of course it makes your program cleaner and more consistent if you can avoid adding a phase-separation dependency at a point where it isn't necessary).

Decisions like this are very, very easy for a modern compiler to make - even the very simplistic TCC will perform some amount of dead-code elimination; powerful systems like LLVM and GCC will spot this, and also much more complex cases that you, as a human reader, might miss (by tracing the lifetime and modification of variables beyond simply looking at single points).

This is in addition to other advantages of full compilation, like the fact that your code within the if will be checked for errors (whereas #if is more useful for removing code that would be erroneous on your current system, like references to nonexistent platform functions).

Answer 2

Try

#ifndef REMOVE_UNUSED_CODE
if (cond) {
   doSomething();
}
#endif

Instead. Don't forget to do a

#define REMOVE_UNUSED_CODE

somewhere.

Answer 3

The answer depends on the implementation of the compiler. You should never depend on this.

Instead be explicit:

#define REMOVE_UNUSED_CODE 0
if (cond && REMOVE_UNUSED_CODE){
#ifndef REMOVE_UNUSED_CODE  
   doSomething()
#endif
}

Answer 4

Looking at this snippet of your code

#define REMOVE_UNUSED_CODE 0

if(cond && REMOVE_UNUSED_CODE)
{
    doSomething();
}

REMOVE_UNUSED_CODE is replaced with 0 by preprocessor before compilation. So if(cond && 0) will always be evaluated as false and will never be executed. So you can say, irrespective of what cond is, it will always be false.

So I'd rather prefer it doing this way:

//#define REMOVE_UNUSED_CODE 0

#ifdef REMOVE_UNUSED_CODE
    if(cond)
    {
        doSomething();
    }
#endif

Answer 5

You should not do it that way:

Suppose you have a function bool f(void* input) with side effects.

Then with

if( f(pointer) && false ) { ... }

the body is not evaluated, but f should be.

In the case of

if( false && f(pointer) ) { ... }

f is not evaluated because of the short-cut rule of the &&operator.

If you use

#define REMOVE_UNUSED_CODE
#ifndef REMOVE_UNUSED_CODE
if( f(pointer) && false ) { }

#endif

the whole code is not even compiled in and will never be executed.

Answer 6

Not a direct answer, but may be helpful. There are compiler-specific intrinsics to do code removal.

For MSVC, it is __assume(0)

For GCC/Clang, it is __builtin_unreachable().

Notice, however, that if you write something like:

if (cond){
  __builtin_unreachable();
  doSomething()
}

Your condition should never evaluate to true, otherwise behavior is undefined. Combining both && REMOVE_UNUSED_CODE and __builtin_unreachable() ensures that your code will be removed by the compiler.